From a3b61beb275534993ce885573f2f7abb246d9987 Mon Sep 17 00:00:00 2001
From: Sergio Vega <svegaxmr@gmail.com>
Date: Tue, 24 Jul 2018 16:19:09 -0500
Subject: [PATCH 001/322] add cursor seek for MDB_GET_BOTH

---
 src/main/java/org/lmdbjava/Cursor.java | 31 ++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/src/main/java/org/lmdbjava/Cursor.java b/src/main/java/org/lmdbjava/Cursor.java
index 9950cde5..c0293a08 100644
--- a/src/main/java/org/lmdbjava/Cursor.java
+++ b/src/main/java/org/lmdbjava/Cursor.java
@@ -125,6 +125,37 @@ public boolean first() {
     return seek(MDB_FIRST);
   }
 
+  /**
+   * Reposition the key/value buffers based on the passed key and operation.
+   *
+   * @param key to search for
+   * @param data to search for
+   * @param op  options for this operation
+   * @return false if key not found
+   */
+  public boolean get(final T key, final T data, final SeekOp op) {
+    if (SHOULD_CHECK) {
+      requireNonNull(key);
+      requireNonNull(op);
+      checkNotClosed();
+      txn.checkReady();
+    }
+    kv.keyIn(key);
+    kv.valIn(data);
+
+    final int rc = LIB.mdb_cursor_get(ptrCursor, kv.pointerKey(), kv
+                                      .pointerVal(), op.getCode());
+
+    if (rc == MDB_NOTFOUND) {
+      return false;
+    }
+
+    checkRc(rc);
+    kv.keyOut();
+    kv.valOut();
+    return true;
+  }
+
   /**
    * Reposition the key/value buffers based on the passed key and operation.
    *

From 9815ffe4a3b671aa50934526af9fb47249701f71 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 8 Feb 2019 13:09:21 +1100
Subject: [PATCH 002/322] Manage addresses using Pointer.[g|s]etAddress(..)
 (#97)

---
 src/main/java/org/lmdbjava/ByteArrayProxy.java    |  4 ++--
 src/main/java/org/lmdbjava/ByteBufferProxy.java   | 12 ++++++------
 src/main/java/org/lmdbjava/DirectBufferProxy.java |  6 +++---
 src/test/java/org/lmdbjava/ByteBufProxy.java      | 10 +++++-----
 4 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/src/main/java/org/lmdbjava/ByteArrayProxy.java b/src/main/java/org/lmdbjava/ByteArrayProxy.java
index 7e64954d..a7213d09 100644
--- a/src/main/java/org/lmdbjava/ByteArrayProxy.java
+++ b/src/main/java/org/lmdbjava/ByteArrayProxy.java
@@ -94,7 +94,7 @@ protected final void in(final byte[] buffer, final Pointer ptr,
     final Pointer pointer = MEM_MGR.allocateDirect(buffer.length);
     pointer.put(0, buffer, 0, buffer.length);
     ptr.putLong(STRUCT_FIELD_OFFSET_SIZE, buffer.length);
-    ptr.putLong(STRUCT_FIELD_OFFSET_DATA, pointer.address());
+    ptr.putAddress(STRUCT_FIELD_OFFSET_DATA, pointer.address());
   }
 
   @Override
@@ -106,7 +106,7 @@ protected final void in(final byte[] buffer, final int size, final Pointer ptr,
   @Override
   protected final byte[] out(final byte[] buffer, final Pointer ptr,
                              final long ptrAddr) {
-    final long addr = ptr.getLong(STRUCT_FIELD_OFFSET_DATA);
+    final long addr = ptr.getAddress(STRUCT_FIELD_OFFSET_DATA);
     final int size = (int) ptr.getLong(STRUCT_FIELD_OFFSET_SIZE);
     final Pointer pointer = MEM_MGR.newPointer(addr, size);
     final byte[] bytes = new byte[size];
diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
index ba3f8206..ac313897 100644
--- a/src/main/java/org/lmdbjava/ByteBufferProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -225,7 +225,7 @@ private static final class ReflectiveProxy extends AbstractByteBufferProxy {
     @Override
     protected void in(final ByteBuffer buffer, final Pointer ptr,
                       final long ptrAddr) {
-      ptr.putLong(STRUCT_FIELD_OFFSET_DATA, address(buffer));
+      ptr.putAddress(STRUCT_FIELD_OFFSET_DATA, address(buffer));
       ptr.putLong(STRUCT_FIELD_OFFSET_SIZE, buffer.remaining());
     }
 
@@ -233,13 +233,13 @@ protected void in(final ByteBuffer buffer, final Pointer ptr,
     protected void in(final ByteBuffer buffer, final int size, final Pointer ptr,
                       final long ptrAddr) {
       ptr.putLong(STRUCT_FIELD_OFFSET_SIZE, size);
-      ptr.putLong(STRUCT_FIELD_OFFSET_DATA, address(buffer));
+      ptr.putAddress(STRUCT_FIELD_OFFSET_DATA, address(buffer));
     }
 
     @Override
     protected ByteBuffer out(final ByteBuffer buffer, final Pointer ptr,
                              final long ptrAddr) {
-      final long addr = ptr.getLong(STRUCT_FIELD_OFFSET_DATA);
+      final long addr = ptr.getAddress(STRUCT_FIELD_OFFSET_DATA);
       final long size = ptr.getLong(STRUCT_FIELD_OFFSET_SIZE);
       try {
         ADDRESS_FIELD.set(buffer, addr);
@@ -277,20 +277,20 @@ private static final class UnsafeProxy extends AbstractByteBufferProxy {
     protected void in(final ByteBuffer buffer, final Pointer ptr,
                       final long ptrAddr) {
       UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_SIZE, buffer.remaining());
-      UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_DATA, address(buffer));
+      UNSAFE.putAddress(ptrAddr + STRUCT_FIELD_OFFSET_DATA, address(buffer));
     }
 
     @Override
     protected void in(final ByteBuffer buffer, final int size, final Pointer ptr,
                       final long ptrAddr) {
       UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_SIZE, size);
-      UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_DATA, address(buffer));
+      UNSAFE.putAddress(ptrAddr + STRUCT_FIELD_OFFSET_DATA, address(buffer));
     }
 
     @Override
     protected ByteBuffer out(final ByteBuffer buffer, final Pointer ptr,
                              final long ptrAddr) {
-      final long addr = UNSAFE.getLong(ptrAddr + STRUCT_FIELD_OFFSET_DATA);
+      final long addr = UNSAFE.getAddress(ptrAddr + STRUCT_FIELD_OFFSET_DATA);
       final long size = UNSAFE.getLong(ptrAddr + STRUCT_FIELD_OFFSET_SIZE);
       UNSAFE.putLong(buffer, ADDRESS_OFFSET, addr);
       UNSAFE.putInt(buffer, CAPACITY_OFFSET, (int) size);
diff --git a/src/main/java/org/lmdbjava/DirectBufferProxy.java b/src/main/java/org/lmdbjava/DirectBufferProxy.java
index 28aa7ff1..105a74fb 100644
--- a/src/main/java/org/lmdbjava/DirectBufferProxy.java
+++ b/src/main/java/org/lmdbjava/DirectBufferProxy.java
@@ -130,7 +130,7 @@ protected void in(final DirectBuffer buffer, final Pointer ptr,
                     final long ptrAddr) {
     final long addr = buffer.addressOffset();
     final long size = buffer.capacity();
-    UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_DATA, addr);
+    UNSAFE.putAddress(ptrAddr + STRUCT_FIELD_OFFSET_DATA, addr);
     UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_SIZE, size);
   }
 
@@ -138,14 +138,14 @@ protected void in(final DirectBuffer buffer, final Pointer ptr,
   protected void in(final DirectBuffer buffer, final int size, final Pointer ptr,
                     final long ptrAddr) {
     final long addr = buffer.addressOffset();
-    UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_DATA, addr);
+    UNSAFE.putAddress(ptrAddr + STRUCT_FIELD_OFFSET_DATA, addr);
     UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_SIZE, size);
   }
 
   @Override
   protected DirectBuffer out(final DirectBuffer buffer, final Pointer ptr,
                              final long ptrAddr) {
-    final long addr = UNSAFE.getLong(ptrAddr + STRUCT_FIELD_OFFSET_DATA);
+    final long addr = UNSAFE.getAddress(ptrAddr + STRUCT_FIELD_OFFSET_DATA);
     final long size = UNSAFE.getLong(ptrAddr + STRUCT_FIELD_OFFSET_SIZE);
     buffer.wrap(addr, (int) size);
     return buffer;
diff --git a/src/test/java/org/lmdbjava/ByteBufProxy.java b/src/test/java/org/lmdbjava/ByteBufProxy.java
index 8826a76b..a11214fc 100644
--- a/src/test/java/org/lmdbjava/ByteBufProxy.java
+++ b/src/test/java/org/lmdbjava/ByteBufProxy.java
@@ -121,8 +121,8 @@ protected byte[] getBytes(final ByteBuf buffer) {
   protected void in(final ByteBuf buffer, final Pointer ptr, final long ptrAddr) {
     UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_SIZE,
                    buffer.writerIndex() - buffer.readerIndex());
-    UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_DATA,
-                   buffer.memoryAddress() + buffer.readerIndex());
+    UNSAFE.putAddress(ptrAddr + STRUCT_FIELD_OFFSET_DATA,
+                      buffer.memoryAddress() + buffer.readerIndex());
   }
 
   @Override
@@ -130,14 +130,14 @@ protected void in(final ByteBuf buffer, final int size, final Pointer ptr,
                     final long ptrAddr) {
     UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_SIZE,
                    size);
-    UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_DATA,
-                   buffer.memoryAddress() + buffer.readerIndex());
+    UNSAFE.putAddress(ptrAddr + STRUCT_FIELD_OFFSET_DATA,
+                      buffer.memoryAddress() + buffer.readerIndex());
   }
 
   @Override
   protected ByteBuf out(final ByteBuf buffer, final Pointer ptr,
                         final long ptrAddr) {
-    final long addr = UNSAFE.getLong(ptrAddr + STRUCT_FIELD_OFFSET_DATA);
+    final long addr = UNSAFE.getAddress(ptrAddr + STRUCT_FIELD_OFFSET_DATA);
     final long size = UNSAFE.getLong(ptrAddr + STRUCT_FIELD_OFFSET_SIZE);
     UNSAFE.putLong(buffer, ADDRESS_OFFSET, addr);
     UNSAFE.putInt(buffer, LENGTH_OFFSET, (int) size);

From c9d48670857657c83d1f282588f5db7cbf38866c Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 8 Feb 2019 13:14:40 +1100
Subject: [PATCH 003/322] AppVeyor test with Java 11

---
 appveyor.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/appveyor.yml b/appveyor.yml
index 156e098d..2623c2b0 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -5,7 +5,7 @@ image: Visual Studio 2017
 clone_depth: 50
 
 environment:
-  JAVA_HOME: "C:\\Program Files\\Java\\jdk1.8.0"
+  JAVA_HOME: "C:\\Program Files\\Java\\jdk11"
   MVN_VER: 3.6.0
   PYTHON: "C:\\Python35"
 

From cd48ecf6dd313ae2cd434b0598911e8ab5071097 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 8 Feb 2019 13:17:49 +1100
Subject: [PATCH 004/322] Update to LMDB native 0.9.23-1 (closes #115)

---
 pom.xml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/pom.xml b/pom.xml
index ce220f0e..36b83688 100644
--- a/pom.xml
+++ b/pom.xml
@@ -129,19 +129,19 @@
     <dependency>
       <groupId>org.lmdbjava</groupId>
       <artifactId>lmdbjava-native-linux-x86_64</artifactId>
-      <version>0.9.22-2</version>
+      <version>0.9.23-1</version>
       <optional>true</optional>
     </dependency>
     <dependency>
       <groupId>org.lmdbjava</groupId>
       <artifactId>lmdbjava-native-windows-x86_64</artifactId>
-      <version>0.9.22-2</version>
+      <version>0.9.23-1</version>
       <optional>true</optional>
     </dependency>
     <dependency>
       <groupId>org.lmdbjava</groupId>
       <artifactId>lmdbjava-native-osx-x86_64</artifactId>
-      <version>0.9.22-2</version>
+      <version>0.9.23-1</version>
       <optional>true</optional>
     </dependency>
     <dependency>

From a5ef8b55cc4b6a1af89325e6cd59b77ad96802ed Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 8 Feb 2019 14:08:32 +1100
Subject: [PATCH 005/322] Continue to use UNSAFE.[get|put]Long(..) (#97)

---
 src/main/java/org/lmdbjava/ByteBufferProxy.java   |  6 +++---
 src/main/java/org/lmdbjava/DirectBufferProxy.java |  6 +++---
 src/test/java/org/lmdbjava/ByteBufProxy.java      | 10 +++++-----
 3 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
index ac313897..3d358856 100644
--- a/src/main/java/org/lmdbjava/ByteBufferProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -277,20 +277,20 @@ private static final class UnsafeProxy extends AbstractByteBufferProxy {
     protected void in(final ByteBuffer buffer, final Pointer ptr,
                       final long ptrAddr) {
       UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_SIZE, buffer.remaining());
-      UNSAFE.putAddress(ptrAddr + STRUCT_FIELD_OFFSET_DATA, address(buffer));
+      UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_DATA, address(buffer));
     }
 
     @Override
     protected void in(final ByteBuffer buffer, final int size, final Pointer ptr,
                       final long ptrAddr) {
       UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_SIZE, size);
-      UNSAFE.putAddress(ptrAddr + STRUCT_FIELD_OFFSET_DATA, address(buffer));
+      UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_DATA, address(buffer));
     }
 
     @Override
     protected ByteBuffer out(final ByteBuffer buffer, final Pointer ptr,
                              final long ptrAddr) {
-      final long addr = UNSAFE.getAddress(ptrAddr + STRUCT_FIELD_OFFSET_DATA);
+      final long addr = UNSAFE.getLong(ptrAddr + STRUCT_FIELD_OFFSET_DATA);
       final long size = UNSAFE.getLong(ptrAddr + STRUCT_FIELD_OFFSET_SIZE);
       UNSAFE.putLong(buffer, ADDRESS_OFFSET, addr);
       UNSAFE.putInt(buffer, CAPACITY_OFFSET, (int) size);
diff --git a/src/main/java/org/lmdbjava/DirectBufferProxy.java b/src/main/java/org/lmdbjava/DirectBufferProxy.java
index 105a74fb..28aa7ff1 100644
--- a/src/main/java/org/lmdbjava/DirectBufferProxy.java
+++ b/src/main/java/org/lmdbjava/DirectBufferProxy.java
@@ -130,7 +130,7 @@ protected void in(final DirectBuffer buffer, final Pointer ptr,
                     final long ptrAddr) {
     final long addr = buffer.addressOffset();
     final long size = buffer.capacity();
-    UNSAFE.putAddress(ptrAddr + STRUCT_FIELD_OFFSET_DATA, addr);
+    UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_DATA, addr);
     UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_SIZE, size);
   }
 
@@ -138,14 +138,14 @@ protected void in(final DirectBuffer buffer, final Pointer ptr,
   protected void in(final DirectBuffer buffer, final int size, final Pointer ptr,
                     final long ptrAddr) {
     final long addr = buffer.addressOffset();
-    UNSAFE.putAddress(ptrAddr + STRUCT_FIELD_OFFSET_DATA, addr);
+    UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_DATA, addr);
     UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_SIZE, size);
   }
 
   @Override
   protected DirectBuffer out(final DirectBuffer buffer, final Pointer ptr,
                              final long ptrAddr) {
-    final long addr = UNSAFE.getAddress(ptrAddr + STRUCT_FIELD_OFFSET_DATA);
+    final long addr = UNSAFE.getLong(ptrAddr + STRUCT_FIELD_OFFSET_DATA);
     final long size = UNSAFE.getLong(ptrAddr + STRUCT_FIELD_OFFSET_SIZE);
     buffer.wrap(addr, (int) size);
     return buffer;
diff --git a/src/test/java/org/lmdbjava/ByteBufProxy.java b/src/test/java/org/lmdbjava/ByteBufProxy.java
index a11214fc..8826a76b 100644
--- a/src/test/java/org/lmdbjava/ByteBufProxy.java
+++ b/src/test/java/org/lmdbjava/ByteBufProxy.java
@@ -121,8 +121,8 @@ protected byte[] getBytes(final ByteBuf buffer) {
   protected void in(final ByteBuf buffer, final Pointer ptr, final long ptrAddr) {
     UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_SIZE,
                    buffer.writerIndex() - buffer.readerIndex());
-    UNSAFE.putAddress(ptrAddr + STRUCT_FIELD_OFFSET_DATA,
-                      buffer.memoryAddress() + buffer.readerIndex());
+    UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_DATA,
+                   buffer.memoryAddress() + buffer.readerIndex());
   }
 
   @Override
@@ -130,14 +130,14 @@ protected void in(final ByteBuf buffer, final int size, final Pointer ptr,
                     final long ptrAddr) {
     UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_SIZE,
                    size);
-    UNSAFE.putAddress(ptrAddr + STRUCT_FIELD_OFFSET_DATA,
-                      buffer.memoryAddress() + buffer.readerIndex());
+    UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_DATA,
+                   buffer.memoryAddress() + buffer.readerIndex());
   }
 
   @Override
   protected ByteBuf out(final ByteBuf buffer, final Pointer ptr,
                         final long ptrAddr) {
-    final long addr = UNSAFE.getAddress(ptrAddr + STRUCT_FIELD_OFFSET_DATA);
+    final long addr = UNSAFE.getLong(ptrAddr + STRUCT_FIELD_OFFSET_DATA);
     final long size = UNSAFE.getLong(ptrAddr + STRUCT_FIELD_OFFSET_SIZE);
     UNSAFE.putLong(buffer, ADDRESS_OFFSET, addr);
     UNSAFE.putInt(buffer, LENGTH_OFFSET, (int) size);

From 3e88ba9aaf68b6530332130c0dc0cf35c59bab70 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 8 Feb 2019 14:09:21 +1100
Subject: [PATCH 006/322] Update to Netty 4.1.33

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 36b83688..d7ee1a70 100644
--- a/pom.xml
+++ b/pom.xml
@@ -111,7 +111,7 @@
     <dependency>
       <groupId>io.netty</groupId>
       <artifactId>netty-all</artifactId>
-      <version>4.1.32.Final</version>
+      <version>4.1.33.Final</version>
       <scope>test</scope>
     </dependency>
     <dependency>

From 6617d80abe495187eca63bcfc8b2029ee00b07e9 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 8 Feb 2019 14:48:37 +1100
Subject: [PATCH 007/322] Ensure buffer returned by Netty is as expected

---
 src/test/java/org/lmdbjava/ByteBufProxy.java | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/test/java/org/lmdbjava/ByteBufProxy.java b/src/test/java/org/lmdbjava/ByteBufProxy.java
index 8826a76b..670a5d59 100644
--- a/src/test/java/org/lmdbjava/ByteBufProxy.java
+++ b/src/test/java/org/lmdbjava/ByteBufProxy.java
@@ -56,7 +56,10 @@ public final class ByteBufProxy extends BufferProxy<ByteBuf> {
   static {
     try {
       // create buffer (first is SimpleLeakAwareByteBuff but we need PooledUDBB)
-      DEFAULT.directBuffer(0);
+      final ByteBuf bb = DEFAULT.directBuffer(0);
+      if (!NAME.equals(bb.getClass().getName())) {
+        throw new IllegalStateException("Netty buffer must be " + NAME);
+      }
       final Field address = findField(NAME, FIELD_NAME_ADDRESS);
       final Field length = findField(NAME, FIELD_NAME_LENGTH);
       ADDRESS_OFFSET = UNSAFE.objectFieldOffset(address);

From a7f478bdd8083ee337c22cb9e6f2e7009a64b7a1 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 8 Feb 2019 15:05:14 +1100
Subject: [PATCH 008/322] Update to Agrona 0.9.32

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index d7ee1a70..38241b98 100644
--- a/pom.xml
+++ b/pom.xml
@@ -105,7 +105,7 @@
     <dependency>
       <groupId>org.agrona</groupId>
       <artifactId>agrona</artifactId>
-      <version>0.9.28</version>
+      <version>0.9.32</version>
       <optional>true</optional>
     </dependency>
     <dependency>

From 034f6100401ad233d81f3a180e67ff935f9bd141 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 8 Feb 2019 15:10:32 +1100
Subject: [PATCH 009/322] [maven-release-plugin] prepare release lmdbjava-0.6.3

---
 pom.xml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pom.xml b/pom.xml
index 38241b98..0821f8f2 100644
--- a/pom.xml
+++ b/pom.xml
@@ -8,7 +8,7 @@
   </parent>
   <groupId>org.lmdbjava</groupId>
   <artifactId>lmdbjava</artifactId>
-  <version>0.6.3-SNAPSHOT</version>
+  <version>0.6.3</version>
   <packaging>jar</packaging>
   <name>LmdbJava</name>
   <description>Low latency Java API for the ultra-fast, embedded Symas Lightning Database (LMDB)</description>
@@ -45,7 +45,7 @@
     <connection>scm:git:git@github.com:${github.org}/${github.repo}.git</connection>
     <developerConnection>scm:git:git@github.com:${github.org}/${github.repo}.git</developerConnection>
     <url>git@github.com:${github.org}/${github.repo}.git</url>
-    <tag>HEAD</tag>
+    <tag>lmdbjava-0.6.3</tag>
   </scm>
   <issueManagement>
     <system>GitHub Issues</system>

From 294dcf8113b5627ba8b27454eb51aed063f5a45a Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 8 Feb 2019 15:11:14 +1100
Subject: [PATCH 010/322] [maven-release-plugin] prepare for next development
 iteration

---
 pom.xml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pom.xml b/pom.xml
index 0821f8f2..a8bdbd43 100644
--- a/pom.xml
+++ b/pom.xml
@@ -8,7 +8,7 @@
   </parent>
   <groupId>org.lmdbjava</groupId>
   <artifactId>lmdbjava</artifactId>
-  <version>0.6.3</version>
+  <version>0.6.4-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>LmdbJava</name>
   <description>Low latency Java API for the ultra-fast, embedded Symas Lightning Database (LMDB)</description>
@@ -45,7 +45,7 @@
     <connection>scm:git:git@github.com:${github.org}/${github.repo}.git</connection>
     <developerConnection>scm:git:git@github.com:${github.org}/${github.repo}.git</developerConnection>
     <url>git@github.com:${github.org}/${github.repo}.git</url>
-    <tag>lmdbjava-0.6.3</tag>
+    <tag>HEAD</tag>
   </scm>
   <issueManagement>
     <system>GitHub Issues</system>

From 1fee606fdc8a1f99c6ce808c16e148585c87df02 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Thu, 21 Mar 2019 18:10:14 +1100
Subject: [PATCH 011/322] Update to Agrona 0.9.34

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index a8bdbd43..90f95710 100644
--- a/pom.xml
+++ b/pom.xml
@@ -105,7 +105,7 @@
     <dependency>
       <groupId>org.agrona</groupId>
       <artifactId>agrona</artifactId>
-      <version>0.9.32</version>
+      <version>0.9.34</version>
       <optional>true</optional>
     </dependency>
     <dependency>

From ee6ee3d4ce26251b98c26414c4744e741390a50d Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Thu, 21 Mar 2019 18:10:22 +1100
Subject: [PATCH 012/322] Update to Netty 4.1.34

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 90f95710..490b8b07 100644
--- a/pom.xml
+++ b/pom.xml
@@ -111,7 +111,7 @@
     <dependency>
       <groupId>io.netty</groupId>
       <artifactId>netty-all</artifactId>
-      <version>4.1.33.Final</version>
+      <version>4.1.34.Final</version>
       <scope>test</scope>
     </dependency>
     <dependency>

From 498db3dbbabbf1141909826434ce6285a94d0411 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Thu, 21 Mar 2019 18:10:29 +1100
Subject: [PATCH 013/322] Update to Guava 27.1

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 490b8b07..370f1f78 100644
--- a/pom.xml
+++ b/pom.xml
@@ -117,7 +117,7 @@
     <dependency>
       <groupId>com.google.guava</groupId>
       <artifactId>guava</artifactId>
-      <version>27.0.1-jre</version>
+      <version>27.1-jre</version>
       <scope>test</scope>
       <exclusions>
         <exclusion>

From ddf342eebfff0253f8c7a2c86434620c8ab025a1 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Thu, 21 Mar 2019 18:10:41 +1100
Subject: [PATCH 014/322] Update to Acegi Standard Project 0.2.1

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 370f1f78..ec1e6ac0 100644
--- a/pom.xml
+++ b/pom.xml
@@ -4,7 +4,7 @@
   <parent>
     <groupId>au.com.acegi</groupId>
     <artifactId>acegi-standard-project</artifactId>
-    <version>0.1.9</version>
+    <version>0.2.1</version>
   </parent>
   <groupId>org.lmdbjava</groupId>
   <artifactId>lmdbjava</artifactId>

From a927565b215421e0b5be1fb43a2fa09e0942610d Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 5 Apr 2019 12:46:56 +1100
Subject: [PATCH 015/322] Initial environment verifier (#124)

---
 src/main/java/org/lmdbjava/Verifier.java     | 307 +++++++++++++++++++
 src/test/java/org/lmdbjava/TutorialTest.java |  31 +-
 src/test/java/org/lmdbjava/VerifierTest.java |  57 ++++
 3 files changed, 394 insertions(+), 1 deletion(-)
 create mode 100644 src/main/java/org/lmdbjava/Verifier.java
 create mode 100644 src/test/java/org/lmdbjava/VerifierTest.java

diff --git a/src/main/java/org/lmdbjava/Verifier.java b/src/main/java/org/lmdbjava/Verifier.java
new file mode 100644
index 00000000..9ce5c008
--- /dev/null
+++ b/src/main/java/org/lmdbjava/Verifier.java
@@ -0,0 +1,307 @@
+/*-
+ * #%L
+ * LmdbJava
+ * %%
+ * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * %%
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * #L%
+ */
+
+package org.lmdbjava;
+
+import java.nio.ByteBuffer;
+import static java.nio.ByteOrder.BIG_ENDIAN;
+import java.util.ArrayList;
+import java.util.List;
+import static java.util.Objects.requireNonNull;
+import java.util.Random;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.zip.CRC32;
+import static org.lmdbjava.DbiFlags.MDB_CREATE;
+
+/**
+ * Verifies correct operation of LmdbJava in a given environment.
+ *
+ * <p>
+ * Due to the large variety of operating systems and Java platforms typically
+ * used with LmdbJava, this class provides a convenient verification of correct
+ * operating behavior through a potentially long duration set of tests that
+ * carefully verify correct storage and retrieval of successively larger
+ * database entries.
+ *
+ * <p>
+ * The verifier currently operates by incrementing a <code>long</code>
+ * identifier that deterministically maps to a given {@link Dbi} and value size.
+ * The key is simply the <code>long</code> identifier. The value commences with
+ * a CRC that includes the identifier and the random bytes of the value. Each
+ * entry is written out, and then the prior entry is retrieved using its key.
+ * The prior entry's value is evaluated for accuracy and then deleted.
+ * Transactions are committed in batches to ensure successive transactions
+ * correctly retrieve the results of earlier transactions.
+ *
+ * <p>
+ * Please note the verification approach may be modified in the future.
+ *
+ * <p>
+ * If an exception is raised by this class, please:
+ *
+ * <ol>
+ * <li>Ensure the {@link Env} passed at construction time complies with the
+ * requirements specified at {@link #Verifier(org.lmdbjava.Env)}</li>
+ * <li>Attempt to use a different file system to store the database (be
+ * especially careful to not use network file systems, remote file systems,
+ * read-only file systems etc)</li>
+ * <li>Record the full exception message and stack trace, then run the verifier
+ * again to see if it fails at the same or a different point</li>
+ * <li>Raise a ticket on the LmdbJava Issue Tracker that confirms the above
+ * details along with the failing operating system and Java version</li>
+ * </ol>
+ *
+ */
+public final class Verifier implements Callable<Long> {
+
+  /**
+   * Number of DBIs the created environment should allow.
+   */
+  public static final int DBI_COUNT = 5;
+  private static final int BATCH_SIZE = 64;
+  private static final int BUFFER_LEN = 1024 * BATCH_SIZE;
+  private static final int CRC_LENGTH = Long.BYTES;
+  private static final int KEY_LENGTH = Long.BYTES;
+  private final byte[] ba = new byte[BUFFER_LEN];
+  private final CRC32 crc = new CRC32();
+  private final List<Dbi<ByteBuffer>> dbis = new ArrayList<>(DBI_COUNT);
+  private final Env<ByteBuffer> env;
+  private long id;
+  private final ByteBuffer key = ByteBuffer.allocateDirect(KEY_LENGTH);
+  private final AtomicBoolean proceed = new AtomicBoolean(true);
+  private final Random rnd = new Random();
+  private Txn<ByteBuffer> txn;
+  private final ByteBuffer val = ByteBuffer.allocateDirect(BUFFER_LEN);
+
+  /**
+   * Create an instance of the verifier.
+   *
+   * <p>
+   * The caller must provide an {@link Env} configured with a suitable local
+   * storage location, maximum DBIs equal to {@link #DBI_COUNT}, and a
+   * map size large enough to accommodate the intended verification duration.
+   *
+   * <p>
+   * ALL EXISTING DATA IN THE DATABASE WILL BE DELETED. The caller must not
+   * interact with the <code>Env</code> in any way (eg querying, transactions
+   * etc) while the verifier is executing.
+   *
+   * @param env target that complies with the above requirements (required)
+   */
+  public Verifier(final Env<ByteBuffer> env) {
+    requireNonNull(env);
+    this.env = env;
+    key.order(BIG_ENDIAN);
+
+    deleteDbis();
+    createDbis();
+  }
+
+  /**
+   * Run the verifier until {@link #stop()} is called or an exception occurs.
+   *
+   * <p>
+   * Successful return of this method indicates no faults were detected. If any
+   * fault was detected the exception message will detail the exact point that
+   * the fault was encountered.
+   *
+   * @return number of database rows successfully verified
+   */
+  @Override
+  public Long call() {
+    try {
+      while (proceed.get()) {
+        transactionControl();
+
+        write(id);
+
+        if (id > 0) {
+          fetchAndDelete(id - 1);
+        }
+
+        id++;
+      }
+    } finally {
+      if (txn != null) {
+        txn.close();
+      }
+    }
+    return id;
+  }
+
+  /**
+   * Execute the verifier for the given duration.
+   *
+   * <p>
+   * This provides a simple way to execute the verifier for those applications
+   * which do not wish to manage threads directly.
+   *
+   * @param duration amount of time to execute
+   * @param unit     units used to express the duration
+   * @return number of database rows successfully verified
+   */
+  public long runFor(final long duration, final TimeUnit unit) {
+    final long deadline = System.currentTimeMillis() + unit.toMillis(duration);
+    final ExecutorService es = Executors.newSingleThreadExecutor();
+    final Future<Long> future = es.submit(this);
+    try {
+      while (System.currentTimeMillis() < deadline && !future.isDone()) {
+        Thread.sleep(unit.toMillis(1));
+      }
+    } catch (final InterruptedException ignored) {
+    } finally {
+      stop();
+    }
+    final long result;
+    try {
+      result = future.get();
+    } catch (final InterruptedException | ExecutionException ex) {
+      throw new IllegalStateException(ex);
+    } finally {
+      es.shutdown();
+    }
+    return result;
+  }
+
+  private void createDbis() {
+    for (int i = 0; i < DBI_COUNT; i++) {
+      dbis.add(env.openDbi(Verifier.class.getSimpleName() + i, MDB_CREATE));
+    }
+  }
+
+  private void deleteDbis() {
+    for (final byte[] existingDbiName : env.getDbiNames()) {
+      final Dbi<ByteBuffer> existingDbi = env.openDbi(existingDbiName);
+      try (Txn<ByteBuffer> txn = env.txnWrite()) {
+        existingDbi.drop(txn, true);
+        txn.commit();
+      }
+    }
+  }
+
+  private void fetchAndDelete(final long forId) {
+    final Dbi<ByteBuffer> dbi = getDbi(forId);
+    updateKey(forId);
+    final ByteBuffer fetchedValue;
+    try {
+      fetchedValue = dbi.get(txn, key);
+    } catch (final LmdbException ex) {
+      throw new IllegalStateException("DB get id=" + forId, ex);
+    }
+
+    if (fetchedValue == null) {
+      throw new IllegalStateException("DB not found id=" + forId);
+    }
+
+    verifyValue(forId, fetchedValue);
+
+    try {
+      dbi.delete(txn, key);
+    } catch (final LmdbException ex) {
+      throw new IllegalStateException("DB del id=" + forId, ex);
+    }
+  }
+
+  private Dbi<ByteBuffer> getDbi(final long forId) {
+    return dbis.get((int) (forId % dbis.size()));
+  }
+
+  /**
+   * Request the verifier to stop execution.
+   */
+  private void stop() {
+    proceed.set(false);
+  }
+
+  private void transactionControl() {
+    if (id % BATCH_SIZE == 0) {
+      if (txn != null) {
+        txn.commit();
+        txn.close();
+      }
+      rnd.nextBytes(ba);
+      txn = env.txnWrite();
+    }
+  }
+
+  private void updateKey(final long forId) {
+    key.clear();
+    key.putLong(forId);
+    key.flip();
+  }
+
+  private void updateValue(final long forId) {
+    final int rndSize = valueSize(forId);
+    crc.reset();
+    crc.update((int) forId);
+    crc.update(ba, CRC_LENGTH, rndSize);
+    final long crcVal = crc.getValue();
+
+    val.clear();
+    val.putLong(crcVal);
+    val.put(ba, CRC_LENGTH, rndSize);
+    val.flip();
+  }
+
+  private int valueSize(final long forId) {
+    final int mod = (int) (forId % BATCH_SIZE);
+    final int base = 1024 * mod;
+    final int value = base == 0 ? 512 : base;
+    return value - CRC_LENGTH - KEY_LENGTH; // aim to minimise partial pages
+  }
+
+  private void verifyValue(final long forId, final ByteBuffer bb) {
+    final int rndSize = valueSize(forId);
+    final int expected = rndSize + CRC_LENGTH;
+    if (bb.limit() != expected) {
+      throw new IllegalStateException("Limit error id=" + forId + " exp="
+                                          + expected + " limit=" + bb.limit());
+    }
+
+    final long crcRead = bb.getLong();
+    crc.reset();
+    crc.update((int) forId);
+    crc.update(bb);
+    final long crcVal = crc.getValue();
+
+    if (crcRead != crcVal) {
+      throw new IllegalStateException("CRC error id=" + forId);
+    }
+  }
+
+  private void write(final long forId) {
+    final Dbi<ByteBuffer> dbi = getDbi(forId);
+    updateKey(forId);
+    updateValue(forId);
+
+    try {
+      dbi.put(txn, key, val);
+    } catch (final LmdbException ex) {
+      throw new IllegalStateException("DB put id=" + forId, ex);
+    }
+  }
+
+}
diff --git a/src/test/java/org/lmdbjava/TutorialTest.java b/src/test/java/org/lmdbjava/TutorialTest.java
index 1f411d85..4b256ca9 100644
--- a/src/test/java/org/lmdbjava/TutorialTest.java
+++ b/src/test/java/org/lmdbjava/TutorialTest.java
@@ -40,6 +40,7 @@
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
+import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
 import org.lmdbjava.CursorIterator.KeyVal;
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
 import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
@@ -415,13 +416,41 @@ public void tutorial5() throws IOException {
   }
 
   /**
-   * In this final tutorial we'll look at using Agrona's DirectBuffer.
+   * Next up we'll show you how to easily check your platform (operating system
+   * and Java version) is working properly with LmdbJava and the embedded LMDB
+   * native library.
    *
    * @throws IOException if a path was unavailable for memory mapping
    */
   @Test
   @SuppressWarnings("ConvertToTryWithResources")
   public void tutorial6() throws IOException {
+    final File path = tmp.newFolder();
+
+    // Note we need to specify the Verifier's DBI_COUNT for the Env.
+    final Env<ByteBuffer> env = create(PROXY_OPTIMAL)
+        .setMapSize(10_485_760)
+        .setMaxDbs(Verifier.DBI_COUNT)
+        .open(path);
+
+    // Create a Verifier (it's a Callable<Long> for those needing full control).
+    final Verifier v = new Verifier(env);
+
+    // We now run the verifier for 3 seconds; it raises an exception on failure.
+    // The method returns the number of entries it successfully verified.
+    v.runFor(3, SECONDS);
+
+    env.close();
+  }
+
+  /**
+   * In this final tutorial we'll look at using Agrona's DirectBuffer.
+   *
+   * @throws IOException if a path was unavailable for memory mapping
+   */
+  @Test
+  @SuppressWarnings("ConvertToTryWithResources")
+  public void tutorial7() throws IOException {
     // The critical difference is we pass the PROXY_DB field to Env.create().
     // There's also a PROXY_SAFE if you want to stop ByteBuffer's Unsafe use.
     // Aside from that and a different type argument, it's the same as usual...
diff --git a/src/test/java/org/lmdbjava/VerifierTest.java b/src/test/java/org/lmdbjava/VerifierTest.java
new file mode 100644
index 00000000..1302fd25
--- /dev/null
+++ b/src/test/java/org/lmdbjava/VerifierTest.java
@@ -0,0 +1,57 @@
+/*-
+ * #%L
+ * LmdbJava
+ * %%
+ * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * %%
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * #L%
+ */
+
+package org.lmdbjava;
+
+import static com.jakewharton.byteunits.BinaryByteUnit.MEBIBYTES;
+import java.io.File;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.concurrent.TimeUnit;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.greaterThan;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import static org.lmdbjava.Env.create;
+import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
+
+/**
+ * Test {@link Verifier}.
+ */
+public final class VerifierTest {
+
+  @Rule
+  public final TemporaryFolder tmp = new TemporaryFolder();
+
+  @Test
+  public void verification() throws IOException {
+    final File path = tmp.newFile();
+    try (Env<ByteBuffer> env = create()
+        .setMaxReaders(1)
+        .setMaxDbs(Verifier.DBI_COUNT)
+        .setMapSize(MEBIBYTES.toBytes(10))
+        .open(path, MDB_NOSUBDIR)) {
+      final Verifier v = new Verifier(env);
+      assertThat(v.runFor(2, TimeUnit.SECONDS), greaterThan(1L));
+    }
+  }
+
+}

From 6431d6ebdc2488c7868a0bb8cf295f80a7911ee0 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Tue, 9 Apr 2019 10:05:46 +1000
Subject: [PATCH 016/322] Update to Agrona 0.9.35

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index ec1e6ac0..f20475c2 100644
--- a/pom.xml
+++ b/pom.xml
@@ -105,7 +105,7 @@
     <dependency>
       <groupId>org.agrona</groupId>
       <artifactId>agrona</artifactId>
-      <version>0.9.34</version>
+      <version>0.9.35</version>
       <optional>true</optional>
     </dependency>
     <dependency>

From 5912beb1037722c71f3ddc05e70fcbe739dfa272 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Tue, 9 Apr 2019 10:06:20 +1000
Subject: [PATCH 017/322] Move callback to field to survive GC (fixes #125)

Without this modification the callback is null if a GC is performed
subsequent to the construction of the Dbi instance.
---
 src/main/java/org/lmdbjava/Dbi.java | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index dc4ecc31..12b550d1 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -54,6 +54,7 @@
  */
 public final class Dbi<T> {
 
+  private final ComparatorCallback ccb;
   private boolean cleaned;
   private final Comparator<T> compFunc;
   private final T compKeyA;
@@ -76,12 +77,13 @@ public final class Dbi<T> {
       compFunc = null;
       compKeyA = null;
       compKeyB = null;
+      ccb = null;
     } else {
       this.proxy = txn.getProxy();
       this.compFunc = comparator;
       this.compKeyA = proxy.allocate();
       this.compKeyB = proxy.allocate();
-      final ComparatorCallback ccb = (keyA, keyB) -> {
+      this.ccb = (keyA, keyB) -> {
         proxy.out(compKeyA, keyA, keyA.address());
         proxy.out(compKeyB, keyB, keyB.address());
         return compFunc.compare(compKeyA, compKeyB);

From 52375e4c938a927b8ec2c194f3f628a95d5acecc Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 31 May 2019 15:31:57 +1000
Subject: [PATCH 018/322] Dbi comparator thread safety (fixes #127)

---
 src/main/java/org/lmdbjava/Dbi.java     | 17 +++----
 src/test/java/org/lmdbjava/DbiTest.java | 59 ++++++++++++++++++++++++-
 2 files changed, 64 insertions(+), 12 deletions(-)

diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index 12b550d1..d402a282 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -57,8 +57,6 @@ public final class Dbi<T> {
   private final ComparatorCallback ccb;
   private boolean cleaned;
   private final Comparator<T> compFunc;
-  private final T compKeyA;
-  private final T compKeyB;
   private final Env<T> env;
   private final byte[] name;
   private final BufferProxy<T> proxy;
@@ -75,18 +73,19 @@ public final class Dbi<T> {
     if (comparator == null) {
       proxy = null;
       compFunc = null;
-      compKeyA = null;
-      compKeyB = null;
       ccb = null;
     } else {
       this.proxy = txn.getProxy();
       this.compFunc = comparator;
-      this.compKeyA = proxy.allocate();
-      this.compKeyB = proxy.allocate();
       this.ccb = (keyA, keyB) -> {
+        final T compKeyA = proxy.allocate();
+        final T compKeyB = proxy.allocate();
         proxy.out(compKeyA, keyA, keyA.address());
         proxy.out(compKeyB, keyB, keyB.address());
-        return compFunc.compare(compKeyA, compKeyB);
+        final int result = compFunc.compare(compKeyA, compKeyB);
+        proxy.deallocate(compKeyA);
+        proxy.deallocate(compKeyB);
+        return result;
       };
       LIB.mdb_set_compare(txn.pointer(), ptr, ccb);
     }
@@ -495,10 +494,6 @@ private void clean() {
       return;
     }
     cleaned = true;
-    if (compKeyA != null) {
-      proxy.deallocate(compKeyA);
-      proxy.deallocate(compKeyB);
-    }
   }
 
   /**
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 3d9f9745..c15f8c31 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -28,16 +28,27 @@
 import java.nio.ByteBuffer;
 import static java.nio.ByteBuffer.allocateDirect;
 import static java.nio.charset.StandardCharsets.UTF_8;
+import java.util.ArrayList;
 import static java.util.Collections.nCopies;
 import java.util.Comparator;
 import java.util.List;
 import java.util.Random;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import static java.util.concurrent.TimeUnit.SECONDS;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+import static java.util.stream.Collectors.toList;
+import static java.util.stream.IntStream.range;
 import org.agrona.concurrent.UnsafeBuffer;
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.CoreMatchers.notNullValue;
 import static org.hamcrest.CoreMatchers.nullValue;
 import static org.hamcrest.MatcherAssert.assertThat;
+import org.hamcrest.Matchers;
 import static org.hamcrest.Matchers.hasSize;
 import static org.hamcrest.collection.IsEmptyCollection.empty;
 import org.junit.After;
@@ -47,6 +58,7 @@
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
+import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
 import org.lmdbjava.Dbi.DbFullException;
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
 import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
@@ -81,7 +93,7 @@ public void before() throws IOException {
     final File path = tmp.newFile();
     env = create()
         .setMapSize(MEBIBYTES.toBytes(64))
-        .setMaxReaders(1)
+        .setMaxReaders(2)
         .setMaxDbs(2)
         .open(path, MDB_NOSUBDIR);
   }
@@ -127,6 +139,51 @@ public void dbOpenMaxDatabases() {
     env.openDbi("db3 fails", MDB_CREATE);
   }
 
+  @Test
+  public void dbiWithComparatorThreadSafety() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, PROXY_OPTIMAL::compare,
+                                           MDB_CREATE);
+
+    final List<Integer> keys = range(0, 1000).boxed().collect(toList());
+
+    final ExecutorService pool = Executors.newCachedThreadPool();
+    final AtomicBoolean proceed = new AtomicBoolean(true);
+    final Future<?> reader = pool.submit(() -> {
+      while (proceed.get()) {
+        try (Txn<ByteBuffer> txn = env.txnRead()) {
+          db.get(txn, bb(50));
+        }
+      }
+    });
+
+    for (final Integer key : keys) {
+      try (Txn<ByteBuffer> txn = env.txnWrite()) {
+        db.put(txn, bb(key), bb(3));
+        txn.commit();
+      }
+    }
+
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      final CursorIterator<ByteBuffer> iter = db.iterate(txn);
+
+      final List<Integer> result = new ArrayList<>();
+      while (iter.hasNext()) {
+        result.add(iter.next().key().getInt());
+      }
+
+      assertThat(result, Matchers.contains(keys.toArray(new Integer[0])));
+    }
+
+    proceed.set(false);
+    try {
+      reader.get(1, SECONDS);
+      pool.shutdown();
+      pool.awaitTermination(1, SECONDS);
+    } catch (ExecutionException | InterruptedException | TimeoutException e) {
+      throw new IllegalStateException(e);
+    }
+  }
+
   @Test
   public void drop() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);

From 90adace01871b54850aaafe95c44dd07e4638a3c Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 31 May 2019 15:42:17 +1000
Subject: [PATCH 019/322] Update to Agrona 1.0.1

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index f20475c2..b4fb3ec2 100644
--- a/pom.xml
+++ b/pom.xml
@@ -105,7 +105,7 @@
     <dependency>
       <groupId>org.agrona</groupId>
       <artifactId>agrona</artifactId>
-      <version>0.9.35</version>
+      <version>1.0.1</version>
       <optional>true</optional>
     </dependency>
     <dependency>

From 47fec9e3ff57a411142400f1d4dbdca7d26692e5 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 31 May 2019 15:42:26 +1000
Subject: [PATCH 020/322] Update to Netty 4.1.36

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index b4fb3ec2..0b357d70 100644
--- a/pom.xml
+++ b/pom.xml
@@ -111,7 +111,7 @@
     <dependency>
       <groupId>io.netty</groupId>
       <artifactId>netty-all</artifactId>
-      <version>4.1.34.Final</version>
+      <version>4.1.36.Final</version>
       <scope>test</scope>
     </dependency>
     <dependency>

From 1fe353d8852f432b346cd21c0dfdafde838152b5 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Sat, 1 Jun 2019 14:38:53 +1000
Subject: [PATCH 021/322] Fix IndexOutOfBoundsException due to
 SimpleLeakAwareByteBuf (fixes #133)

---
 src/test/java/org/lmdbjava/ByteBufProxy.java | 19 +++++++++++++------
 1 file changed, 13 insertions(+), 6 deletions(-)

diff --git a/src/test/java/org/lmdbjava/ByteBufProxy.java b/src/test/java/org/lmdbjava/ByteBufProxy.java
index 670a5d59..768c1b5e 100644
--- a/src/test/java/org/lmdbjava/ByteBufProxy.java
+++ b/src/test/java/org/lmdbjava/ByteBufProxy.java
@@ -48,6 +48,7 @@ public final class ByteBufProxy extends BufferProxy<ByteBuf> {
   private static final ThreadLocal<ArrayDeque<ByteBuf>> BUFFERS = withInitial(()
       -> new ArrayDeque<>(16));
 
+  private static final int BUFFER_RETRIES = 10;
   private static final String FIELD_NAME_ADDRESS = "memoryAddress";
   private static final String FIELD_NAME_LENGTH = "length";
   private static final long LENGTH_OFFSET;
@@ -55,11 +56,7 @@ public final class ByteBufProxy extends BufferProxy<ByteBuf> {
 
   static {
     try {
-      // create buffer (first is SimpleLeakAwareByteBuff but we need PooledUDBB)
-      final ByteBuf bb = DEFAULT.directBuffer(0);
-      if (!NAME.equals(bb.getClass().getName())) {
-        throw new IllegalStateException("Netty buffer must be " + NAME);
-      }
+      createBuffer();
       final Field address = findField(NAME, FIELD_NAME_ADDRESS);
       final Field length = findField(NAME, FIELD_NAME_LENGTH);
       ADDRESS_OFFSET = UNSAFE.objectFieldOffset(address);
@@ -88,6 +85,16 @@ static Field findField(final String c, final String name) {
     throw new LmdbException(name + " not found");
   }
 
+  private static ByteBuf createBuffer() {
+    for (int i = 0; i < BUFFER_RETRIES; i++) {
+      final ByteBuf bb = DEFAULT.directBuffer(0);
+      if (NAME.equals(bb.getClass().getName())) {
+        return bb;
+      }
+    }
+    throw new IllegalStateException("Netty buffer must be " + NAME);
+  }
+
   @Override
   protected ByteBuf allocate() {
     final ArrayDeque<ByteBuf> queue = BUFFERS.get();
@@ -96,7 +103,7 @@ protected ByteBuf allocate() {
     if (buffer != null && buffer.capacity() >= 0) {
       return buffer;
     } else {
-      return DEFAULT.directBuffer(0);
+      return createBuffer();
     }
   }
 

From b0085a469ed09df74cb61d86609483c38d6c5608 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Sat, 1 Jun 2019 14:42:12 +1000
Subject: [PATCH 022/322] TutorialTest to reduce required readers (fixes #129)

---
 src/test/java/org/lmdbjava/TutorialTest.java | 34 +++++++++-----------
 1 file changed, 15 insertions(+), 19 deletions(-)

diff --git a/src/test/java/org/lmdbjava/TutorialTest.java b/src/test/java/org/lmdbjava/TutorialTest.java
index 4b256ca9..56af2293 100644
--- a/src/test/java/org/lmdbjava/TutorialTest.java
+++ b/src/test/java/org/lmdbjava/TutorialTest.java
@@ -46,7 +46,6 @@
 import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
 import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
 import static org.lmdbjava.Env.create;
-import static org.lmdbjava.Env.open;
 import static org.lmdbjava.GetOp.MDB_SET;
 import static org.lmdbjava.SeekOp.MDB_FIRST;
 import static org.lmdbjava.SeekOp.MDB_LAST;
@@ -151,10 +150,7 @@ public void tutorial1() throws IOException {
   @SuppressWarnings({"ConvertToTryWithResources",
                      "checkstyle:executablestatementcount"})
   public void tutorial2() throws IOException, InterruptedException {
-    final File path = tmp.newFolder();
-    // Here we use a shortcut to open a 10 MB environment with one database.
-    final Env<ByteBuffer> env = open(path, 10);
-
+    final Env<ByteBuffer> env = createSimpleEnv(tmp.newFolder());
     final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
     final ByteBuffer key = allocateDirect(env.getMaxKeySize());
     final ByteBuffer val = allocateDirect(700);
@@ -229,9 +225,7 @@ public void tutorial2() throws IOException, InterruptedException {
   @SuppressWarnings({"ConvertToTryWithResources",
                      "checkstyle:executablestatementcount"})
   public void tutorial3() throws IOException {
-    // As per tutorial1...
-    final File path = tmp.newFolder();
-    final Env<ByteBuffer> env = open(path, 10);
+    final Env<ByteBuffer> env = createSimpleEnv(tmp.newFolder());
     final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
     final ByteBuffer key = allocateDirect(env.getMaxKeySize());
     final ByteBuffer val = allocateDirect(700);
@@ -306,9 +300,7 @@ public void tutorial3() throws IOException {
   @Test
   @SuppressWarnings("ConvertToTryWithResources")
   public void tutorial4() throws IOException {
-    // As per tutorial1...
-    final File path = tmp.newFolder();
-    final Env<ByteBuffer> env = open(path, 10);
+    final Env<ByteBuffer> env = createSimpleEnv(tmp.newFolder());
     final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
 
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
@@ -368,9 +360,7 @@ public void tutorial4() throws IOException {
   @Test
   @SuppressWarnings("ConvertToTryWithResources")
   public void tutorial5() throws IOException {
-    // As per tutorial1...
-    final File path = tmp.newFolder();
-    final Env<ByteBuffer> env = open(path, 10);
+    final Env<ByteBuffer> env = createSimpleEnv(tmp.newFolder());
 
     // This time we're going to tell the Dbi it can store > 1 value per key.
     // There are other flags available if we're storing integers etc.
@@ -425,13 +415,11 @@ public void tutorial5() throws IOException {
   @Test
   @SuppressWarnings("ConvertToTryWithResources")
   public void tutorial6() throws IOException {
-    final File path = tmp.newFolder();
-
     // Note we need to specify the Verifier's DBI_COUNT for the Env.
     final Env<ByteBuffer> env = create(PROXY_OPTIMAL)
         .setMapSize(10_485_760)
         .setMaxDbs(Verifier.DBI_COUNT)
-        .open(path);
+        .open(tmp.newFolder());
 
     // Create a Verifier (it's a Callable<Long> for those needing full control).
     final Verifier v = new Verifier(env);
@@ -454,11 +442,10 @@ public void tutorial7() throws IOException {
     // The critical difference is we pass the PROXY_DB field to Env.create().
     // There's also a PROXY_SAFE if you want to stop ByteBuffer's Unsafe use.
     // Aside from that and a different type argument, it's the same as usual...
-    final File path = tmp.newFolder();
     final Env<DirectBuffer> env = create(PROXY_DB)
         .setMapSize(10_485_760)
         .setMaxDbs(1)
-        .open(path);
+        .open(tmp.newFolder());
 
     final Dbi<DirectBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
 
@@ -513,4 +500,13 @@ public void tutorial7() throws IOException {
   // how to speed up inserts by appending them in key order, using integer
   // or reverse ordered keys, using Env.DISABLE_CHECKS_PROP etc), but you now
   // know enough to tackle the JavaDocs with confidence. Have fun!
+
+  private Env<ByteBuffer> createSimpleEnv(final File path) {
+    return create()
+        .setMapSize(10_485_760)
+        .setMaxDbs(1)
+        .setMaxReaders(1)
+        .open(path);
+  }
+
 }

From 8258e4871ecd9b07ec59666357a8cc224af44097 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Sat, 1 Jun 2019 15:09:24 +1000
Subject: [PATCH 023/322] Remove unchecked exceptions from method signatures

---
 src/main/java/org/lmdbjava/Cursor.java           | 2 +-
 src/main/java/org/lmdbjava/CursorIterator.java   | 2 +-
 src/main/java/org/lmdbjava/ResultCodeMapper.java | 3 +--
 src/main/java/org/lmdbjava/Txn.java              | 6 +++---
 4 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/src/main/java/org/lmdbjava/Cursor.java b/src/main/java/org/lmdbjava/Cursor.java
index 2c6bd7e0..80c5df4f 100644
--- a/src/main/java/org/lmdbjava/Cursor.java
+++ b/src/main/java/org/lmdbjava/Cursor.java
@@ -355,7 +355,7 @@ public T val() {
     return kv.val();
   }
 
-  private void checkNotClosed() throws ClosedException {
+  private void checkNotClosed() {
     if (closed) {
       throw new ClosedException();
     }
diff --git a/src/main/java/org/lmdbjava/CursorIterator.java b/src/main/java/org/lmdbjava/CursorIterator.java
index e6ec5392..d03ae71b 100644
--- a/src/main/java/org/lmdbjava/CursorIterator.java
+++ b/src/main/java/org/lmdbjava/CursorIterator.java
@@ -88,7 +88,7 @@ public Iterable<KeyVal<T>> iterable() {
   }
 
   @Override
-  public KeyVal<T> next() throws NoSuchElementException {
+  public KeyVal<T> next() {
     if (!hasNext()) {
       throw new NoSuchElementException();
     }
diff --git a/src/main/java/org/lmdbjava/ResultCodeMapper.java b/src/main/java/org/lmdbjava/ResultCodeMapper.java
index 67946652..67ecaef9 100644
--- a/src/main/java/org/lmdbjava/ResultCodeMapper.java
+++ b/src/main/java/org/lmdbjava/ResultCodeMapper.java
@@ -56,9 +56,8 @@ private ResultCodeMapper() {
    * Checks the result code and raises an exception is not {@link #MDB_SUCCESS}.
    *
    * @param rc the LMDB result code
-   * @throws LmdbNativeException the resolved exception
    */
-  static void checkRc(final int rc) throws LmdbNativeException {
+  static void checkRc(final int rc) {
     switch (rc) {
       case MDB_SUCCESS:
         return;
diff --git a/src/main/java/org/lmdbjava/Txn.java b/src/main/java/org/lmdbjava/Txn.java
index d8c87b84..233cd6a5 100644
--- a/src/main/java/org/lmdbjava/Txn.java
+++ b/src/main/java/org/lmdbjava/Txn.java
@@ -184,19 +184,19 @@ public T val() {
     return keyVal.val();
   }
 
-  void checkReadOnly() throws ReadOnlyRequiredException {
+  void checkReadOnly() {
     if (!readOnly) {
       throw new ReadOnlyRequiredException();
     }
   }
 
-  void checkReady() throws NotReadyException {
+  void checkReady() {
     if (state != READY) {
       throw new NotReadyException();
     }
   }
 
-  void checkWritesAllowed() throws ReadWriteRequiredException {
+  void checkWritesAllowed() {
     if (readOnly) {
       throw new ReadWriteRequiredException();
     }

From a97617b0b9a346ceabeb2ff7c7bc38dafced2dd6 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Sat, 1 Jun 2019 15:09:35 +1000
Subject: [PATCH 024/322] Update to Acegi Standard Project 0.2.3

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 0b357d70..6207e1fb 100644
--- a/pom.xml
+++ b/pom.xml
@@ -4,7 +4,7 @@
   <parent>
     <groupId>au.com.acegi</groupId>
     <artifactId>acegi-standard-project</artifactId>
-    <version>0.2.1</version>
+    <version>0.2.3</version>
   </parent>
   <groupId>org.lmdbjava</groupId>
   <artifactId>lmdbjava</artifactId>

From a8ee24fbd1603ed9cf4f743682334dce6d7e6878 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Sun, 2 Jun 2019 10:32:54 +1000
Subject: [PATCH 025/322] Update features list

---
 README.md | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 3bba0014..611c2f0f 100644
--- a/README.md
+++ b/README.md
@@ -25,13 +25,16 @@
 **LmdbJava** adds Java-specific features to LMDB:
 
 * [Extremely fast](https://github.com/lmdbjava/benchmarks/blob/master/results/20160710/README.md) across a broad range of benchmarks, data sizes and access patterns
-* Modern, idiomatic Java API (including iterators, enums, exceptions etc)
-* Nothing to install (the JAR embeds LMDB libraries for Linux, OS X and Windows)
+* Modern, idiomatic Java API (including iterators, key ranges, enums, exceptions etc)
+* Nothing to install (the JAR embeds the latest LMDB libraries for Linux, OS X and Windows)
 * Buffer agnostic (Java `ByteBuffer`, Agrona `DirectBuffer`, Netty `ByteBuf`, your own buffer)
 * 100% stock-standard, officially-released, widely-tested LMDB C code ([no extra](https://github.com/lmdbjava/native) C/JNI code)
 * Low latency design (allocation-free; buffer pools; optional checks can be easily disabled in production etc)
+* Automatically tested with Java 8 and Java 11
 * Easy to use (just work through our step-by-step, CI-tested, fully-executable [tutorial](https://github.com/lmdbjava/lmdbjava/tree/master/src/test/java/org/lmdbjava/TutorialTest.java))
-* Tested with Java 8 through to Java 11
+* Community questions and contributions are welcome through [GitHub tickets](https://github.com/lmdbjava/lmdbjava/issues)
+* Mature code (commenced in 2016) and used for heavy production workloads (eg > 500 TB of HFT data)
+* Actively maintained and with a "Zero Bug Policy" before every release (see [issues](https://github.com/lmdbjava/lmdbjava/issues))
 * Available from [Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22org.lmdbjava%22%20AND%20a%3A%22lmdbjava%22) and [OSS Sonatype Snapshots](https://oss.sonatype.org/content/repositories/snapshots/org/lmdbjava/lmdbjava) (see [Change Log](https://github.com/lmdbjava/lmdbjava/wiki/Change-Log))
 * Comprehensive [JavaDocs](http://www.javadoc.io/doc/org.lmdbjava/lmdbjava)
 * [Linux](https://travis-ci.org/lmdbjava/lmdbjava), [OS X](https://travis-ci.org/lmdbjava/lmdbjava) and [Windows](https://ci.appveyor.com/project/benalexau/lmdbjava) CI

From bc12fd0416e75ff173b45ee19caafe2eddb8c247 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Sun, 2 Jun 2019 17:44:54 +1000
Subject: [PATCH 026/322] Automatic formatting only

---
 src/test/java/org/lmdbjava/TutorialTest.java | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/test/java/org/lmdbjava/TutorialTest.java b/src/test/java/org/lmdbjava/TutorialTest.java
index 56af2293..d631126c 100644
--- a/src/test/java/org/lmdbjava/TutorialTest.java
+++ b/src/test/java/org/lmdbjava/TutorialTest.java
@@ -500,7 +500,6 @@ public void tutorial7() throws IOException {
   // how to speed up inserts by appending them in key order, using integer
   // or reverse ordered keys, using Env.DISABLE_CHECKS_PROP etc), but you now
   // know enough to tackle the JavaDocs with confidence. Have fun!
-
   private Env<ByteBuffer> createSimpleEnv(final File path) {
     return create()
         .setMapSize(10_485_760)

From 3a75fd5e6856e485a5d350ced3526d3be9a9363a Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Tue, 4 Jun 2019 14:55:29 +1000
Subject: [PATCH 027/322] [maven-release-plugin] prepare release lmdbjava-0.7.0

---
 pom.xml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pom.xml b/pom.xml
index 6207e1fb..4fc7866a 100644
--- a/pom.xml
+++ b/pom.xml
@@ -8,7 +8,7 @@
   </parent>
   <groupId>org.lmdbjava</groupId>
   <artifactId>lmdbjava</artifactId>
-  <version>0.6.4-SNAPSHOT</version>
+  <version>0.7.0</version>
   <packaging>jar</packaging>
   <name>LmdbJava</name>
   <description>Low latency Java API for the ultra-fast, embedded Symas Lightning Database (LMDB)</description>
@@ -45,7 +45,7 @@
     <connection>scm:git:git@github.com:${github.org}/${github.repo}.git</connection>
     <developerConnection>scm:git:git@github.com:${github.org}/${github.repo}.git</developerConnection>
     <url>git@github.com:${github.org}/${github.repo}.git</url>
-    <tag>HEAD</tag>
+    <tag>lmdbjava-0.7.0</tag>
   </scm>
   <issueManagement>
     <system>GitHub Issues</system>

From 0591402fd1820512cddc920a1562ff7f8fcf26c2 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Tue, 4 Jun 2019 14:56:08 +1000
Subject: [PATCH 028/322] [maven-release-plugin] prepare for next development
 iteration

---
 pom.xml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pom.xml b/pom.xml
index 4fc7866a..3b0c2ca8 100644
--- a/pom.xml
+++ b/pom.xml
@@ -8,7 +8,7 @@
   </parent>
   <groupId>org.lmdbjava</groupId>
   <artifactId>lmdbjava</artifactId>
-  <version>0.7.0</version>
+  <version>0.7.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>LmdbJava</name>
   <description>Low latency Java API for the ultra-fast, embedded Symas Lightning Database (LMDB)</description>
@@ -45,7 +45,7 @@
     <connection>scm:git:git@github.com:${github.org}/${github.repo}.git</connection>
     <developerConnection>scm:git:git@github.com:${github.org}/${github.repo}.git</developerConnection>
     <url>git@github.com:${github.org}/${github.repo}.git</url>
-    <tag>lmdbjava-0.7.0</tag>
+    <tag>HEAD</tag>
   </scm>
   <issueManagement>
     <system>GitHub Issues</system>

From 7552aaa4196eba6aba9557954eff7937ad273df8 Mon Sep 17 00:00:00 2001
From: Martin Harrigan <martinharrigan@gmail.com>
Date: Thu, 1 Aug 2019 10:46:10 +0100
Subject: [PATCH 029/322] Fix typo in exception class name

---
 src/main/java/org/lmdbjava/LmdbNativeException.java  | 4 ++--
 src/main/java/org/lmdbjava/ResultCodeMapper.java     | 2 +-
 src/test/java/org/lmdbjava/DbiTest.java              | 4 ++--
 src/test/java/org/lmdbjava/ResultCodeMapperTest.java | 6 +++---
 4 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/main/java/org/lmdbjava/LmdbNativeException.java b/src/main/java/org/lmdbjava/LmdbNativeException.java
index 7ef02a62..b80d9e13 100644
--- a/src/main/java/org/lmdbjava/LmdbNativeException.java
+++ b/src/main/java/org/lmdbjava/LmdbNativeException.java
@@ -57,11 +57,11 @@ public final int getResultCode() {
   /**
    * Exception raised from a system constant table lookup.
    */
-  public static final class ConstantDerviedException extends LmdbNativeException {
+  public static final class ConstantDerivedException extends LmdbNativeException {
 
     private static final long serialVersionUID = 1L;
 
-    ConstantDerviedException(final int rc, final String message) {
+    ConstantDerivedException(final int rc, final String message) {
       super(rc, "Platform constant error code: " + message);
     }
   }
diff --git a/src/main/java/org/lmdbjava/ResultCodeMapper.java b/src/main/java/org/lmdbjava/ResultCodeMapper.java
index 67ecaef9..678537e5 100644
--- a/src/main/java/org/lmdbjava/ResultCodeMapper.java
+++ b/src/main/java/org/lmdbjava/ResultCodeMapper.java
@@ -110,7 +110,7 @@ static void checkRc(final int rc) {
       throw new IllegalArgumentException("Unknown result code " + rc);
     }
     final String msg = constant.name() + " " + constant.toString();
-    throw new LmdbNativeException.ConstantDerviedException(rc, msg);
+    throw new LmdbNativeException.ConstantDerivedException(rc, msg);
   }
 
 }
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index c15f8c31..5d454cb8 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -67,7 +67,7 @@
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
 import static org.lmdbjava.GetOp.MDB_SET_KEY;
 import static org.lmdbjava.KeyRange.atMost;
-import org.lmdbjava.LmdbNativeException.ConstantDerviedException;
+import org.lmdbjava.LmdbNativeException.ConstantDerivedException;
 import static org.lmdbjava.PutFlags.MDB_NODUPDATA;
 import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
 import static org.lmdbjava.TestUtils.DB_1;
@@ -98,7 +98,7 @@ public void before() throws IOException {
         .open(path, MDB_NOSUBDIR);
   }
 
-  @Test(expected = ConstantDerviedException.class)
+  @Test(expected = ConstantDerivedException.class)
   public void close() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
     db.put(bb(1), bb(42));
diff --git a/src/test/java/org/lmdbjava/ResultCodeMapperTest.java b/src/test/java/org/lmdbjava/ResultCodeMapperTest.java
index 75007db7..78adb498 100644
--- a/src/test/java/org/lmdbjava/ResultCodeMapperTest.java
+++ b/src/test/java/org/lmdbjava/ResultCodeMapperTest.java
@@ -43,7 +43,7 @@
 import org.lmdbjava.Env.MapFullException;
 import org.lmdbjava.Env.ReadersFullException;
 import org.lmdbjava.Env.VersionMismatchException;
-import org.lmdbjava.LmdbNativeException.ConstantDerviedException;
+import org.lmdbjava.LmdbNativeException.ConstantDerivedException;
 import org.lmdbjava.LmdbNativeException.PageCorruptedException;
 import org.lmdbjava.LmdbNativeException.PageFullException;
 import org.lmdbjava.LmdbNativeException.PageNotFoundException;
@@ -103,7 +103,7 @@ public void checkErrAll() {
     }
   }
 
-  @Test(expected = ConstantDerviedException.class)
+  @Test(expected = ConstantDerivedException.class)
   public void checkErrConstantDerived() {
     checkRc(20);
   }
@@ -113,7 +113,7 @@ public void checkErrConstantDerivedMessage() {
     try {
       checkRc(2);
       fail("Should have raised exception");
-    } catch (final ConstantDerviedException ex) {
+    } catch (final ConstantDerivedException ex) {
       assertThat(ex.getMessage(), containsString("No such file or directory"));
     }
   }

From 83f991cb4e3974235e491c93170b206e14000ed7 Mon Sep 17 00:00:00 2001
From: sidnt <sidnt@users.noreply.github.com>
Date: Sat, 4 Jan 2020 11:10:44 +0530
Subject: [PATCH 030/322] add documentation from lmdb api doc

---
 src/main/java/org/lmdbjava/EnvFlags.java | 100 +++++++++++++++++++++--
 1 file changed, 93 insertions(+), 7 deletions(-)

diff --git a/src/main/java/org/lmdbjava/EnvFlags.java b/src/main/java/org/lmdbjava/EnvFlags.java
index eb267f33..6b1709ba 100644
--- a/src/main/java/org/lmdbjava/EnvFlags.java
+++ b/src/main/java/org/lmdbjava/EnvFlags.java
@@ -26,50 +26,136 @@
 public enum EnvFlags implements MaskedFlag {
 
   /**
-   * Mmap at a fixed address (experimental).
+   * http://www.lmdb.tech/doc/group__mdb.html#ga32a193c6bf4d7d5c5d579e71f22e9340
    */
+
   /**
    * Mmap at a fixed address (experimental).
+   * MDB_FIXEDMAP : Use a fixed address for the mmap region. This flag must be
+   * specified when creating the environment, and is stored persistently in the
+   * environment. If successful, the memory map will always reside at the same
+   * virtual address and pointers used to reference data items in the database will
+   * be constant across multiple invocations. This option may not always work,
+   * depending on how the operating system has allocated memory to shared
+   * libraries and other uses. The feature is highly experimental.
    */
   MDB_FIXEDMAP(0x01),
+
   /**
    * No environment directory.
+   * MDB_NOSUBDIR : By default, LMDB creates its environment in a directory whose pathname is
+   * given in path, and creates its data and lock files under that directory.
+   * With this option, path is used as-is for the database main data file. The
+   * database lock file is the path with "-lock" appended.
    */
   MDB_NOSUBDIR(0x4000),
+
   /**
-   * Don't fsync after commit.
+   * MDB_RDONLY : Open the environment in read-only mode. No write operations will
+   * be allowed. LMDB will still modify the lock file - except on read-only
+   * filesystems, where LMDB does not use locks.
    */
-  MDB_NOSYNC(0x1_0000),
+  MDB_RDONLY_ENV(0x2_0000),
+
   /**
-   * Read only.
+   * MDB_WRITEMAP : Use a writeable memory map unless MDB_RDONLY is set. This is
+   * faster and uses fewer mallocs, but loses protection from application bugs
+   * like wild pointer writes and other bad updates into the database.
+   * Incompatible with nested transactions. Do not mix processes with and without
+   * MDB_WRITEMAP on the same environment. This can defeat durability (mdb_env_sync etc).
    */
-  MDB_RDONLY_ENV(0x2_0000),
+  MDB_WRITEMAP(0x8_0000),
+
   /**
    * Don't fsync metapage after commit.
+   * MDB_NOMETASYNC : Flush system buffers to disk only once per transaction, omit the
+   * metadata flush. Defer that until the system flushes files to disk, or next non-MDB_RDONLY
+   * commit or mdb_env_sync(). This optimization maintains database integrity, but a system
+   * crash may undo the last committed transaction. I.e. it preserves the ACI (atomicity,
+   * consistency, isolation) but not D (durability) database property. This flag may be
+   * changed at any time using mdb_env_set_flags().
    */
   MDB_NOMETASYNC(0x4_0000),
+
   /**
-   * Use writable mmap.
+   * Don't fsync after commit.
+   * MDB_NOSYNC : Don't flush system buffers to disk when committing a transaction.
+   * This optimization means a system crash can corrupt the database or lose the last
+   * transactions if buffers are not yet flushed to disk. The risk is governed by how
+   * often the system flushes dirty buffers to disk and how often mdb_env_sync() is called.
+   * However, if the filesystem preserves write order and the MDB_WRITEMAP flag is not used,
+   * transactions exhibit ACI (atomicity, consistency, isolation) properties and only lose D
+   * (durability). I.e. database integrity is maintained, but a system crash may undo the
+   * final transactions. Note that (MDB_NOSYNC | MDB_WRITEMAP) leaves the system with no hint
+   * for when to write transactions to disk, unless mdb_env_sync() is called.
+   * (MDB_MAPASYNC | MDB_WRITEMAP) may be preferable. This flag may be changed at any time
+   * using mdb_env_set_flags().
    */
-  MDB_WRITEMAP(0x8_0000),
+  MDB_NOSYNC(0x1_0000),
+
   /**
    * Use asynchronous msync when {@link #MDB_WRITEMAP} is used.
+   * MDB_MAPASYNC : When using MDB_WRITEMAP, use asynchronous flushes to disk.
+   * As with MDB_NOSYNC, a system crash can then corrupt the database or lose the
+   * last transactions. Calling mdb_env_sync() ensures on-disk database integrity
+   * until next commit. This flag may be changed at any time using mdb_env_set_flags().
    */
   MDB_MAPASYNC(0x10_0000),
+
   /**
    * Tie reader locktable slots to {@link Txn} objects instead of to threads.
+   * MDB_NOTLS : Don't use Thread-Local Storage. Tie reader locktable slots to
+   * MDB_txn objects instead of to threads. I.e. mdb_txn_reset() keeps the slot
+   * reseved for the MDB_txn object. A thread may use parallel read-only transactions.
+   * A read-only transaction may span threads if the user synchronizes its use.
+   * Applications that multiplex many user threads over individual OS threads
+   * need this option. Such an application must also serialize the write
+   * transactions in an OS thread, since LMDB's write locking is unaware
+   * of the user threads.
    */
   MDB_NOTLS(0x20_0000),
+
   /**
    * Don't do any locking, caller must manage their own locks.
+   * MDB_NOLOCK : Don't do any locking. If concurrent access is anticipated,
+   * the caller must manage all concurrency itself. For proper operation
+   * the caller must enforce single-writer semantics, and must ensure
+   * that no readers are using old transactions while a writer is active.
+   * The simplest approach is to use an exclusive lock so that no readers
+   * may be active at all when a writer begins.
    */
   MDB_NOLOCK(0x40_0000),
+
   /**
    * Don't do readahead (no effect on Windows).
+   * MDB_NORDAHEAD : Turn off readahead. Most operating systems perform
+   * readahead on read requests by default. This option turns it off if
+   * the OS supports it. Turning it off may help random read performance
+   * when the DB is larger than RAM and system RAM is full. The option
+   * is not implemented on Windows.
    */
   MDB_NORDAHEAD(0x80_0000),
+
   /**
    * Don't initialize malloc'd memory before writing to datafile.
+   * MDB_NOMEMINIT : Don't initialize malloc'd memory before writing to
+   * unused spaces in the data file. By default, memory for pages written
+   * to the data file is obtained using malloc. While these pages may be
+   * reused in subsequent transactions, freshly malloc'd pages will be
+   * initialized to zeroes before use. This avoids persisting leftover
+   * data from other code (that used the heap and subsequently freed
+   * the memory) into the data file. Note that many other system
+   * libraries may allocate and free memory from the heap for
+   * arbitrary uses. E.g., stdio may use the heap for file I/O buffers.
+   * This initialization step has a modest performance cost so some
+   * applications may want to disable it using this flag. This option
+   * can be a problem for applications which handle sensitive data
+   * like passwords, and it makes memory checkers like Valgrind noisy.
+   * This flag is not needed with MDB_WRITEMAP, which writes directly
+   * to the mmap instead of using malloc for pages. The initialization
+   * is also skipped if MDB_RESERVE is used; the caller is expected to
+   * overwrite all of the memory that was reserved in that case. This
+   * flag may be changed at any time using mdb_env_set_flags().
    */
   MDB_NOMEMINIT(0x100_0000);
 

From a02bc60b31b36b42dc86344bec5719d11183f571 Mon Sep 17 00:00:00 2001
From: Justin Heister <justin.heister@youdevise.com>
Date: Tue, 10 Mar 2020 09:47:04 +0000
Subject: [PATCH 031/322] Add support for listing Dbi flags

---
 src/main/java/org/lmdbjava/Dbi.java     | 28 +++++++++++++++++++++++++
 src/main/java/org/lmdbjava/Library.java |  2 +-
 src/test/java/org/lmdbjava/DbiTest.java | 12 +++++++++++
 3 files changed, 41 insertions(+), 1 deletion(-)

diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index d402a282..eccefd5f 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -20,10 +20,15 @@
 
 package org.lmdbjava;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Comparator;
+import java.util.List;
+
 import static java.util.Objects.requireNonNull;
 import static jnr.ffi.Memory.allocateDirect;
+
+import jnr.ffi.NativeType;
 import static jnr.ffi.NativeType.ADDRESS;
 import jnr.ffi.Pointer;
 import jnr.ffi.byref.PointerByReference;
@@ -489,6 +494,29 @@ public Stat stat(final Txn<T> txn) {
         stat.f5_ms_entries.longValue());
   }
 
+  /*
+  * Return DbiFlags for this Dbi.
+  *
+  * @param txn transaction handle (not null; not committed)
+  * @return the list of flags this Dbi was created with
+  */
+  public List<DbiFlags> listFlags(final Txn<T> txn) {
+    final Pointer resultPtr = allocateDirect(RUNTIME, NativeType.UINT);
+    checkRc(LIB.mdb_dbi_flags(txn.pointer(), ptr, resultPtr));
+
+    final int flags = resultPtr.getInt(0);
+
+    final List<DbiFlags> result = new ArrayList<>();
+
+    for (final DbiFlags flag : DbiFlags.values()) {
+      if (MaskedFlag.isSet(flags, flag)) {
+        result.add(flag);
+      }
+    }
+
+    return result;
+  }
+
   private void clean() {
     if (cleaned) {
       return;
diff --git a/src/main/java/org/lmdbjava/Library.java b/src/main/java/org/lmdbjava/Library.java
index 3cb44fae..60ac2fbc 100644
--- a/src/main/java/org/lmdbjava/Library.java
+++ b/src/main/java/org/lmdbjava/Library.java
@@ -222,7 +222,7 @@ int mdb_cursor_put(@In Pointer cursor, @In Pointer key, @In Pointer data,
 
     void mdb_dbi_close(@In Pointer env, @In Pointer dbi);
 
-    int mdb_dbi_flags(@In Pointer txn, @In Pointer dbi, int flags);
+    int mdb_dbi_flags(@In Pointer txn, @In Pointer dbi, @Out Pointer flags);
 
     int mdb_dbi_open(@In Pointer txn, @In byte[] name, int flags,
                      @In Pointer dbiPtr);
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 5d454cb8..c36be6bf 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -49,6 +49,7 @@
 import static org.hamcrest.CoreMatchers.nullValue;
 import static org.hamcrest.MatcherAssert.assertThat;
 import org.hamcrest.Matchers;
+import static org.hamcrest.Matchers.containsInAnyOrder;
 import static org.hamcrest.Matchers.hasSize;
 import static org.hamcrest.collection.IsEmptyCollection.empty;
 import org.junit.After;
@@ -62,6 +63,7 @@
 import org.lmdbjava.Dbi.DbFullException;
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
 import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
+import static org.lmdbjava.DbiFlags.MDB_REVERSEKEY;
 import org.lmdbjava.Env.MapFullException;
 import static org.lmdbjava.Env.create;
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
@@ -474,4 +476,14 @@ public void testParallelWritesStress() {
           }
         });
   }
+
+  @Test
+  public void listsFlags() {
+    final Dbi<ByteBuffer> dbi = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT, MDB_REVERSEKEY);
+
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      final List<DbiFlags> flags = dbi.listFlags(txn);
+      assertThat(flags, containsInAnyOrder(MDB_DUPSORT, MDB_REVERSEKEY));
+    }
+  }
 }

From c016449d8b5370178fbe7a10151d2dd886516260 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Sat, 11 Apr 2020 15:40:04 +1000
Subject: [PATCH 032/322] Copyright update

---
 src/main/java/org/lmdbjava/BufferProxy.java          | 2 +-
 src/main/java/org/lmdbjava/ByteArrayProxy.java       | 2 +-
 src/main/java/org/lmdbjava/ByteBufferProxy.java      | 2 +-
 src/main/java/org/lmdbjava/CopyFlags.java            | 2 +-
 src/main/java/org/lmdbjava/Cursor.java               | 2 +-
 src/main/java/org/lmdbjava/CursorIterator.java       | 2 +-
 src/main/java/org/lmdbjava/Dbi.java                  | 2 +-
 src/main/java/org/lmdbjava/DbiFlags.java             | 2 +-
 src/main/java/org/lmdbjava/DirectBufferProxy.java    | 2 +-
 src/main/java/org/lmdbjava/Env.java                  | 2 +-
 src/main/java/org/lmdbjava/EnvFlags.java             | 2 +-
 src/main/java/org/lmdbjava/EnvInfo.java              | 2 +-
 src/main/java/org/lmdbjava/GetOp.java                | 2 +-
 src/main/java/org/lmdbjava/KeyRange.java             | 2 +-
 src/main/java/org/lmdbjava/KeyRangeType.java         | 2 +-
 src/main/java/org/lmdbjava/KeyVal.java               | 2 +-
 src/main/java/org/lmdbjava/Library.java              | 2 +-
 src/main/java/org/lmdbjava/LmdbException.java        | 2 +-
 src/main/java/org/lmdbjava/LmdbNativeException.java  | 2 +-
 src/main/java/org/lmdbjava/MaskedFlag.java           | 2 +-
 src/main/java/org/lmdbjava/Meta.java                 | 2 +-
 src/main/java/org/lmdbjava/PutFlags.java             | 2 +-
 src/main/java/org/lmdbjava/ResultCodeMapper.java     | 2 +-
 src/main/java/org/lmdbjava/SeekOp.java               | 2 +-
 src/main/java/org/lmdbjava/Stat.java                 | 2 +-
 src/main/java/org/lmdbjava/Txn.java                  | 2 +-
 src/main/java/org/lmdbjava/TxnFlags.java             | 2 +-
 src/main/java/org/lmdbjava/UnsafeAccess.java         | 2 +-
 src/main/java/org/lmdbjava/Verifier.java             | 2 +-
 src/main/java/org/lmdbjava/package-info.java         | 2 +-
 src/test/java/org/lmdbjava/ByteBufProxy.java         | 2 +-
 src/test/java/org/lmdbjava/ByteBufferProxyTest.java  | 2 +-
 src/test/java/org/lmdbjava/ComparatorTest.java       | 2 +-
 src/test/java/org/lmdbjava/CursorIteratorTest.java   | 2 +-
 src/test/java/org/lmdbjava/CursorParamTest.java      | 2 +-
 src/test/java/org/lmdbjava/CursorTest.java           | 2 +-
 src/test/java/org/lmdbjava/DbiTest.java              | 2 +-
 src/test/java/org/lmdbjava/EnvTest.java              | 2 +-
 src/test/java/org/lmdbjava/KeyRangeTest.java         | 2 +-
 src/test/java/org/lmdbjava/LibraryTest.java          | 2 +-
 src/test/java/org/lmdbjava/MaskedFlagTest.java       | 2 +-
 src/test/java/org/lmdbjava/MetaTest.java             | 2 +-
 src/test/java/org/lmdbjava/ResultCodeMapperTest.java | 2 +-
 src/test/java/org/lmdbjava/TestUtils.java            | 2 +-
 src/test/java/org/lmdbjava/TutorialTest.java         | 2 +-
 src/test/java/org/lmdbjava/TxnTest.java              | 2 +-
 src/test/java/org/lmdbjava/VerifierTest.java         | 2 +-
 src/test/java/org/lmdbjava/package-info.java         | 2 +-
 48 files changed, 48 insertions(+), 48 deletions(-)

diff --git a/src/main/java/org/lmdbjava/BufferProxy.java b/src/main/java/org/lmdbjava/BufferProxy.java
index 36f6a9eb..6ad9ef34 100644
--- a/src/main/java/org/lmdbjava/BufferProxy.java
+++ b/src/main/java/org/lmdbjava/BufferProxy.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/ByteArrayProxy.java b/src/main/java/org/lmdbjava/ByteArrayProxy.java
index a7213d09..237170b4 100644
--- a/src/main/java/org/lmdbjava/ByteArrayProxy.java
+++ b/src/main/java/org/lmdbjava/ByteArrayProxy.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
index 3d358856..de6db50b 100644
--- a/src/main/java/org/lmdbjava/ByteBufferProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/CopyFlags.java b/src/main/java/org/lmdbjava/CopyFlags.java
index cd471d0e..d85ffb06 100644
--- a/src/main/java/org/lmdbjava/CopyFlags.java
+++ b/src/main/java/org/lmdbjava/CopyFlags.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/Cursor.java b/src/main/java/org/lmdbjava/Cursor.java
index 80c5df4f..79138a69 100644
--- a/src/main/java/org/lmdbjava/Cursor.java
+++ b/src/main/java/org/lmdbjava/Cursor.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/CursorIterator.java b/src/main/java/org/lmdbjava/CursorIterator.java
index d03ae71b..c184a55b 100644
--- a/src/main/java/org/lmdbjava/CursorIterator.java
+++ b/src/main/java/org/lmdbjava/CursorIterator.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index d402a282..39fbf0ee 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/DbiFlags.java b/src/main/java/org/lmdbjava/DbiFlags.java
index b6f23092..0f9573dd 100644
--- a/src/main/java/org/lmdbjava/DbiFlags.java
+++ b/src/main/java/org/lmdbjava/DbiFlags.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/DirectBufferProxy.java b/src/main/java/org/lmdbjava/DirectBufferProxy.java
index 28aa7ff1..2ba68781 100644
--- a/src/main/java/org/lmdbjava/DirectBufferProxy.java
+++ b/src/main/java/org/lmdbjava/DirectBufferProxy.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 6d329cad..8b5cd1af 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/EnvFlags.java b/src/main/java/org/lmdbjava/EnvFlags.java
index eb267f33..50cdf494 100644
--- a/src/main/java/org/lmdbjava/EnvFlags.java
+++ b/src/main/java/org/lmdbjava/EnvFlags.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/EnvInfo.java b/src/main/java/org/lmdbjava/EnvInfo.java
index 3e2fe54e..fe16e92b 100644
--- a/src/main/java/org/lmdbjava/EnvInfo.java
+++ b/src/main/java/org/lmdbjava/EnvInfo.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/GetOp.java b/src/main/java/org/lmdbjava/GetOp.java
index 4d0040b3..82550f82 100644
--- a/src/main/java/org/lmdbjava/GetOp.java
+++ b/src/main/java/org/lmdbjava/GetOp.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/KeyRange.java b/src/main/java/org/lmdbjava/KeyRange.java
index a534d6e7..e8cd57ab 100644
--- a/src/main/java/org/lmdbjava/KeyRange.java
+++ b/src/main/java/org/lmdbjava/KeyRange.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/KeyRangeType.java b/src/main/java/org/lmdbjava/KeyRangeType.java
index be1f6c74..b286f72c 100644
--- a/src/main/java/org/lmdbjava/KeyRangeType.java
+++ b/src/main/java/org/lmdbjava/KeyRangeType.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/KeyVal.java b/src/main/java/org/lmdbjava/KeyVal.java
index 700cfc26..6bfd4546 100644
--- a/src/main/java/org/lmdbjava/KeyVal.java
+++ b/src/main/java/org/lmdbjava/KeyVal.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/Library.java b/src/main/java/org/lmdbjava/Library.java
index 3cb44fae..726f626c 100644
--- a/src/main/java/org/lmdbjava/Library.java
+++ b/src/main/java/org/lmdbjava/Library.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/LmdbException.java b/src/main/java/org/lmdbjava/LmdbException.java
index e19f8dca..e6004f19 100644
--- a/src/main/java/org/lmdbjava/LmdbException.java
+++ b/src/main/java/org/lmdbjava/LmdbException.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/LmdbNativeException.java b/src/main/java/org/lmdbjava/LmdbNativeException.java
index b80d9e13..81b46d15 100644
--- a/src/main/java/org/lmdbjava/LmdbNativeException.java
+++ b/src/main/java/org/lmdbjava/LmdbNativeException.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/MaskedFlag.java b/src/main/java/org/lmdbjava/MaskedFlag.java
index 14bbbabd..21dde5a1 100644
--- a/src/main/java/org/lmdbjava/MaskedFlag.java
+++ b/src/main/java/org/lmdbjava/MaskedFlag.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/Meta.java b/src/main/java/org/lmdbjava/Meta.java
index 5cd61b5a..46807f3c 100644
--- a/src/main/java/org/lmdbjava/Meta.java
+++ b/src/main/java/org/lmdbjava/Meta.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/PutFlags.java b/src/main/java/org/lmdbjava/PutFlags.java
index f15a4dd0..87bdacd9 100644
--- a/src/main/java/org/lmdbjava/PutFlags.java
+++ b/src/main/java/org/lmdbjava/PutFlags.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/ResultCodeMapper.java b/src/main/java/org/lmdbjava/ResultCodeMapper.java
index 678537e5..63310fcd 100644
--- a/src/main/java/org/lmdbjava/ResultCodeMapper.java
+++ b/src/main/java/org/lmdbjava/ResultCodeMapper.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/SeekOp.java b/src/main/java/org/lmdbjava/SeekOp.java
index 83f1a0f2..1d214adb 100644
--- a/src/main/java/org/lmdbjava/SeekOp.java
+++ b/src/main/java/org/lmdbjava/SeekOp.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/Stat.java b/src/main/java/org/lmdbjava/Stat.java
index 87dad739..de43577e 100644
--- a/src/main/java/org/lmdbjava/Stat.java
+++ b/src/main/java/org/lmdbjava/Stat.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/Txn.java b/src/main/java/org/lmdbjava/Txn.java
index 233cd6a5..67c84343 100644
--- a/src/main/java/org/lmdbjava/Txn.java
+++ b/src/main/java/org/lmdbjava/Txn.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/TxnFlags.java b/src/main/java/org/lmdbjava/TxnFlags.java
index 5fbb0285..a4cf3e8d 100644
--- a/src/main/java/org/lmdbjava/TxnFlags.java
+++ b/src/main/java/org/lmdbjava/TxnFlags.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/UnsafeAccess.java b/src/main/java/org/lmdbjava/UnsafeAccess.java
index 591cf905..92d1df5e 100644
--- a/src/main/java/org/lmdbjava/UnsafeAccess.java
+++ b/src/main/java/org/lmdbjava/UnsafeAccess.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/Verifier.java b/src/main/java/org/lmdbjava/Verifier.java
index 9ce5c008..207b9b7f 100644
--- a/src/main/java/org/lmdbjava/Verifier.java
+++ b/src/main/java/org/lmdbjava/Verifier.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/package-info.java b/src/main/java/org/lmdbjava/package-info.java
index 9447fb4b..05e35587 100644
--- a/src/main/java/org/lmdbjava/package-info.java
+++ b/src/main/java/org/lmdbjava/package-info.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/ByteBufProxy.java b/src/test/java/org/lmdbjava/ByteBufProxy.java
index 768c1b5e..9e220f16 100644
--- a/src/test/java/org/lmdbjava/ByteBufProxy.java
+++ b/src/test/java/org/lmdbjava/ByteBufProxy.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
index ef090cce..9399eada 100644
--- a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
+++ b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/ComparatorTest.java b/src/test/java/org/lmdbjava/ComparatorTest.java
index bfd6a8de..a2ea539b 100644
--- a/src/test/java/org/lmdbjava/ComparatorTest.java
+++ b/src/test/java/org/lmdbjava/ComparatorTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/CursorIteratorTest.java b/src/test/java/org/lmdbjava/CursorIteratorTest.java
index 7dd2acd0..c787ccb2 100644
--- a/src/test/java/org/lmdbjava/CursorIteratorTest.java
+++ b/src/test/java/org/lmdbjava/CursorIteratorTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/CursorParamTest.java b/src/test/java/org/lmdbjava/CursorParamTest.java
index 37e573e9..8756534e 100644
--- a/src/test/java/org/lmdbjava/CursorParamTest.java
+++ b/src/test/java/org/lmdbjava/CursorParamTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/CursorTest.java b/src/test/java/org/lmdbjava/CursorTest.java
index cdc73819..8e03ce5f 100644
--- a/src/test/java/org/lmdbjava/CursorTest.java
+++ b/src/test/java/org/lmdbjava/CursorTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 5d454cb8..81d49899 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index b111168d..0c580437 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/KeyRangeTest.java b/src/test/java/org/lmdbjava/KeyRangeTest.java
index bdbdbf66..68fed292 100644
--- a/src/test/java/org/lmdbjava/KeyRangeTest.java
+++ b/src/test/java/org/lmdbjava/KeyRangeTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/LibraryTest.java b/src/test/java/org/lmdbjava/LibraryTest.java
index f2cdbad3..35523272 100644
--- a/src/test/java/org/lmdbjava/LibraryTest.java
+++ b/src/test/java/org/lmdbjava/LibraryTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/MaskedFlagTest.java b/src/test/java/org/lmdbjava/MaskedFlagTest.java
index 3bf6990b..e5a63952 100644
--- a/src/test/java/org/lmdbjava/MaskedFlagTest.java
+++ b/src/test/java/org/lmdbjava/MaskedFlagTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/MetaTest.java b/src/test/java/org/lmdbjava/MetaTest.java
index d61e4a6e..18967fec 100644
--- a/src/test/java/org/lmdbjava/MetaTest.java
+++ b/src/test/java/org/lmdbjava/MetaTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/ResultCodeMapperTest.java b/src/test/java/org/lmdbjava/ResultCodeMapperTest.java
index 78adb498..5d915f84 100644
--- a/src/test/java/org/lmdbjava/ResultCodeMapperTest.java
+++ b/src/test/java/org/lmdbjava/ResultCodeMapperTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/TestUtils.java b/src/test/java/org/lmdbjava/TestUtils.java
index 7614f391..afc9c418 100644
--- a/src/test/java/org/lmdbjava/TestUtils.java
+++ b/src/test/java/org/lmdbjava/TestUtils.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/TutorialTest.java b/src/test/java/org/lmdbjava/TutorialTest.java
index d631126c..91dfe0f3 100644
--- a/src/test/java/org/lmdbjava/TutorialTest.java
+++ b/src/test/java/org/lmdbjava/TutorialTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/TxnTest.java b/src/test/java/org/lmdbjava/TxnTest.java
index 66b7276b..d8fcfb76 100644
--- a/src/test/java/org/lmdbjava/TxnTest.java
+++ b/src/test/java/org/lmdbjava/TxnTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/VerifierTest.java b/src/test/java/org/lmdbjava/VerifierTest.java
index 1302fd25..ad0b42d9 100644
--- a/src/test/java/org/lmdbjava/VerifierTest.java
+++ b/src/test/java/org/lmdbjava/VerifierTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/package-info.java b/src/test/java/org/lmdbjava/package-info.java
index 557d6fab..caa25a12 100644
--- a/src/test/java/org/lmdbjava/package-info.java
+++ b/src/test/java/org/lmdbjava/package-info.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2019 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

From 67faba6d46f96b464b983bbebe5525907658cebc Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 13 Apr 2020 11:22:15 +1000
Subject: [PATCH 033/322] PMD suppressions

---
 src/main/java/org/lmdbjava/Verifier.java           |  1 +
 src/test/java/org/lmdbjava/CursorIteratorTest.java |  1 +
 src/test/java/org/lmdbjava/CursorParamTest.java    |  2 +-
 src/test/java/org/lmdbjava/CursorTest.java         | 13 +++++++++++++
 src/test/java/org/lmdbjava/DbiTest.java            |  2 ++
 src/test/java/org/lmdbjava/EnvTest.java            |  4 ++++
 src/test/java/org/lmdbjava/TutorialTest.java       |  3 ++-
 src/test/java/org/lmdbjava/TxnTest.java            | 14 ++++++++++++++
 8 files changed, 38 insertions(+), 2 deletions(-)

diff --git a/src/main/java/org/lmdbjava/Verifier.java b/src/main/java/org/lmdbjava/Verifier.java
index 207b9b7f..38a0b531 100644
--- a/src/main/java/org/lmdbjava/Verifier.java
+++ b/src/main/java/org/lmdbjava/Verifier.java
@@ -163,6 +163,7 @@ public Long call() {
    * @param unit     units used to express the duration
    * @return number of database rows successfully verified
    */
+  @SuppressWarnings("PMD.DoNotUseThreads")
   public long runFor(final long duration, final TimeUnit unit) {
     final long deadline = System.currentTimeMillis() + unit.toMillis(duration);
     final ExecutorService es = Executors.newSingleThreadExecutor();
diff --git a/src/test/java/org/lmdbjava/CursorIteratorTest.java b/src/test/java/org/lmdbjava/CursorIteratorTest.java
index c787ccb2..ae20e57a 100644
--- a/src/test/java/org/lmdbjava/CursorIteratorTest.java
+++ b/src/test/java/org/lmdbjava/CursorIteratorTest.java
@@ -147,6 +147,7 @@ public void backwardSeekDeprecated() {
   }
 
   @Before
+  @SuppressWarnings("PMD.CloseResource")
   public void before() throws IOException {
     final File path = tmp.newFile();
     env = create()
diff --git a/src/test/java/org/lmdbjava/CursorParamTest.java b/src/test/java/org/lmdbjava/CursorParamTest.java
index 8756534e..75e78a84 100644
--- a/src/test/java/org/lmdbjava/CursorParamTest.java
+++ b/src/test/java/org/lmdbjava/CursorParamTest.java
@@ -104,7 +104,7 @@ protected AbstractBufferRunner(final BufferProxy<T> proxy) {
       this.proxy = proxy;
     }
 
-    @SuppressWarnings("checkstyle:executablestatementcount")
+    @SuppressWarnings({"checkstyle:executablestatementcount", "PMD.CloseResource"})
     @Override
     public final void execute(final TemporaryFolder tmp) {
       try (Env<T> env = env(tmp)) {
diff --git a/src/test/java/org/lmdbjava/CursorTest.java b/src/test/java/org/lmdbjava/CursorTest.java
index 8e03ce5f..aea29bbc 100644
--- a/src/test/java/org/lmdbjava/CursorTest.java
+++ b/src/test/java/org/lmdbjava/CursorTest.java
@@ -84,6 +84,7 @@ public void before() throws IOException {
   }
 
   @Test(expected = ClosedException.class)
+  @SuppressWarnings("PMD.CloseResource")
   public void closedCursorRejectsSubsequentGets() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
@@ -94,6 +95,7 @@ public void closedCursorRejectsSubsequentGets() {
   }
 
   @Test
+  @SuppressWarnings("PMD.CloseResource")
   public void count() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
@@ -124,6 +126,7 @@ public void cursorCannotCloseIfTransactionCommitted() {
   }
 
   @Test
+  @SuppressWarnings("PMD.CloseResource")
   public void cursorFirstLastNextPrev() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
@@ -154,6 +157,7 @@ public void cursorFirstLastNextPrev() {
   }
 
   @Test
+  @SuppressWarnings("PMD.CloseResource")
   public void delete() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
@@ -173,6 +177,7 @@ public void delete() {
   }
 
   @Test
+  @SuppressWarnings("PMD.CloseResource")
   public void putMultiple() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT,
                                            MDB_DUPFIXED);
@@ -194,6 +199,7 @@ public void putMultiple() {
   }
 
   @Test(expected = IllegalArgumentException.class)
+  @SuppressWarnings("PMD.CloseResource")
   public void putMultipleWithoutMdbMultipleFlag() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
@@ -203,6 +209,7 @@ public void putMultipleWithoutMdbMultipleFlag() {
   }
 
   @Test
+  @SuppressWarnings("PMD.CloseResource")
   public void renewTxRo() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
 
@@ -219,6 +226,7 @@ public void renewTxRo() {
   }
 
   @Test(expected = ReadOnlyRequiredException.class)
+  @SuppressWarnings("PMD.CloseResource")
   public void renewTxRw() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
@@ -230,6 +238,7 @@ public void renewTxRw() {
   }
 
   @Test
+  @SuppressWarnings("PMD.CloseResource")
   public void repeatedCloseCausesNotError() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
@@ -240,6 +249,7 @@ public void repeatedCloseCausesNotError() {
   }
 
   @Test
+  @SuppressWarnings("PMD.CloseResource")
   public void reserve() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
     final ByteBuffer key = bb(5);
@@ -259,6 +269,7 @@ public void reserve() {
   }
 
   @Test
+  @SuppressWarnings("PMD.CloseResource")
   public void returnValueForNoDupData() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
@@ -271,6 +282,7 @@ public void returnValueForNoDupData() {
   }
 
   @Test
+  @SuppressWarnings("PMD.CloseResource")
   public void returnValueForNoOverwrite() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
@@ -284,6 +296,7 @@ public void returnValueForNoOverwrite() {
   }
 
   @Test
+  @SuppressWarnings("PMD.CloseResource")
   public void testCursorByteBufferDuplicate() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 81d49899..32265ec0 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -107,6 +107,7 @@ public void close() {
   }
 
   @Test
+  @SuppressWarnings("PMD.CloseResource")
   public void customComparator() {
     final Comparator<ByteBuffer> reverseOrder = (o1, o2) -> {
       final int lexicalOrder = ByteBufferProxy.PROXY_OPTIMAL.compare(o1, o2);
@@ -140,6 +141,7 @@ public void dbOpenMaxDatabases() {
   }
 
   @Test
+  @SuppressWarnings({"PMD.CloseResource", "PMD.DoNotUseThreads"})
   public void dbiWithComparatorThreadSafety() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, PROXY_OPTIMAL::compare,
                                            MDB_CREATE);
diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index 0c580437..8b8e067f 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -100,6 +100,7 @@ public void cannotChangeMaxReadersAfterOpen() throws IOException {
   }
 
   @Test(expected = AlreadyClosedException.class)
+  @SuppressWarnings("PMD.CloseResource")
   public void cannotInfoOnceClosed() throws IOException {
     final File path = tmp.newFile();
     final Env<ByteBuffer> env = create()
@@ -129,6 +130,7 @@ public void cannotOverflowMapSize() {
   }
 
   @Test(expected = AlreadyClosedException.class)
+  @SuppressWarnings("PMD.CloseResource")
   public void cannotStatOnceClosed() throws IOException {
     final File path = tmp.newFile();
     final Env<ByteBuffer> env = create()
@@ -139,6 +141,7 @@ public void cannotStatOnceClosed() throws IOException {
   }
 
   @Test(expected = AlreadyClosedException.class)
+  @SuppressWarnings("PMD.CloseResource")
   public void cannotSyncOnceClosed() throws IOException {
     final File path = tmp.newFile();
     final Env<ByteBuffer> env = create()
@@ -200,6 +203,7 @@ public void copyRejectsNonEmptyDestination() throws IOException {
   }
 
   @Test
+  @SuppressWarnings("PMD.CloseResource")
   public void createAsDirectory() throws IOException {
     final File path = tmp.newFolder();
     final Env<ByteBuffer> env = create()
diff --git a/src/test/java/org/lmdbjava/TutorialTest.java b/src/test/java/org/lmdbjava/TutorialTest.java
index 91dfe0f3..7d4f37f5 100644
--- a/src/test/java/org/lmdbjava/TutorialTest.java
+++ b/src/test/java/org/lmdbjava/TutorialTest.java
@@ -64,6 +64,7 @@
  * need to install the LMDB system library yourself. 32-bit platforms are not
  * supported.
  */
+@SuppressWarnings("PMD.CloseResource")
 public final class TutorialTest {
 
   private static final String DB_NAME = "my DB";
@@ -147,7 +148,7 @@ public void tutorial1() throws IOException {
    * @throws InterruptedException if executor shutdown interrupted
    */
   @Test
-  @SuppressWarnings({"ConvertToTryWithResources",
+  @SuppressWarnings({"ConvertToTryWithResources", "PMD.DoNotUseThreads",
                      "checkstyle:executablestatementcount"})
   public void tutorial2() throws IOException, InterruptedException {
     final Env<ByteBuffer> env = createSimpleEnv(tmp.newFolder());
diff --git a/src/test/java/org/lmdbjava/TxnTest.java b/src/test/java/org/lmdbjava/TxnTest.java
index d8fcfb76..6f98be86 100644
--- a/src/test/java/org/lmdbjava/TxnTest.java
+++ b/src/test/java/org/lmdbjava/TxnTest.java
@@ -96,6 +96,7 @@ public void largeKeysRejected() throws IOException {
   }
 
   @Test
+  @SuppressWarnings("PMD.CloseResource")
   public void rangeSearch() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
 
@@ -152,6 +153,7 @@ public void readWriteTxnDeniedInReadOnlyEnv() {
   }
 
   @Test(expected = NotReadyException.class)
+  @SuppressWarnings("PMD.CloseResource")
   public void testCheckNotCommitted() {
     final Txn<ByteBuffer> txn = env.txnRead();
     txn.commit();
@@ -159,12 +161,14 @@ public void testCheckNotCommitted() {
   }
 
   @Test(expected = ReadOnlyRequiredException.class)
+  @SuppressWarnings("PMD.CloseResource")
   public void testCheckReadOnly() {
     final Txn<ByteBuffer> txn = env.txnWrite();
     txn.checkReadOnly();
   }
 
   @Test(expected = ReadWriteRequiredException.class)
+  @SuppressWarnings("PMD.CloseResource")
   public void testCheckWritesAllowed() {
     final Txn<ByteBuffer> txn = env.txnRead();
     txn.checkWritesAllowed();
@@ -210,6 +214,7 @@ public void txCannotAbortIfAlreadyCommitted() {
   }
 
   @Test(expected = NotReadyException.class)
+  @SuppressWarnings("PMD.CloseResource")
   public void txCannotCommitTwice() {
     final Txn<ByteBuffer> txn = env.txnRead();
     txn.commit();
@@ -224,6 +229,7 @@ public void txConstructionDeniedIfEnvClosed() {
   }
 
   @Test
+  @SuppressWarnings("PMD.CloseResource")
   public void txParent() {
     final Txn<ByteBuffer> txRoot = env.txnWrite();
     final Txn<ByteBuffer> txChild = env.txn(txRoot);
@@ -232,18 +238,21 @@ public void txParent() {
   }
 
   @Test(expected = IncompatibleParent.class)
+  @SuppressWarnings("PMD.CloseResource")
   public void txParentROChildRWIncompatible() {
     final Txn<ByteBuffer> txRoot = env.txnRead();
     env.txn(txRoot); // error
   }
 
   @Test(expected = IncompatibleParent.class)
+  @SuppressWarnings("PMD.CloseResource")
   public void txParentRWChildROIncompatible() {
     final Txn<ByteBuffer> txRoot = env.txnWrite();
     env.txn(txRoot, MDB_RDONLY_TXN); // error
   }
 
   @Test
+  @SuppressWarnings("PMD.CloseResource")
   public void txReadOnly() {
     final Txn<ByteBuffer> txn = env.txnRead();
     assertThat(txn.getParent(), is(nullValue()));
@@ -262,6 +271,7 @@ public void txReadOnly() {
   }
 
   @Test
+  @SuppressWarnings("PMD.CloseResource")
   public void txReadWrite() {
     final Txn<ByteBuffer> txn = env.txnWrite();
     assertThat(txn.getParent(), is(nullValue()));
@@ -276,12 +286,14 @@ public void txReadWrite() {
   }
 
   @Test(expected = NotResetException.class)
+  @SuppressWarnings("PMD.CloseResource")
   public void txRenewDeniedWithoutPriorReset() {
     final Txn<ByteBuffer> txn = env.txnRead();
     txn.renew();
   }
 
   @Test(expected = ResetException.class)
+  @SuppressWarnings("PMD.CloseResource")
   public void txResetDeniedForAlreadyResetTransaction() {
     final Txn<ByteBuffer> txn = env.txnRead();
     txn.reset();
@@ -291,12 +303,14 @@ public void txResetDeniedForAlreadyResetTransaction() {
   }
 
   @Test(expected = ReadOnlyRequiredException.class)
+  @SuppressWarnings("PMD.CloseResource")
   public void txResetDeniedForReadWriteTransaction() {
     final Txn<ByteBuffer> txn = env.txnWrite();
     txn.reset();
   }
 
   @Test(expected = BadValueSizeException.class)
+  @SuppressWarnings("PMD.CloseResource")
   public void zeroByteKeysRejected() throws IOException {
     final Dbi<ByteBuffer> dbi = env.openDbi(DB_1, MDB_CREATE);
     final ByteBuffer key = allocateDirect(4);

From a18dfadc1fadf78cf20ec681e40fdd421c2933a2 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 13 Apr 2020 11:22:29 +1000
Subject: [PATCH 034/322] Update to JNR FFI 2.1.12

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 3b0c2ca8..c363ccc0 100644
--- a/pom.xml
+++ b/pom.xml
@@ -72,7 +72,7 @@
     <dependency>
       <groupId>com.github.jnr</groupId>
       <artifactId>jnr-ffi</artifactId>
-      <version>2.1.9</version>
+      <version>2.1.12</version>
       <exclusions>
         <exclusion>
           <groupId>com.github.jnr</groupId>

From 9e9d4212b3877ca2bdd1405857476a700529d82a Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 13 Apr 2020 11:22:51 +1000
Subject: [PATCH 035/322] Update to JNR JFFI 1.2.23

---
 pom.xml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pom.xml b/pom.xml
index c363ccc0..b12764d7 100644
--- a/pom.xml
+++ b/pom.xml
@@ -83,13 +83,13 @@
     <dependency>
       <groupId>com.github.jnr</groupId>
       <artifactId>jffi</artifactId>
-      <version>1.2.18</version>
+      <version>1.2.23</version>
     </dependency>
     <dependency>
       <groupId>com.github.jnr</groupId>
       <artifactId>jffi</artifactId>
       <classifier>native</classifier>
-      <version>1.2.18</version>
+      <version>1.2.23</version>
     </dependency>
     <dependency>
       <groupId>com.github.jnr</groupId>

From 79b32a66e62157c46831fa7a18b1cc0d85f1b106 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 13 Apr 2020 11:23:03 +1000
Subject: [PATCH 036/322] Update to JNR Constants 0.9.15

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index b12764d7..d352abc3 100644
--- a/pom.xml
+++ b/pom.xml
@@ -94,7 +94,7 @@
     <dependency>
       <groupId>com.github.jnr</groupId>
       <artifactId>jnr-constants</artifactId>
-      <version>0.9.12</version>
+      <version>0.9.15</version>
     </dependency>
     <dependency>
       <groupId>com.jakewharton.byteunits</groupId>

From 11e95bd91b8d505d2c73377e06fd87ea5ebd4cb4 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 13 Apr 2020 11:23:13 +1000
Subject: [PATCH 037/322] Update to Agrona 1.4.1

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index d352abc3..238bb1ce 100644
--- a/pom.xml
+++ b/pom.xml
@@ -105,7 +105,7 @@
     <dependency>
       <groupId>org.agrona</groupId>
       <artifactId>agrona</artifactId>
-      <version>1.0.1</version>
+      <version>1.4.1</version>
       <optional>true</optional>
     </dependency>
     <dependency>

From f7d9a3bc60b5fc7e60c18b3166d1d5dcfd4beabd Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 13 Apr 2020 11:23:20 +1000
Subject: [PATCH 038/322] Update to Jetty 4.1.48

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 238bb1ce..3eb5c626 100644
--- a/pom.xml
+++ b/pom.xml
@@ -111,7 +111,7 @@
     <dependency>
       <groupId>io.netty</groupId>
       <artifactId>netty-all</artifactId>
-      <version>4.1.36.Final</version>
+      <version>4.1.48.Final</version>
       <scope>test</scope>
     </dependency>
     <dependency>

From e9ff5ea021ef507fc5d6c00f8fbafa384765b5ad Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 13 Apr 2020 11:23:29 +1000
Subject: [PATCH 039/322] Update to Guava 28.2

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 3eb5c626..495ab034 100644
--- a/pom.xml
+++ b/pom.xml
@@ -117,7 +117,7 @@
     <dependency>
       <groupId>com.google.guava</groupId>
       <artifactId>guava</artifactId>
-      <version>27.1-jre</version>
+      <version>28.2-jre</version>
       <scope>test</scope>
       <exclusions>
         <exclusion>

From a49f3321213a647147db089014ee1d2fb44ae5fa Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 13 Apr 2020 11:23:38 +1000
Subject: [PATCH 040/322] Update to Acegi Standard Project 0.2.5

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 495ab034..b01b2246 100644
--- a/pom.xml
+++ b/pom.xml
@@ -4,7 +4,7 @@
   <parent>
     <groupId>au.com.acegi</groupId>
     <artifactId>acegi-standard-project</artifactId>
-    <version>0.2.3</version>
+    <version>0.2.5</version>
   </parent>
   <groupId>org.lmdbjava</groupId>
   <artifactId>lmdbjava</artifactId>

From 4da2cd1bc4a6c2d2f7ebd715037ae67a529ada99 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 13 Apr 2020 12:47:54 +1000
Subject: [PATCH 041/322] AppVeyor to skip Checkstyle due to CRFL endings

---
 appveyor.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/appveyor.yml b/appveyor.yml
index 2623c2b0..2c1a5bb4 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -22,7 +22,7 @@ install:
   - pip install codecov
 
 build_script:
-  - mvn -V -B --settings .travis-settings.xml -e verify
+  - mvn -V -B -Dcheckstyle.skip=true --settings .travis-settings.xml -e verify
   - codecov -X gcov -f target/site/jacoco/jacoco.xml
 
 notifications:

From 870802846d3e9065c1b88abd22cbc2dfdf4de493 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 13 Apr 2020 12:48:10 +1000
Subject: [PATCH 042/322] AppVeyor to use Maven 3.6.3 as 3.6.0 no longer
 available

---
 appveyor.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/appveyor.yml b/appveyor.yml
index 2c1a5bb4..e4fc2013 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -6,7 +6,7 @@ clone_depth: 50
 
 environment:
   JAVA_HOME: "C:\\Program Files\\Java\\jdk11"
-  MVN_VER: 3.6.0
+  MVN_VER: 3.6.3
   PYTHON: "C:\\Python35"
 
 cache:

From 7b667f3cfe6a590dead7cf8f3825ac3351997b40 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 13 Apr 2020 13:03:42 +1000
Subject: [PATCH 043/322] Explicitly configure AppVeyor PMD rule set

---
 appveyor.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/appveyor.yml b/appveyor.yml
index e4fc2013..515a8d1e 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -22,7 +22,7 @@ install:
   - pip install codecov
 
 build_script:
-  - mvn -V -B -Dcheckstyle.skip=true --settings .travis-settings.xml -e verify
+  - mvn -V -B -Dpmd.ruleset=C:\projects\lmdbjava\target/acegi-standard-resources/au/com/acegi/standard/rule-set-pmd.xml -Dcheckstyle.skip=true --settings .travis-settings.xml -e verify
   - codecov -X gcov -f target/site/jacoco/jacoco.xml
 
 notifications:

From 248878a53d3c6ba6f4f750d3997fa22d62df5714 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 13 Apr 2020 13:33:37 +1000
Subject: [PATCH 044/322] Use explicit Netty JARs to mitigate
 dependency:go-offline failures

While https://netty.io/downloads.html states to use netty-all for
4.0.0 and above releases, both Travis and local development
environments successfully reproduce missing native artifacts. Given
Netty support is only for buffer testing purposes in LmdbJava, it's
easier to simply depend on the minimal Netty JARs that we
require. This also significantly speeds up builds when the .m2 cache
has been invalidated, as numerous unnecessary Netty components are no
longer downloaded.
---
 pom.xml | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index b01b2246..3c214cf3 100644
--- a/pom.xml
+++ b/pom.xml
@@ -110,7 +110,13 @@
     </dependency>
     <dependency>
       <groupId>io.netty</groupId>
-      <artifactId>netty-all</artifactId>
+      <artifactId>netty-buffer</artifactId>
+      <version>4.1.48.Final</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>io.netty</groupId>
+      <artifactId>netty-common</artifactId>
       <version>4.1.48.Final</version>
       <scope>test</scope>
     </dependency>
@@ -164,6 +170,7 @@
           </usedDependencies>
           <ignoredDependencies>
             <ignoredDependency>com.github.jnr:jffi</ignoredDependency>
+            <ignoredDependency>io.netty:netty-common</ignoredDependency>
           </ignoredDependencies>
         </configuration>
       </plugin>

From f7e685adc3f9b789282206a0f0a6a37963bd12c4 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 13 Apr 2020 13:43:44 +1000
Subject: [PATCH 045/322] Travis to test macOS via xcode 11.3 image

---
 .travis.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.travis.yml b/.travis.yml
index 37bd63ff..cfd5c1e8 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -9,7 +9,7 @@ matrix:
     jdk: openjdk8
   - os: osx
     language: java
-    osx_image: xcode10.1
+    osx_image: xcode11.3
 notifications:
   email:
     - ben.alex@acegi.com.au

From 08a0b43558e64b7536669f7b1c5b23e15a793e35 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Wed, 15 Apr 2020 10:49:23 +1000
Subject: [PATCH 046/322] Update to Acegi Standard Project 0.3.1

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 3c214cf3..a2c7d507 100644
--- a/pom.xml
+++ b/pom.xml
@@ -4,7 +4,7 @@
   <parent>
     <groupId>au.com.acegi</groupId>
     <artifactId>acegi-standard-project</artifactId>
-    <version>0.2.5</version>
+    <version>0.3.1</version>
   </parent>
   <groupId>org.lmdbjava</groupId>
   <artifactId>lmdbjava</artifactId>

From 43f101d03ea750db2320fef2493a9c1a5f63c481 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Wed, 15 Apr 2020 11:03:03 +1000
Subject: [PATCH 047/322] Migrate from Travis and AppVeyor to GitHub Actions

---
 .github/workflows/maven.yml | 100 ++++++++++++++++++++++++++++++++++++
 .travis-settings.xml        |  44 ----------------
 .travis.yml                 |  26 ----------
 README.md                   |  10 ++--
 appveyor.yml                |  33 ------------
 pom.xml                     |   4 +-
 6 files changed, 107 insertions(+), 110 deletions(-)
 create mode 100644 .github/workflows/maven.yml
 delete mode 100644 .travis-settings.xml
 delete mode 100644 .travis.yml
 delete mode 100644 appveyor.yml

diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml
new file mode 100644
index 00000000..e7d62450
--- /dev/null
+++ b/.github/workflows/maven.yml
@@ -0,0 +1,100 @@
+name: Maven Build and Deployment
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+    name: Java 11 Build and Verify
+    runs-on: ubuntu-16.04
+
+    steps:
+    - name: Check out Git repository
+      uses: actions/checkout@v2
+
+    - name: Set up Java and Maven
+      uses: actions/setup-java@v1
+      with:
+        java-version: 11
+
+    - name: Cache Maven packages
+      uses: actions/cache@v1
+      with:
+        path: ~/.m2
+        key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.xml') }}
+        restore-keys: ${{ runner.os }}-m2
+
+    - name: Build with Maven
+      run: mvn -B verify
+
+    - name: Upload code coverage to Codecov
+      uses: codecov/codecov-action@v1
+
+  compatibility-checks:
+    name: Java ${{ matrix.java }} on ${{ matrix.os }} Compatibility
+    runs-on: ${{ matrix.os }}
+
+    strategy:
+      matrix:
+        os: [ubuntu-16.04, macos-latest, windows-latest]
+        java: [8, 11, 14]
+
+    steps:
+      - name: Check out Git repository
+        uses: actions/checkout@v2
+
+      - name: Set up Java and Maven
+        uses: actions/setup-java@v1
+        with:
+          java-version: ${{ matrix.java }}
+
+      - name: Cache Maven packages
+        uses: actions/cache@v1
+        with:
+          path: ~/.m2
+          key: ${{ runner.os }}-${{ matrix.java }}-m2-${{ hashFiles('**/pom.xml') }}
+          restore-keys: ${{ runner.os }}-${{ matrix.java }}-m2
+
+      - name: Test with Maven
+        run: mvn -B test
+
+      - name: Upload Surefire reports on test failure
+        uses: actions/upload-artifact@v1
+        if: failure()
+        with:
+          name: surefire-test-log
+          path: target/surefire-reports
+
+  deploy:
+    name: Deploy to OSSRH
+    needs: [build, compatibility-checks]
+    if: github.event_name == 'push'
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Check out Git repository
+      uses: actions/checkout@v2
+
+    - name: Set up Java and Maven
+      uses: actions/setup-java@v1
+      with:
+        java-version: 11
+
+    - name: Cache Maven packages
+      uses: actions/cache@v1
+      with:
+        path: ~/.m2
+        key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.xml') }}
+        restore-keys: ${{ runner.os }}-m2
+
+    - name: Publish Maven package
+      uses: samuelmeuli/action-maven-publish@v1
+      with:
+        gpg_private_key: ${{ secrets.gpg_private_key }}
+        gpg_passphrase: ${{ secrets.gpg_passphrase }}
+        nexus_username: ${{ secrets.nexus_username }}
+        nexus_password: ${{ secrets.nexus_password }}
+        maven_args: "-DskipTests"
diff --git a/.travis-settings.xml b/.travis-settings.xml
deleted file mode 100644
index 8fcbfc94..00000000
--- a/.travis-settings.xml
+++ /dev/null
@@ -1,44 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<settings>
-  <servers>
-    <server>
-      <id>ossrh</id>
-      <username>${env.CENTRAL_USERNAME}</username>
-      <password>${env.CENTRAL_PASSWORD}</password>
-    </server>
-    <server>
-      <id>github</id>
-      <password>${env.GITHUB_PASSWORD}</password>
-    </server>
-  </servers>
-  <profiles>
-    <profile>
-      <id>ossrh</id>
-      <activation>
-        <activeByDefault>true</activeByDefault>
-      </activation>
-      <properties>
-        <gpg.keyname>${env.GPG_KEY_NAME}</gpg.keyname>
-        <gpg.passphrase>${env.GPG_PASSPHRASE}</gpg.passphrase>
-      </properties>
-    </profile>
-    <profile>
-      <id>allow-snapshots</id>
-      <activation>
-        <activeByDefault>true</activeByDefault>
-      </activation>
-      <repositories>
-        <repository>
-          <id>snapshots-repo</id>
-          <url>https://oss.sonatype.org/content/repositories/snapshots</url>
-          <releases>
-            <enabled>false</enabled>
-          </releases>
-          <snapshots>
-            <enabled>true</enabled>
-          </snapshots>
-        </repository>
-      </repositories>
-    </profile>
-  </profiles>
-</settings>
diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index cfd5c1e8..00000000
--- a/.travis.yml
+++ /dev/null
@@ -1,26 +0,0 @@
-cache:
-  directories:
-  - $HOME/.m2
-matrix:
-  include:
-  - os: linux
-    dist: xenial
-    language: java
-    jdk: openjdk8
-  - os: osx
-    language: java
-    osx_image: xcode11.3
-notifications:
-  email:
-    - ben.alex@acegi.com.au
-    - stoffe@gmail.com
-before_install:
-  - if [ "$TRAVIS_OS_NAME" == "osx" ]; then export JAVA_HOME=$(/usr/libexec/java_home); fi
-install:
-  - mvn -B -Pdeploy --settings .travis-settings.xml -V dependency:go-offline
-script:
-  - mvn -B -Pdeploy --settings .travis-settings.xml -Dgpg.skip=true verify
-after_success:
-  - bash <(curl -s https://codecov.io/bash)
-  - if [ "$TRAVIS_PULL_REQUEST" == "false" ] && [ "$TRAVIS_TAG" == "" ] && [ "$TRAVIS_OS_NAME" == "linux" ]; then echo $GPG_KEY | base64 --decode | gpg --batch --fast-import -; fi
-  - if [ "$TRAVIS_PULL_REQUEST" == "false" ] && [ "$TRAVIS_TAG" == "" ] && [ "$TRAVIS_OS_NAME" == "linux" ]; then mvn -B -Pdeploy --settings .travis-settings.xml deploy; fi
diff --git a/README.md b/README.md
index 611c2f0f..e2ee753b 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,4 @@
-[![Build Status](https://travis-ci.org/lmdbjava/lmdbjava.svg?branch=master)](https://travis-ci.org/lmdbjava/lmdbjava)
-[![Build Status](https://ci.appveyor.com/api/projects/status/0w4yb9ybx22g2pwp?svg=true)](https://ci.appveyor.com/project/benalexau/lmdbjava)
+[![Maven Build and Deployment](https://github.com/lmdbjava/lmdbjava/workflows/Maven%20Build%20and%20Deployment/badge.svg)](https://github.com/lmdbjava/lmdbjava/actions)
 [![codecov](https://codecov.io/gh/lmdbjava/lmdbjava/branch/master/graph/badge.svg)](https://codecov.io/gh/lmdbjava/lmdbjava)
 [![Javadocs](http://www.javadoc.io/badge/org.lmdbjava/lmdbjava.svg?color=blue)](http://www.javadoc.io/doc/org.lmdbjava/lmdbjava)
 [![Maven Central](https://img.shields.io/maven-central/v/org.lmdbjava/lmdbjava.svg?maxAge=3600)](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22org.lmdbjava%22%20AND%20a%3A%22lmdbjava%22)
@@ -35,9 +34,10 @@
 * Community questions and contributions are welcome through [GitHub tickets](https://github.com/lmdbjava/lmdbjava/issues)
 * Mature code (commenced in 2016) and used for heavy production workloads (eg > 500 TB of HFT data)
 * Actively maintained and with a "Zero Bug Policy" before every release (see [issues](https://github.com/lmdbjava/lmdbjava/issues))
-* Available from [Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22org.lmdbjava%22%20AND%20a%3A%22lmdbjava%22) and [OSS Sonatype Snapshots](https://oss.sonatype.org/content/repositories/snapshots/org/lmdbjava/lmdbjava) (see [Change Log](https://github.com/lmdbjava/lmdbjava/wiki/Change-Log))
-* Comprehensive [JavaDocs](http://www.javadoc.io/doc/org.lmdbjava/lmdbjava)
-* [Linux](https://travis-ci.org/lmdbjava/lmdbjava), [OS X](https://travis-ci.org/lmdbjava/lmdbjava) and [Windows](https://ci.appveyor.com/project/benalexau/lmdbjava) CI
+* Available from [Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22org.lmdbjava%22%20AND%20a%3A%22lmdbjava%22) and [OSS Sonatype Snapshots](https://oss.sonatype.org/content/repositories/snapshots/org/lmdbjava/lmdbjava)
+* Detailed [JavaDocs](http://www.javadoc.io/doc/org.lmdbjava/lmdbjava)
+* [Change Log](https://github.com/lmdbjava/lmdbjava/wiki/Change-Log) to assist with upgrades
+* [Continuous integration](https://github.com/lmdbjava/lmdbjava/actions) testing on Linux, Windows and macOS across Java versions 8, 11 and 14
 
 ### Performance
 
diff --git a/appveyor.yml b/appveyor.yml
deleted file mode 100644
index 515a8d1e..00000000
--- a/appveyor.yml
+++ /dev/null
@@ -1,33 +0,0 @@
-version: '{build}'
-
-image: Visual Studio 2017
-
-clone_depth: 50
-
-environment:
-  JAVA_HOME: "C:\\Program Files\\Java\\jdk11"
-  MVN_VER: 3.6.3
-  PYTHON: "C:\\Python35"
-
-cache:
-  - C:\Users\appveyor\apache-maven-%MVN_VER% -> appveyor.yml
-  - C:\Users\appveyor\.m2 -> pom.xml
-
-install:
-  - if not exist C:\Users\appveyor\apache-maven-%MVN_VER% (
-      curl -LsS "http://www.apache.org/dyn/closer.cgi?action=download&filename=maven/maven-3/%MVN_VER%/binaries/apache-maven-%MVN_VER%-bin.zip" > apache-maven.zip &&
-      unzip apache-maven.zip -d C:\Users\appveyor
-    )
-  - SET PATH=%PYTHON%;%PYTHON%\\Scripts;C:\Users\appveyor\apache-maven-%MVN_VER%\bin;%PATH%
-  - pip install codecov
-
-build_script:
-  - mvn -V -B -Dpmd.ruleset=C:\projects\lmdbjava\target/acegi-standard-resources/au/com/acegi/standard/rule-set-pmd.xml -Dcheckstyle.skip=true --settings .travis-settings.xml -e verify
-  - codecov -X gcov -f target/site/jacoco/jacoco.xml
-
-notifications:
-  - provider: Email
-    to:
-      - ben.alex@acegi.com.au
-      - stoffe@gmail.com
-    on_build_success: false
diff --git a/pom.xml b/pom.xml
index a2c7d507..827dd173 100644
--- a/pom.xml
+++ b/pom.xml
@@ -52,8 +52,8 @@
     <url>https://github.com/${github.org}/${github.repo}/issues</url>
   </issueManagement>
   <ciManagement>
-    <system>travis-ci</system>
-    <url>https://travis-ci.org/${github.org}/${github.repo}</url>
+    <system>GitHub Actions</system>
+    <url>https://github.com/${github.org}/${github.repo}/actions</url>
   </ciManagement>
   <properties>
     <github.org>lmdbjava</github.org>

From 528dad36948fda48432377aec59c7e4c0b3b05ea Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Wed, 15 Apr 2020 14:03:05 +1000
Subject: [PATCH 048/322] Update to LMDB 0.9.24 snapshot for testing (#148)

---
 .github/workflows/maven.yml | 18 +++++++++++++++---
 pom.xml                     |  8 ++++----
 2 files changed, 19 insertions(+), 7 deletions(-)

diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml
index e7d62450..4953db73 100644
--- a/.github/workflows/maven.yml
+++ b/.github/workflows/maven.yml
@@ -20,12 +20,16 @@ jobs:
       with:
         java-version: 11
 
+    - name: Add OSSRH to the snapshot repositories list
+      uses: s4u/maven-settings-action@v2.1.0
+      with:
+        sonatypeSnapshots: true
+
     - name: Cache Maven packages
       uses: actions/cache@v1
       with:
         path: ~/.m2
         key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.xml') }}
-        restore-keys: ${{ runner.os }}-m2
 
     - name: Build with Maven
       run: mvn -B verify
@@ -51,12 +55,16 @@ jobs:
         with:
           java-version: ${{ matrix.java }}
 
+      - name: Add OSSRH to the snapshot repositories list
+        uses: s4u/maven-settings-action@v2.1.0
+        with:
+          sonatypeSnapshots: true
+
       - name: Cache Maven packages
         uses: actions/cache@v1
         with:
           path: ~/.m2
           key: ${{ runner.os }}-${{ matrix.java }}-m2-${{ hashFiles('**/pom.xml') }}
-          restore-keys: ${{ runner.os }}-${{ matrix.java }}-m2
 
       - name: Test with Maven
         run: mvn -B test
@@ -83,12 +91,16 @@ jobs:
       with:
         java-version: 11
 
+    - name: Add OSSRH to the snapshot repositories list
+      uses: s4u/maven-settings-action@v2.1.0
+      with:
+        sonatypeSnapshots: true
+
     - name: Cache Maven packages
       uses: actions/cache@v1
       with:
         path: ~/.m2
         key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.xml') }}
-        restore-keys: ${{ runner.os }}-m2
 
     - name: Publish Maven package
       uses: samuelmeuli/action-maven-publish@v1
diff --git a/pom.xml b/pom.xml
index 827dd173..6b032ef0 100644
--- a/pom.xml
+++ b/pom.xml
@@ -8,7 +8,7 @@
   </parent>
   <groupId>org.lmdbjava</groupId>
   <artifactId>lmdbjava</artifactId>
-  <version>0.7.1-SNAPSHOT</version>
+  <version>0.8.0-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>LmdbJava</name>
   <description>Low latency Java API for the ultra-fast, embedded Symas Lightning Database (LMDB)</description>
@@ -135,19 +135,19 @@
     <dependency>
       <groupId>org.lmdbjava</groupId>
       <artifactId>lmdbjava-native-linux-x86_64</artifactId>
-      <version>0.9.23-1</version>
+      <version>0.9.24-1-SNAPSHOT</version>
       <optional>true</optional>
     </dependency>
     <dependency>
       <groupId>org.lmdbjava</groupId>
       <artifactId>lmdbjava-native-windows-x86_64</artifactId>
-      <version>0.9.23-1</version>
+      <version>0.9.24-1-SNAPSHOT</version>
       <optional>true</optional>
     </dependency>
     <dependency>
       <groupId>org.lmdbjava</groupId>
       <artifactId>lmdbjava-native-osx-x86_64</artifactId>
-      <version>0.9.23-1</version>
+      <version>0.9.24-1-SNAPSHOT</version>
       <optional>true</optional>
     </dependency>
     <dependency>

From e621eb8846539be62dd52bb4538a792a5db74c06 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Wed, 15 Apr 2020 14:37:22 +1000
Subject: [PATCH 049/322] Add Ubuntu 18.04 to CI (#147)

---
 .github/workflows/maven.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml
index 4953db73..b6899406 100644
--- a/.github/workflows/maven.yml
+++ b/.github/workflows/maven.yml
@@ -9,7 +9,7 @@ on:
 jobs:
   build:
     name: Java 11 Build and Verify
-    runs-on: ubuntu-16.04
+    runs-on: ubuntu-latest
 
     steps:
     - name: Check out Git repository
@@ -43,7 +43,7 @@ jobs:
 
     strategy:
       matrix:
-        os: [ubuntu-16.04, macos-latest, windows-latest]
+        os: [ubuntu-16.04, ubuntu-latest, macos-latest, windows-latest]
         java: [8, 11, 14]
 
     steps:

From fed0c5df22ade16e05570f10d624bca5c64221bf Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Wed, 15 Apr 2020 14:44:07 +1000
Subject: [PATCH 050/322] Perform TutorialTest in two phases during CI

---
 .github/workflows/maven.yml | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml
index b6899406..a657e88d 100644
--- a/.github/workflows/maven.yml
+++ b/.github/workflows/maven.yml
@@ -32,7 +32,7 @@ jobs:
         key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.xml') }}
 
     - name: Build with Maven
-      run: mvn -B verify
+      run: mvn -B -Dtest='!TutorialTest' verify
 
     - name: Upload code coverage to Codecov
       uses: codecov/codecov-action@v1
@@ -67,7 +67,10 @@ jobs:
           key: ${{ runner.os }}-${{ matrix.java }}-m2-${{ hashFiles('**/pom.xml') }}
 
       - name: Test with Maven
-        run: mvn -B test
+        run: mvn -B -Dtest='!TutorialTest' test
+
+      - name: Test with Maven 2
+        run: mvn -B -Dtest='TutorialTest' test
 
       - name: Upload Surefire reports on test failure
         uses: actions/upload-artifact@v1

From d273a58bbb81781a4c034b2f2be7e106b1edbf4b Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Wed, 15 Apr 2020 15:53:29 +1000
Subject: [PATCH 051/322] Handle resource closing via try-with-resources where
 possible

Certain test cases cannot use a try-with-resources block because the
test is fundamentally designed to exercise improper closing sequences.

The TutorialTest remains an exception in the interests of
readability. However it may be necessary to refactor into individual
test classes so the resources can be better managed.
---
 .../java/org/lmdbjava/CursorParamTest.java    |   6 +-
 src/test/java/org/lmdbjava/CursorTest.java    |  55 ++++-----
 src/test/java/org/lmdbjava/DbiTest.java       |  11 +-
 src/test/java/org/lmdbjava/TxnTest.java       | 115 +++++++++---------
 4 files changed, 89 insertions(+), 98 deletions(-)

diff --git a/src/test/java/org/lmdbjava/CursorParamTest.java b/src/test/java/org/lmdbjava/CursorParamTest.java
index 75e78a84..0e2fa9ee 100644
--- a/src/test/java/org/lmdbjava/CursorParamTest.java
+++ b/src/test/java/org/lmdbjava/CursorParamTest.java
@@ -104,16 +104,16 @@ protected AbstractBufferRunner(final BufferProxy<T> proxy) {
       this.proxy = proxy;
     }
 
-    @SuppressWarnings({"checkstyle:executablestatementcount", "PMD.CloseResource"})
+    @SuppressWarnings("checkstyle:executablestatementcount")
     @Override
     public final void execute(final TemporaryFolder tmp) {
       try (Env<T> env = env(tmp)) {
         assertThat(env.getDbiNames(), empty());
         final Dbi<T> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
         assertThat(env.getDbiNames().get(0), is(DB_1.getBytes(UTF_8)));
-        try (Txn<T> txn = env.txnWrite()) {
+        try (Txn<T> txn = env.txnWrite();
+             Cursor<T> c = db.openCursor(txn)) {
           // populate data
-          final Cursor<T> c = db.openCursor(txn);
           c.put(set(1), set(2), MDB_NOOVERWRITE);
           c.put(set(3), set(4));
           c.put(set(5), set(6));
diff --git a/src/test/java/org/lmdbjava/CursorTest.java b/src/test/java/org/lmdbjava/CursorTest.java
index aea29bbc..40dd9f97 100644
--- a/src/test/java/org/lmdbjava/CursorTest.java
+++ b/src/test/java/org/lmdbjava/CursorTest.java
@@ -95,11 +95,10 @@ public void closedCursorRejectsSubsequentGets() {
   }
 
   @Test
-  @SuppressWarnings("PMD.CloseResource")
   public void count() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
-    try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      final Cursor<ByteBuffer> c = db.openCursor(txn);
+    try (Txn<ByteBuffer> txn = env.txnWrite();
+         Cursor<ByteBuffer> c = db.openCursor(txn)) {
       c.put(bb(1), bb(2), MDB_APPENDDUP);
       assertThat(c.count(), is(1L));
       c.put(bb(1), bb(4), MDB_APPENDDUP);
@@ -126,12 +125,10 @@ public void cursorCannotCloseIfTransactionCommitted() {
   }
 
   @Test
-  @SuppressWarnings("PMD.CloseResource")
   public void cursorFirstLastNextPrev() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
-    try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      // populate data
-      final Cursor<ByteBuffer> c = db.openCursor(txn);
+    try (Txn<ByteBuffer> txn = env.txnWrite();
+         Cursor<ByteBuffer> c = db.openCursor(txn)) {
       c.put(bb(1), bb(2), MDB_NOOVERWRITE);
       c.put(bb(3), bb(4));
       c.put(bb(5), bb(6));
@@ -157,11 +154,10 @@ public void cursorFirstLastNextPrev() {
   }
 
   @Test
-  @SuppressWarnings("PMD.CloseResource")
   public void delete() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
-    try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      final Cursor<ByteBuffer> c = db.openCursor(txn);
+    try (Txn<ByteBuffer> txn = env.txnWrite();
+         Cursor<ByteBuffer> c = db.openCursor(txn)) {
       c.put(bb(1), bb(2), MDB_NOOVERWRITE);
       c.put(bb(3), bb(4));
       assertThat(c.seek(MDB_FIRST), is(true));
@@ -177,7 +173,6 @@ public void delete() {
   }
 
   @Test
-  @SuppressWarnings("PMD.CloseResource")
   public void putMultiple() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT,
                                            MDB_DUPFIXED);
@@ -191,19 +186,18 @@ public void putMultiple() {
 
     final int key = 100;
     final ByteBuffer k = bb(key);
-    try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      final Cursor<ByteBuffer> c = db.openCursor(txn);
+    try (Txn<ByteBuffer> txn = env.txnWrite();
+         Cursor<ByteBuffer> c = db.openCursor(txn)) {
       c.putMultiple(k, values, elemCount, MDB_MULTIPLE);
       assertThat(c.count(), is((long) elemCount));
     }
   }
 
   @Test(expected = IllegalArgumentException.class)
-  @SuppressWarnings("PMD.CloseResource")
   public void putMultipleWithoutMdbMultipleFlag() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
-    try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      final Cursor<ByteBuffer> c = db.openCursor(txn);
+    try (Txn<ByteBuffer> txn = env.txnWrite();
+         Cursor<ByteBuffer> c = db.openCursor(txn)) {
       c.putMultiple(bb(100), bb(1), 1);
     }
   }
@@ -223,17 +217,19 @@ public void renewTxRo() {
       c.renew(txn);
       txn.commit();
     }
+
+    c.close();
   }
 
   @Test(expected = ReadOnlyRequiredException.class)
-  @SuppressWarnings("PMD.CloseResource")
   public void renewTxRw() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       assertThat(txn.isReadOnly(), is(false));
 
-      final Cursor<ByteBuffer> c = db.openCursor(txn);
-      c.renew(txn);
+      try (Cursor<ByteBuffer> c = db.openCursor(txn)) {
+        c.renew(txn);
+      }
     }
   }
 
@@ -249,16 +245,16 @@ public void repeatedCloseCausesNotError() {
   }
 
   @Test
-  @SuppressWarnings("PMD.CloseResource")
   public void reserve() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
     final ByteBuffer key = bb(5);
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      final Cursor<ByteBuffer> c = db.openCursor(txn);
       assertNull(db.get(txn, key));
-      final ByteBuffer val = c.reserve(key, BYTES * 2);
-      assertNotNull(db.get(txn, key));
-      val.putLong(MIN_VALUE).flip();
+      try (Cursor<ByteBuffer> c = db.openCursor(txn)) {
+        final ByteBuffer val = c.reserve(key, BYTES * 2);
+        assertNotNull(db.get(txn, key));
+        val.putLong(MIN_VALUE).flip();
+      }
       txn.commit();
     }
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
@@ -269,11 +265,10 @@ public void reserve() {
   }
 
   @Test
-  @SuppressWarnings("PMD.CloseResource")
   public void returnValueForNoDupData() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
-    try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      final Cursor<ByteBuffer> c = db.openCursor(txn);
+    try (Txn<ByteBuffer> txn = env.txnWrite();
+         Cursor<ByteBuffer> c = db.openCursor(txn)) {
       // ok
       assertThat(c.put(bb(5), bb(6), MDB_NODUPDATA), is(true));
       assertThat(c.put(bb(5), bb(7), MDB_NODUPDATA), is(true));
@@ -282,11 +277,10 @@ public void returnValueForNoDupData() {
   }
 
   @Test
-  @SuppressWarnings("PMD.CloseResource")
   public void returnValueForNoOverwrite() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
-    try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      final Cursor<ByteBuffer> c = db.openCursor(txn);
+    try (Txn<ByteBuffer> txn = env.txnWrite();
+         Cursor<ByteBuffer> c = db.openCursor(txn)) {
       // ok
       assertThat(c.put(bb(5), bb(6), MDB_NOOVERWRITE), is(true));
       // fails, but gets exist val
@@ -296,7 +290,6 @@ public void returnValueForNoOverwrite() {
   }
 
   @Test
-  @SuppressWarnings("PMD.CloseResource")
   public void testCursorByteBufferDuplicate() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 32265ec0..882d7731 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -107,7 +107,6 @@ public void close() {
   }
 
   @Test
-  @SuppressWarnings("PMD.CloseResource")
   public void customComparator() {
     final Comparator<ByteBuffer> reverseOrder = (o1, o2) -> {
       final int lexicalOrder = ByteBufferProxy.PROXY_OPTIMAL.compare(o1, o2);
@@ -124,8 +123,8 @@ public void customComparator() {
       assertThat(db.put(txn, bb(8), bb(7)), is(true));
       txn.commit();
     }
-    try (Txn<ByteBuffer> txn = env.txnRead()) {
-      final CursorIterator<ByteBuffer> iter = db.iterate(txn, atMost(bb(4)));
+    try (Txn<ByteBuffer> txn = env.txnRead();
+         CursorIterator<ByteBuffer> iter = db.iterate(txn, atMost(bb(4)))) {
       assertThat(iter.next().key(), is(bb(8)));
       assertThat(iter.next().key(), is(bb(6)));
       assertThat(iter.next().key(), is(bb(4)));
@@ -141,7 +140,7 @@ public void dbOpenMaxDatabases() {
   }
 
   @Test
-  @SuppressWarnings({"PMD.CloseResource", "PMD.DoNotUseThreads"})
+  @SuppressWarnings("PMD.DoNotUseThreads")
   public void dbiWithComparatorThreadSafety() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, PROXY_OPTIMAL::compare,
                                            MDB_CREATE);
@@ -165,8 +164,8 @@ public void dbiWithComparatorThreadSafety() {
       }
     }
 
-    try (Txn<ByteBuffer> txn = env.txnRead()) {
-      final CursorIterator<ByteBuffer> iter = db.iterate(txn);
+    try (Txn<ByteBuffer> txn = env.txnRead();
+         CursorIterator<ByteBuffer> iter = db.iterate(txn)) {
 
       final List<Integer> result = new ArrayList<>();
       while (iter.hasNext()) {
diff --git a/src/test/java/org/lmdbjava/TxnTest.java b/src/test/java/org/lmdbjava/TxnTest.java
index 6f98be86..21b35808 100644
--- a/src/test/java/org/lmdbjava/TxnTest.java
+++ b/src/test/java/org/lmdbjava/TxnTest.java
@@ -46,6 +46,7 @@
 import static org.lmdbjava.Env.create;
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
 import static org.lmdbjava.EnvFlags.MDB_RDONLY_ENV;
+import static org.lmdbjava.KeyRange.closed;
 import static org.lmdbjava.TestUtils.DB_1;
 import static org.lmdbjava.TestUtils.POSIX_MODE;
 import static org.lmdbjava.TestUtils.bb;
@@ -96,7 +97,6 @@ public void largeKeysRejected() throws IOException {
   }
 
   @Test
-  @SuppressWarnings("PMD.CloseResource")
   public void rangeSearch() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
 
@@ -120,10 +120,10 @@ public void rangeSearch() {
       end.put("z".getBytes(UTF_8)).flip();
 
       final List<String> keysFound = new ArrayList<>();
-      final CursorIterator<ByteBuffer> ckr = db.iterate(txn, KeyRange.closed(
-                                                        start, end));
-      for (final CursorIterator.KeyVal<ByteBuffer> kv : ckr.iterable()) {
-        keysFound.add(UTF_8.decode(kv.key()).toString());
+      try (CursorIterator<ByteBuffer> ckr = db.iterate(txn, closed(start, end))) {
+        for (final CursorIterator.KeyVal<ByteBuffer> kv : ckr.iterable()) {
+          keysFound.add(UTF_8.decode(kv.key()).toString());
+        }
       }
 
       assertEquals(3, keysFound.size());
@@ -153,25 +153,25 @@ public void readWriteTxnDeniedInReadOnlyEnv() {
   }
 
   @Test(expected = NotReadyException.class)
-  @SuppressWarnings("PMD.CloseResource")
   public void testCheckNotCommitted() {
-    final Txn<ByteBuffer> txn = env.txnRead();
-    txn.commit();
-    txn.checkReady();
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      txn.commit();
+      txn.checkReady();
+    }
   }
 
   @Test(expected = ReadOnlyRequiredException.class)
-  @SuppressWarnings("PMD.CloseResource")
   public void testCheckReadOnly() {
-    final Txn<ByteBuffer> txn = env.txnWrite();
-    txn.checkReadOnly();
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      txn.checkReadOnly();
+    }
   }
 
   @Test(expected = ReadWriteRequiredException.class)
-  @SuppressWarnings("PMD.CloseResource")
   public void testCheckWritesAllowed() {
-    final Txn<ByteBuffer> txn = env.txnRead();
-    txn.checkWritesAllowed();
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      txn.checkWritesAllowed();
+    }
   }
 
   @Test
@@ -214,11 +214,11 @@ public void txCannotAbortIfAlreadyCommitted() {
   }
 
   @Test(expected = NotReadyException.class)
-  @SuppressWarnings("PMD.CloseResource")
   public void txCannotCommitTwice() {
-    final Txn<ByteBuffer> txn = env.txnRead();
-    txn.commit();
-    txn.commit(); // error
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      txn.commit();
+      txn.commit(); // error
+    }
   }
 
   @Test(expected = AlreadyClosedException.class)
@@ -229,45 +229,45 @@ public void txConstructionDeniedIfEnvClosed() {
   }
 
   @Test
-  @SuppressWarnings("PMD.CloseResource")
   public void txParent() {
-    final Txn<ByteBuffer> txRoot = env.txnWrite();
-    final Txn<ByteBuffer> txChild = env.txn(txRoot);
-    assertThat(txRoot.getParent(), is(nullValue()));
-    assertThat(txChild.getParent(), is(txRoot));
+    try (Txn<ByteBuffer> txRoot = env.txnWrite();
+         Txn<ByteBuffer> txChild = env.txn(txRoot)) {
+      assertThat(txRoot.getParent(), is(nullValue()));
+      assertThat(txChild.getParent(), is(txRoot));
+    }
   }
 
   @Test(expected = IncompatibleParent.class)
-  @SuppressWarnings("PMD.CloseResource")
   public void txParentROChildRWIncompatible() {
-    final Txn<ByteBuffer> txRoot = env.txnRead();
-    env.txn(txRoot); // error
+    try (Txn<ByteBuffer> txRoot = env.txnRead()) {
+      env.txn(txRoot); // error
+    }
   }
 
   @Test(expected = IncompatibleParent.class)
-  @SuppressWarnings("PMD.CloseResource")
   public void txParentRWChildROIncompatible() {
-    final Txn<ByteBuffer> txRoot = env.txnWrite();
-    env.txn(txRoot, MDB_RDONLY_TXN); // error
+    try (Txn<ByteBuffer> txRoot = env.txnWrite()) {
+      env.txn(txRoot, MDB_RDONLY_TXN); // error
+    }
   }
 
   @Test
-  @SuppressWarnings("PMD.CloseResource")
   public void txReadOnly() {
-    final Txn<ByteBuffer> txn = env.txnRead();
-    assertThat(txn.getParent(), is(nullValue()));
-    assertThat(txn.getState(), is(READY));
-    assertThat(txn.isReadOnly(), is(true));
-    txn.checkReady();
-    txn.checkReadOnly();
-    txn.reset();
-    assertThat(txn.getState(), is(RESET));
-    txn.renew();
-    assertThat(txn.getState(), is(READY));
-    txn.commit();
-    assertThat(txn.getState(), is(DONE));
-    txn.close();
-    assertThat(txn.getState(), is(RELEASED));
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      assertThat(txn.getParent(), is(nullValue()));
+      assertThat(txn.getState(), is(READY));
+      assertThat(txn.isReadOnly(), is(true));
+      txn.checkReady();
+      txn.checkReadOnly();
+      txn.reset();
+      assertThat(txn.getState(), is(RESET));
+      txn.renew();
+      assertThat(txn.getState(), is(READY));
+      txn.commit();
+      assertThat(txn.getState(), is(DONE));
+      txn.close();
+      assertThat(txn.getState(), is(RELEASED));
+    }
   }
 
   @Test
@@ -286,31 +286,30 @@ public void txReadWrite() {
   }
 
   @Test(expected = NotResetException.class)
-  @SuppressWarnings("PMD.CloseResource")
   public void txRenewDeniedWithoutPriorReset() {
-    final Txn<ByteBuffer> txn = env.txnRead();
-    txn.renew();
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      txn.renew();
+    }
   }
 
   @Test(expected = ResetException.class)
-  @SuppressWarnings("PMD.CloseResource")
   public void txResetDeniedForAlreadyResetTransaction() {
-    final Txn<ByteBuffer> txn = env.txnRead();
-    txn.reset();
-    txn.renew();
-    txn.reset();
-    txn.reset();
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      txn.reset();
+      txn.renew();
+      txn.reset();
+      txn.reset();
+    }
   }
 
   @Test(expected = ReadOnlyRequiredException.class)
-  @SuppressWarnings("PMD.CloseResource")
   public void txResetDeniedForReadWriteTransaction() {
-    final Txn<ByteBuffer> txn = env.txnWrite();
-    txn.reset();
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      txn.reset();
+    }
   }
 
   @Test(expected = BadValueSizeException.class)
-  @SuppressWarnings("PMD.CloseResource")
   public void zeroByteKeysRejected() throws IOException {
     final Dbi<ByteBuffer> dbi = env.openDbi(DB_1, MDB_CREATE);
     final ByteBuffer key = allocateDirect(4);

From fd4b71205a32669bc92a34483cf24b7f79d3d991 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Wed, 15 Apr 2020 16:03:22 +1000
Subject: [PATCH 052/322] Include TutorialTest during CI

This reverts commit fed0c5df22ade16e05570f10d624bca5c64221bf.
---
 .github/workflows/maven.yml | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml
index a657e88d..b6899406 100644
--- a/.github/workflows/maven.yml
+++ b/.github/workflows/maven.yml
@@ -32,7 +32,7 @@ jobs:
         key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.xml') }}
 
     - name: Build with Maven
-      run: mvn -B -Dtest='!TutorialTest' verify
+      run: mvn -B verify
 
     - name: Upload code coverage to Codecov
       uses: codecov/codecov-action@v1
@@ -67,10 +67,7 @@ jobs:
           key: ${{ runner.os }}-${{ matrix.java }}-m2-${{ hashFiles('**/pom.xml') }}
 
       - name: Test with Maven
-        run: mvn -B -Dtest='!TutorialTest' test
-
-      - name: Test with Maven 2
-        run: mvn -B -Dtest='TutorialTest' test
+        run: mvn -B test
 
       - name: Upload Surefire reports on test failure
         uses: actions/upload-artifact@v1

From b9d27f588ca64106bafb9711627e558a4a06558f Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Wed, 15 Apr 2020 16:33:35 +1000
Subject: [PATCH 053/322] Update to LmdbJava native library 0.9.24-1 official
 release (closes #148)

---
 pom.xml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/pom.xml b/pom.xml
index 6b032ef0..21f73801 100644
--- a/pom.xml
+++ b/pom.xml
@@ -135,19 +135,19 @@
     <dependency>
       <groupId>org.lmdbjava</groupId>
       <artifactId>lmdbjava-native-linux-x86_64</artifactId>
-      <version>0.9.24-1-SNAPSHOT</version>
+      <version>0.9.24-1</version>
       <optional>true</optional>
     </dependency>
     <dependency>
       <groupId>org.lmdbjava</groupId>
       <artifactId>lmdbjava-native-windows-x86_64</artifactId>
-      <version>0.9.24-1-SNAPSHOT</version>
+      <version>0.9.24-1</version>
       <optional>true</optional>
     </dependency>
     <dependency>
       <groupId>org.lmdbjava</groupId>
       <artifactId>lmdbjava-native-osx-x86_64</artifactId>
-      <version>0.9.24-1-SNAPSHOT</version>
+      <version>0.9.24-1</version>
       <optional>true</optional>
     </dependency>
     <dependency>

From 77a21a6f6641832b907fcdea5e4c3da190468f74 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Wed, 15 Apr 2020 16:51:21 +1000
Subject: [PATCH 054/322] Maven OSSRH deployment should perform tests as per
 default

---
 .github/workflows/maven.yml | 1 -
 1 file changed, 1 deletion(-)

diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml
index b6899406..fe457844 100644
--- a/.github/workflows/maven.yml
+++ b/.github/workflows/maven.yml
@@ -109,4 +109,3 @@ jobs:
         gpg_passphrase: ${{ secrets.gpg_passphrase }}
         nexus_username: ${{ secrets.nexus_username }}
         nexus_password: ${{ secrets.nexus_password }}
-        maven_args: "-DskipTests"

From a1f73e210c9b07bb4837509b3d9feedec07f4edd Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Wed, 15 Apr 2020 17:01:40 +1000
Subject: [PATCH 055/322] Checkstyle and PMD variations following merging PR
 #146

---
 src/main/java/org/lmdbjava/Dbi.java | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index 9fbcef1c..b13098ec 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -24,10 +24,8 @@
 import java.util.Arrays;
 import java.util.Comparator;
 import java.util.List;
-
 import static java.util.Objects.requireNonNull;
 import static jnr.ffi.Memory.allocateDirect;
-
 import jnr.ffi.NativeType;
 import static jnr.ffi.NativeType.ADDRESS;
 import jnr.ffi.Pointer;
@@ -57,6 +55,7 @@
  *
  * @param <T> buffer type
  */
+@SuppressWarnings("PMD.GodClass")
 public final class Dbi<T> {
 
   private final ComparatorCallback ccb;

From 46e1781831a64a1f2d47a318f8060ab2e76fa538 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Wed, 15 Apr 2020 17:18:39 +1000
Subject: [PATCH 056/322] Change to IntByReference due to Windows CI failures
 (#146)

---
 src/main/java/org/lmdbjava/Dbi.java     | 8 ++++----
 src/main/java/org/lmdbjava/Library.java | 3 ++-
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index b13098ec..86db34b8 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -26,9 +26,9 @@
 import java.util.List;
 import static java.util.Objects.requireNonNull;
 import static jnr.ffi.Memory.allocateDirect;
-import jnr.ffi.NativeType;
 import static jnr.ffi.NativeType.ADDRESS;
 import jnr.ffi.Pointer;
+import jnr.ffi.byref.IntByReference;
 import jnr.ffi.byref.PointerByReference;
 import org.lmdbjava.CursorIterator.IteratorType;
 import static org.lmdbjava.CursorIterator.IteratorType.FORWARD;
@@ -500,15 +500,15 @@ public Stat stat(final Txn<T> txn) {
   * @return the list of flags this Dbi was created with
   */
   public List<DbiFlags> listFlags(final Txn<T> txn) {
-    final Pointer resultPtr = allocateDirect(RUNTIME, NativeType.UINT);
+    final IntByReference resultPtr = new IntByReference();
     checkRc(LIB.mdb_dbi_flags(txn.pointer(), ptr, resultPtr));
 
-    final int flags = resultPtr.getInt(0);
+    final int flags = resultPtr.intValue();
 
     final List<DbiFlags> result = new ArrayList<>();
 
     for (final DbiFlags flag : DbiFlags.values()) {
-      if (MaskedFlag.isSet(flags, flag)) {
+      if (isSet(flags, flag)) {
         result.add(flag);
       }
     }
diff --git a/src/main/java/org/lmdbjava/Library.java b/src/main/java/org/lmdbjava/Library.java
index 5834ca44..a458152d 100644
--- a/src/main/java/org/lmdbjava/Library.java
+++ b/src/main/java/org/lmdbjava/Library.java
@@ -222,7 +222,8 @@ int mdb_cursor_put(@In Pointer cursor, @In Pointer key, @In Pointer data,
 
     void mdb_dbi_close(@In Pointer env, @In Pointer dbi);
 
-    int mdb_dbi_flags(@In Pointer txn, @In Pointer dbi, @Out Pointer flags);
+    int mdb_dbi_flags(@In Pointer txn, @In Pointer dbi,
+                      @Out IntByReference flags);
 
     int mdb_dbi_open(@In Pointer txn, @In byte[] name, int flags,
                      @In Pointer dbiPtr);

From a781bb2ee9c5e588c8c687f404ce7761fb80fbbb Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Wed, 15 Apr 2020 17:39:44 +1000
Subject: [PATCH 057/322] Add test for PR #100

---
 src/test/java/org/lmdbjava/CursorTest.java | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/src/test/java/org/lmdbjava/CursorTest.java b/src/test/java/org/lmdbjava/CursorTest.java
index 40dd9f97..3f376bd6 100644
--- a/src/test/java/org/lmdbjava/CursorTest.java
+++ b/src/test/java/org/lmdbjava/CursorTest.java
@@ -48,6 +48,7 @@
 import static org.lmdbjava.PutFlags.MDB_NODUPDATA;
 import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
 import static org.lmdbjava.SeekOp.MDB_FIRST;
+import static org.lmdbjava.SeekOp.MDB_GET_BOTH;
 import static org.lmdbjava.TestUtils.DB_1;
 import static org.lmdbjava.TestUtils.POSIX_MODE;
 import static org.lmdbjava.TestUtils.bb;
@@ -172,6 +173,27 @@ public void delete() {
     }
   }
 
+  @Test
+  public void getKeyVal() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+    try (Txn<ByteBuffer> txn = env.txnWrite();
+         Cursor<ByteBuffer> c = db.openCursor(txn)) {
+      c.put(bb(1), bb(2), MDB_APPENDDUP);
+      c.put(bb(1), bb(4), MDB_APPENDDUP);
+      c.put(bb(1), bb(6), MDB_APPENDDUP);
+      c.put(bb(2), bb(1), MDB_APPENDDUP);
+      c.put(bb(2), bb(2), MDB_APPENDDUP);
+      c.put(bb(2), bb(3), MDB_APPENDDUP);
+      c.put(bb(2), bb(4), MDB_APPENDDUP);
+      assertThat(c.get(bb(1), bb(2), MDB_GET_BOTH), is(true));
+      assertThat(c.count(), is(3L));
+      assertThat(c.get(bb(1), bb(3), MDB_GET_BOTH), is(false));
+      assertThat(c.get(bb(2), bb(1), MDB_GET_BOTH), is(true));
+      assertThat(c.count(), is(4L));
+      assertThat(c.get(bb(2), bb(0), MDB_GET_BOTH), is(false));
+    }
+  }
+
   @Test
   public void putMultiple() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT,

From 11105ff40e2cf7047384af4402642ea4e7506503 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Sat, 18 Apr 2020 14:45:28 +1000
Subject: [PATCH 058/322] Update to Acegi Standard Project 0.4.0

---
 .github/workflows/maven.yml | 1 +
 pom.xml                     | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml
index fe457844..c8ef2d4a 100644
--- a/.github/workflows/maven.yml
+++ b/.github/workflows/maven.yml
@@ -109,3 +109,4 @@ jobs:
         gpg_passphrase: ${{ secrets.gpg_passphrase }}
         nexus_username: ${{ secrets.nexus_username }}
         nexus_password: ${{ secrets.nexus_password }}
+        maven_profiles: ossrh-deploy
diff --git a/pom.xml b/pom.xml
index 21f73801..8360a2aa 100644
--- a/pom.xml
+++ b/pom.xml
@@ -4,7 +4,7 @@
   <parent>
     <groupId>au.com.acegi</groupId>
     <artifactId>acegi-standard-project</artifactId>
-    <version>0.3.1</version>
+    <version>0.4.0</version>
   </parent>
   <groupId>org.lmdbjava</groupId>
   <artifactId>lmdbjava</artifactId>

From 344e4ae810be9492b375bf0ab9bc9f009ed38b5f Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 24 Apr 2020 10:21:13 +1000
Subject: [PATCH 059/322] Revert "Use explicit Netty JARs to mitigate
 dependency:go-offline failures"

This reverts commit 248878a53d3c6ba6f4f750d3997fa22d62df5714.

With the move to GitHub Actions we no longer use mvn
dependency:go-offline. As such the issue with the missing native
dependency should be avoided.
---
 pom.xml | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

diff --git a/pom.xml b/pom.xml
index 8360a2aa..0ae1f82c 100644
--- a/pom.xml
+++ b/pom.xml
@@ -110,13 +110,7 @@
     </dependency>
     <dependency>
       <groupId>io.netty</groupId>
-      <artifactId>netty-buffer</artifactId>
-      <version>4.1.48.Final</version>
-      <scope>test</scope>
-    </dependency>
-    <dependency>
-      <groupId>io.netty</groupId>
-      <artifactId>netty-common</artifactId>
+      <artifactId>netty-all</artifactId>
       <version>4.1.48.Final</version>
       <scope>test</scope>
     </dependency>
@@ -170,7 +164,6 @@
           </usedDependencies>
           <ignoredDependencies>
             <ignoredDependency>com.github.jnr:jffi</ignoredDependency>
-            <ignoredDependency>io.netty:netty-common</ignoredDependency>
           </ignoredDependencies>
         </configuration>
       </plugin>

From 07cf8b0c31e66ec8bb5463257cceea6ebc9394ca Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 24 Apr 2020 10:27:11 +1000
Subject: [PATCH 060/322] Update to JNR-FFI 2.1.13

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 0ae1f82c..090c7a50 100644
--- a/pom.xml
+++ b/pom.xml
@@ -72,7 +72,7 @@
     <dependency>
       <groupId>com.github.jnr</groupId>
       <artifactId>jnr-ffi</artifactId>
-      <version>2.1.12</version>
+      <version>2.1.13</version>
       <exclusions>
         <exclusion>
           <groupId>com.github.jnr</groupId>

From 4df55d5b66cddc2da40acf4ed91bfa7a8e42b431 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 24 Apr 2020 10:27:33 +1000
Subject: [PATCH 061/322] Update to Guava 29.0

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 090c7a50..ea238a32 100644
--- a/pom.xml
+++ b/pom.xml
@@ -117,7 +117,7 @@
     <dependency>
       <groupId>com.google.guava</groupId>
       <artifactId>guava</artifactId>
-      <version>28.2-jre</version>
+      <version>29.0-jre</version>
       <scope>test</scope>
       <exclusions>
         <exclusion>

From 4f70b02311f17bdea67650c9289e001f9f7284c7 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 24 Apr 2020 10:27:48 +1000
Subject: [PATCH 062/322] Update to Netty 4.1.49

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index ea238a32..dc2d405c 100644
--- a/pom.xml
+++ b/pom.xml
@@ -111,7 +111,7 @@
     <dependency>
       <groupId>io.netty</groupId>
       <artifactId>netty-all</artifactId>
-      <version>4.1.48.Final</version>
+      <version>4.1.49.Final</version>
       <scope>test</scope>
     </dependency>
     <dependency>

From 076229fa699c276536204c7396a70d283983113d Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 24 Apr 2020 10:44:58 +1000
Subject: [PATCH 063/322] Promote Netty support from test to main (resolves
 #152)

---
 pom.xml                                                | 2 +-
 src/{test => main}/java/org/lmdbjava/ByteBufProxy.java | 0
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename src/{test => main}/java/org/lmdbjava/ByteBufProxy.java (100%)

diff --git a/pom.xml b/pom.xml
index dc2d405c..6825e457 100644
--- a/pom.xml
+++ b/pom.xml
@@ -112,7 +112,7 @@
       <groupId>io.netty</groupId>
       <artifactId>netty-all</artifactId>
       <version>4.1.49.Final</version>
-      <scope>test</scope>
+      <optional>true</optional>
     </dependency>
     <dependency>
       <groupId>com.google.guava</groupId>
diff --git a/src/test/java/org/lmdbjava/ByteBufProxy.java b/src/main/java/org/lmdbjava/ByteBufProxy.java
similarity index 100%
rename from src/test/java/org/lmdbjava/ByteBufProxy.java
rename to src/main/java/org/lmdbjava/ByteBufProxy.java

From 1fb91944c2393cab0652874492290db4297cb98b Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 24 Apr 2020 11:01:35 +1000
Subject: [PATCH 064/322] Restructure readme to separately list documentation
 resources

---
 README.md | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/README.md b/README.md
index e2ee753b..4311c86e 100644
--- a/README.md
+++ b/README.md
@@ -29,15 +29,10 @@
 * Buffer agnostic (Java `ByteBuffer`, Agrona `DirectBuffer`, Netty `ByteBuf`, your own buffer)
 * 100% stock-standard, officially-released, widely-tested LMDB C code ([no extra](https://github.com/lmdbjava/native) C/JNI code)
 * Low latency design (allocation-free; buffer pools; optional checks can be easily disabled in production etc)
-* Automatically tested with Java 8 and Java 11
-* Easy to use (just work through our step-by-step, CI-tested, fully-executable [tutorial](https://github.com/lmdbjava/lmdbjava/tree/master/src/test/java/org/lmdbjava/TutorialTest.java))
-* Community questions and contributions are welcome through [GitHub tickets](https://github.com/lmdbjava/lmdbjava/issues)
 * Mature code (commenced in 2016) and used for heavy production workloads (eg > 500 TB of HFT data)
 * Actively maintained and with a "Zero Bug Policy" before every release (see [issues](https://github.com/lmdbjava/lmdbjava/issues))
 * Available from [Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22org.lmdbjava%22%20AND%20a%3A%22lmdbjava%22) and [OSS Sonatype Snapshots](https://oss.sonatype.org/content/repositories/snapshots/org/lmdbjava/lmdbjava)
-* Detailed [JavaDocs](http://www.javadoc.io/doc/org.lmdbjava/lmdbjava)
-* [Change Log](https://github.com/lmdbjava/lmdbjava/wiki/Change-Log) to assist with upgrades
-* [Continuous integration](https://github.com/lmdbjava/lmdbjava/actions) testing on Linux, Windows and macOS across Java versions 8, 11 and 14
+* [Continuous integration](https://github.com/lmdbjava/lmdbjava/actions) testing on Linux, Windows and macOS with Java 8, 11 and 14
 
 ### Performance
 
@@ -47,6 +42,13 @@
 
 Full details are in the [latest benchmark report](https://github.com/lmdbjava/benchmarks/blob/master/results/20160710/README.md).
 
+### Documentation
+
+* [Wiki](https://github.com/lmdbjava/lmdbjava/wiki/)
+* [Tutorial](https://github.com/lmdbjava/lmdbjava/tree/master/src/test/java/org/lmdbjava/TutorialTest.java)
+* [JavaDocs](http://www.javadoc.io/doc/org.lmdbjava/lmdbjava)
+* [Change Log](https://github.com/lmdbjava/lmdbjava/wiki/Change-Log)
+
 ### Support
 
 We're happy to help you use LmdbJava. Simply

From ac5671a03bb64f1938aa6d2ae844dba2c33f2c62 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 24 Apr 2020 15:39:03 +1000
Subject: [PATCH 065/322] CursorIterator.iterable() should only return once
 (fixes #153)

---
 src/main/java/org/lmdbjava/CursorIterator.java     | 12 +++++++++++-
 src/test/java/org/lmdbjava/CursorIteratorTest.java |  9 +++++++++
 2 files changed, 20 insertions(+), 1 deletion(-)

diff --git a/src/main/java/org/lmdbjava/CursorIterator.java b/src/main/java/org/lmdbjava/CursorIterator.java
index c184a55b..354f8587 100644
--- a/src/main/java/org/lmdbjava/CursorIterator.java
+++ b/src/main/java/org/lmdbjava/CursorIterator.java
@@ -53,6 +53,7 @@ public final class CursorIterator<T> implements
   private final Comparator<T> comparator;
   private final Cursor<T> cursor;
   private final KeyVal<T> entry;
+  private boolean iterableReturned;
   private final KeyRange<T> range;
   private State state = REQUIRES_INITIAL_OP;
 
@@ -79,11 +80,20 @@ public boolean hasNext() {
   }
 
   /**
-   * Obtain an iterator.
+   * Obtain an iterable.
+   *
+   * <p>
+   * As iteration of the returned iterable will cause movement of the underlying
+   * LMDB cursor, an {@link IllegalStateException} is thrown if an attempt is
+   * made to obtain the iterator more than once.
    *
    * @return an iterator
    */
   public Iterable<KeyVal<T>> iterable() {
+    if (iterableReturned) {
+      throw new IllegalStateException("Iterable can only be returned once");
+    }
+    iterableReturned = true;
     return () -> CursorIterator.this;
   }
 
diff --git a/src/test/java/org/lmdbjava/CursorIteratorTest.java b/src/test/java/org/lmdbjava/CursorIteratorTest.java
index ae20e57a..04564004 100644
--- a/src/test/java/org/lmdbjava/CursorIteratorTest.java
+++ b/src/test/java/org/lmdbjava/CursorIteratorTest.java
@@ -235,6 +235,15 @@ public void greaterThanTest() {
     verify(greaterThan(bb(3)), 4, 6, 8);
   }
 
+  @Test(expected = IllegalStateException.class)
+  public void iterableOnlyReturnedOnce() {
+    try (Txn<ByteBuffer> txn = env.txnRead();
+         CursorIterator<ByteBuffer> c = db.iterate(txn)) {
+      c.iterable(); // ok
+      c.iterable(); // fails
+    }
+  }
+
   @Test
   public void iterate() {
     try (Txn<ByteBuffer> txn = env.txnRead();

From f03a6f962cd039fc018e2683ccc98af1877d0418 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 27 Apr 2020 10:31:50 +1000
Subject: [PATCH 066/322] Format documentation and add links (#141)

---
 src/main/java/org/lmdbjava/EnvFlags.java | 184 ++++++++++++-----------
 1 file changed, 96 insertions(+), 88 deletions(-)

diff --git a/src/main/java/org/lmdbjava/EnvFlags.java b/src/main/java/org/lmdbjava/EnvFlags.java
index 4c3d0a05..5a58c996 100644
--- a/src/main/java/org/lmdbjava/EnvFlags.java
+++ b/src/main/java/org/lmdbjava/EnvFlags.java
@@ -25,137 +25,145 @@
  */
 public enum EnvFlags implements MaskedFlag {
 
-  /**
-   * http://www.lmdb.tech/doc/group__mdb.html#ga32a193c6bf4d7d5c5d579e71f22e9340
-   */
-
   /**
    * Mmap at a fixed address (experimental).
-   * MDB_FIXEDMAP : Use a fixed address for the mmap region. This flag must be
-   * specified when creating the environment, and is stored persistently in the
-   * environment. If successful, the memory map will always reside at the same
-   * virtual address and pointers used to reference data items in the database will
-   * be constant across multiple invocations. This option may not always work,
-   * depending on how the operating system has allocated memory to shared
-   * libraries and other uses. The feature is highly experimental.
+   *
+   * <p>
+   * Use a fixed address for the mmap region. This flag must be specified when
+   * creating the environment, and is stored persistently in the environment. If
+   * successful, the memory map will always reside at the same virtual address
+   * and pointers used to reference data items in the database will be constant
+   * across multiple invocations. This option may not always work, depending on
+   * how the operating system has allocated memory to shared libraries and other
+   * uses. The feature is highly experimental.
    */
   MDB_FIXEDMAP(0x01),
-
   /**
    * No environment directory.
-   * MDB_NOSUBDIR : By default, LMDB creates its environment in a directory whose pathname is
+   *
+   * <p>
+   * By default, LMDB creates its environment in a directory whose pathname is
    * given in path, and creates its data and lock files under that directory.
    * With this option, path is used as-is for the database main data file. The
    * database lock file is the path with "-lock" appended.
    */
   MDB_NOSUBDIR(0x4000),
-
   /**
-   * MDB_RDONLY : Open the environment in read-only mode. No write operations will
-   * be allowed. LMDB will still modify the lock file - except on read-only
-   * filesystems, where LMDB does not use locks.
+   * Open the environment in read-only mode.
+   *
+   * <p>
+   * No write operations will be allowed. LMDB will still modify the lock file -
+   * except on read-only filesystems, where LMDB does not use locks.
    */
   MDB_RDONLY_ENV(0x2_0000),
-
   /**
-   * MDB_WRITEMAP : Use a writeable memory map unless MDB_RDONLY is set. This is
-   * faster and uses fewer mallocs, but loses protection from application bugs
-   * like wild pointer writes and other bad updates into the database.
-   * Incompatible with nested transactions. Do not mix processes with and without
-   * MDB_WRITEMAP on the same environment. This can defeat durability (mdb_env_sync etc).
+   * Use a writeable memory map unless {@link #MDB_RDONLY} is set.
+   *
+   * <p>
+   * This is faster and uses fewer mallocs, but loses protection from
+   * application bugs like wild pointer writes and other bad updates into the
+   * database. Incompatible with nested transactions. Do not mix processes with
+   * and without {@link #MDB_WRITEMAP} on the same environment. This can defeat
+   * durability ({@link Env#sync(boolean)} etc).
    */
   MDB_WRITEMAP(0x8_0000),
-
   /**
    * Don't fsync metapage after commit.
-   * MDB_NOMETASYNC : Flush system buffers to disk only once per transaction, omit the
-   * metadata flush. Defer that until the system flushes files to disk, or next non-MDB_RDONLY
-   * commit or mdb_env_sync(). This optimization maintains database integrity, but a system
-   * crash may undo the last committed transaction. I.e. it preserves the ACI (atomicity,
-   * consistency, isolation) but not D (durability) database property. This flag may be
-   * changed at any time using mdb_env_set_flags().
+   *
+   * <p>
+   * Flush system buffers to disk only once per transaction, omit the metadata
+   * flush. Defer that until the system flushes files to disk, or next
+   * non-{@link #MDB_RDONLY} commit or {@link Env#sync(boolean)}. This
+   * optimization* maintains database integrity, but a system crash may undo the
+   * last* committed transaction. I.e. it preserves the ACI (atomicity,
+   * consistency, isolation) but not D (durability) database property.
    */
   MDB_NOMETASYNC(0x4_0000),
-
   /**
    * Don't fsync after commit.
-   * MDB_NOSYNC : Don't flush system buffers to disk when committing a transaction.
-   * This optimization means a system crash can corrupt the database or lose the last
-   * transactions if buffers are not yet flushed to disk. The risk is governed by how
-   * often the system flushes dirty buffers to disk and how often mdb_env_sync() is called.
-   * However, if the filesystem preserves write order and the MDB_WRITEMAP flag is not used,
-   * transactions exhibit ACI (atomicity, consistency, isolation) properties and only lose D
-   * (durability). I.e. database integrity is maintained, but a system crash may undo the
-   * final transactions. Note that (MDB_NOSYNC | MDB_WRITEMAP) leaves the system with no hint
-   * for when to write transactions to disk, unless mdb_env_sync() is called.
-   * (MDB_MAPASYNC | MDB_WRITEMAP) may be preferable. This flag may be changed at any time
-   * using mdb_env_set_flags().
+   *
+   * <p>
+   * Don't flush system buffers to disk when committing a transaction. This
+   * optimization means a system crash can corrupt the database or lose the last
+   * transactions if buffers are not yet flushed to disk. The risk is governed
+   * by how often the system flushes dirty buffers to disk and how often
+   * {@link Env#sync(boolean)} is called. However, if the filesystem preserves
+   * write order and the {@link #MDB_WRITEMAP} flag is not used, transactions
+   * exhibit ACI (atomicity, consistency, isolation) properties and only lose D
+   * (durability). I.e. database integrity is maintained, but a system crash may
+   * undo the final transactions. Note that
+   * ({@link #MDB_NOSYNC} | {@link #MDB_WRITEMAP}) leaves the system with no
+   * hint for when to write transactions to disk, unless
+   * {@link Env#sync(boolean)} is called.
+   * ({@link #MDB_MAPASYNC} | {@link #MDB_WRITEMAP}) may be preferable.
    */
   MDB_NOSYNC(0x1_0000),
-
   /**
    * Use asynchronous msync when {@link #MDB_WRITEMAP} is used.
-   * MDB_MAPASYNC : When using MDB_WRITEMAP, use asynchronous flushes to disk.
-   * As with MDB_NOSYNC, a system crash can then corrupt the database or lose the
-   * last transactions. Calling mdb_env_sync() ensures on-disk database integrity
-   * until next commit. This flag may be changed at any time using mdb_env_set_flags().
+   *
+   * <p>
+   * When using {@link #MDB_WRITEMAP}, use asynchronous flushes to disk.
+   * As with {@link #MDB_NOSYNC}, a system crash can then corrupt the database
+   * or lose the last transactions. Calling {@link Env#sync(boolean)} ensures
+   * on-disk database integrity until next commit.
    */
   MDB_MAPASYNC(0x10_0000),
-
   /**
    * Tie reader locktable slots to {@link Txn} objects instead of to threads.
-   * MDB_NOTLS : Don't use Thread-Local Storage. Tie reader locktable slots to
-   * MDB_txn objects instead of to threads. I.e. mdb_txn_reset() keeps the slot
-   * reseved for the MDB_txn object. A thread may use parallel read-only transactions.
-   * A read-only transaction may span threads if the user synchronizes its use.
-   * Applications that multiplex many user threads over individual OS threads
-   * need this option. Such an application must also serialize the write
-   * transactions in an OS thread, since LMDB's write locking is unaware
-   * of the user threads.
+   *
+   * <p>
+   * Don't use Thread-Local Storage. Tie reader locktable slots to {@link Txn}
+   * objects instead of to threads. I.e. {@link Txn#reset()} keeps the slot
+   * reseved for the {@link Txn} object. A thread may use parallel read-only
+   * transactions. A read-only transaction may span threads if the user
+   * synchronizes its use. Applications that multiplex many user threads over
+   * individual OS threads need this option. Such an application must also
+   * serialize the write transactions in an OS thread, since LMDB's write
+   * locking is unaware of the user threads.
    */
   MDB_NOTLS(0x20_0000),
-
   /**
    * Don't do any locking, caller must manage their own locks.
-   * MDB_NOLOCK : Don't do any locking. If concurrent access is anticipated,
-   * the caller must manage all concurrency itself. For proper operation
-   * the caller must enforce single-writer semantics, and must ensure
-   * that no readers are using old transactions while a writer is active.
-   * The simplest approach is to use an exclusive lock so that no readers
-   * may be active at all when a writer begins.
+   *
+   * <p>
+   * Don't do any locking. If concurrent access is anticipated, the caller must
+   * manage all concurrency itself. For proper operation the caller must enforce
+   * single-writer semantics, and must ensure that no readers are using old
+   * transactions while a writer is active. The simplest approach is to use an
+   * exclusive lock so that no readers may be active at all when a writer
+   * begins.
    */
   MDB_NOLOCK(0x40_0000),
-
   /**
    * Don't do readahead (no effect on Windows).
-   * MDB_NORDAHEAD : Turn off readahead. Most operating systems perform
-   * readahead on read requests by default. This option turns it off if
-   * the OS supports it. Turning it off may help random read performance
-   * when the DB is larger than RAM and system RAM is full. The option
-   * is not implemented on Windows.
+   *
+   * <p>
+   * Turn off readahead. Most operating systems perform readahead on read
+   * requests by default. This option turns it off if the OS supports it.
+   * Turning it off may help random read performance when the DB is larger than
+   * RAM and system RAM is full. The option is not implemented on Windows.
    */
   MDB_NORDAHEAD(0x80_0000),
-
   /**
    * Don't initialize malloc'd memory before writing to datafile.
-   * MDB_NOMEMINIT : Don't initialize malloc'd memory before writing to
-   * unused spaces in the data file. By default, memory for pages written
-   * to the data file is obtained using malloc. While these pages may be
-   * reused in subsequent transactions, freshly malloc'd pages will be
-   * initialized to zeroes before use. This avoids persisting leftover
-   * data from other code (that used the heap and subsequently freed
-   * the memory) into the data file. Note that many other system
-   * libraries may allocate and free memory from the heap for
-   * arbitrary uses. E.g., stdio may use the heap for file I/O buffers.
-   * This initialization step has a modest performance cost so some
-   * applications may want to disable it using this flag. This option
-   * can be a problem for applications which handle sensitive data
-   * like passwords, and it makes memory checkers like Valgrind noisy.
-   * This flag is not needed with MDB_WRITEMAP, which writes directly
-   * to the mmap instead of using malloc for pages. The initialization
-   * is also skipped if MDB_RESERVE is used; the caller is expected to
-   * overwrite all of the memory that was reserved in that case. This
-   * flag may be changed at any time using mdb_env_set_flags().
+   *
+   * <p>
+   * Don't initialize malloc'd memory before writing to unused spaces in the
+   * data file. By default, memory for pages written to the data file is
+   * obtained using malloc. While these pages may be reused in subsequent
+   * transactions, freshly malloc'd pages will be initialized to zeroes before
+   * use. This avoids persisting leftover data from other code (that used the
+   * heap and subsequently freed the memory) into the data file. Note that many
+   * other system libraries may allocate and free memory from the heap for
+   * arbitrary uses. E.g., stdio may use the heap for file I/O buffers. This
+   * initialization step has a modest performance cost so some applications may
+   * want to disable it using this flag. This option can be a problem for
+   * applications which handle sensitive data like passwords, and it makes
+   * memory checkers like Valgrind noisy. This flag is not needed with
+   * {@link #MDB_WRITEMAP}, which writes directly to the mmap instead of using
+   * malloc for pages. The initialization is also skipped if
+   * {@link PutFlags#MDB_RESERVE} is used; the caller is expected to overwrite
+   * all of the memory that was reserved in that case.
    */
   MDB_NOMEMINIT(0x100_0000);
 

From 981f7ecd82fa2f5900456e417d12919c692c0c63 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 27 Apr 2020 10:32:56 +1000
Subject: [PATCH 067/322] Formatting only

---
 src/main/java/org/lmdbjava/Cursor.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/main/java/org/lmdbjava/Cursor.java b/src/main/java/org/lmdbjava/Cursor.java
index 1bbd8a49..2ae2140d 100644
--- a/src/main/java/org/lmdbjava/Cursor.java
+++ b/src/main/java/org/lmdbjava/Cursor.java
@@ -128,9 +128,9 @@ public boolean first() {
   /**
    * Reposition the key/value buffers based on the passed key and operation.
    *
-   * @param key to search for
+   * @param key  to search for
    * @param data to search for
-   * @param op  options for this operation
+   * @param op   options for this operation
    * @return false if key not found
    */
   public boolean get(final T key, final T data, final SeekOp op) {

From b3aa6bbaa79622ae49a84c07e7a9f97e413ba530 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 27 Apr 2020 11:53:32 +1000
Subject: [PATCH 068/322] Import order

---
 src/main/java/org/lmdbjava/CursorIterator.java | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/main/java/org/lmdbjava/CursorIterator.java b/src/main/java/org/lmdbjava/CursorIterator.java
index 354f8587..96a570b2 100644
--- a/src/main/java/org/lmdbjava/CursorIterator.java
+++ b/src/main/java/org/lmdbjava/CursorIterator.java
@@ -23,11 +23,11 @@
 import java.util.Comparator;
 import java.util.Iterator;
 import java.util.NoSuchElementException;
-import static org.lmdbjava.CursorIterator.State.RELEASED;
-import static org.lmdbjava.CursorIterator.State.REQUIRES_INITIAL_OP;
-import static org.lmdbjava.CursorIterator.State.REQUIRES_ITERATOR_OP;
-import static org.lmdbjava.CursorIterator.State.REQUIRES_NEXT_OP;
-import static org.lmdbjava.CursorIterator.State.TERMINATED;
+import static org.lmdbjava.CursorIterable.State.RELEASED;
+import static org.lmdbjava.CursorIterable.State.REQUIRES_INITIAL_OP;
+import static org.lmdbjava.CursorIterable.State.REQUIRES_ITERATOR_OP;
+import static org.lmdbjava.CursorIterable.State.REQUIRES_NEXT_OP;
+import static org.lmdbjava.CursorIterable.State.TERMINATED;
 import static org.lmdbjava.GetOp.MDB_SET_RANGE;
 import org.lmdbjava.KeyRangeType.CursorOp;
 import org.lmdbjava.KeyRangeType.IteratorOp;

From c9161e1edf4ca63d093ae1ff870a31948ef678fa Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 27 Apr 2020 11:56:21 +1000
Subject: [PATCH 069/322] Automatic formatting only

---
 src/main/java/org/lmdbjava/Dbi.java     | 46 ++++++++++++-------------
 src/test/java/org/lmdbjava/DbiTest.java | 20 ++++++-----
 2 files changed, 34 insertions(+), 32 deletions(-)

diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index 86db34b8..5e62c235 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -354,6 +354,29 @@ public CursorIterator<T> iterate(final Txn<T> txn, final KeyRange<T> range,
     return new CursorIterator<>(txn, this, range, useComp);
   }
 
+  /*
+  * Return DbiFlags for this Dbi.
+  *
+  * @param txn transaction handle (not null; not committed)
+  * @return the list of flags this Dbi was created with
+   */
+  public List<DbiFlags> listFlags(final Txn<T> txn) {
+    final IntByReference resultPtr = new IntByReference();
+    checkRc(LIB.mdb_dbi_flags(txn.pointer(), ptr, resultPtr));
+
+    final int flags = resultPtr.intValue();
+
+    final List<DbiFlags> result = new ArrayList<>();
+
+    for (final DbiFlags flag : DbiFlags.values()) {
+      if (isSet(flags, flag)) {
+        result.add(flag);
+      }
+    }
+
+    return result;
+  }
+
   /**
    * Create a cursor handle.
    *
@@ -493,29 +516,6 @@ public Stat stat(final Txn<T> txn) {
         stat.f5_ms_entries.longValue());
   }
 
-  /*
-  * Return DbiFlags for this Dbi.
-  *
-  * @param txn transaction handle (not null; not committed)
-  * @return the list of flags this Dbi was created with
-  */
-  public List<DbiFlags> listFlags(final Txn<T> txn) {
-    final IntByReference resultPtr = new IntByReference();
-    checkRc(LIB.mdb_dbi_flags(txn.pointer(), ptr, resultPtr));
-
-    final int flags = resultPtr.intValue();
-
-    final List<DbiFlags> result = new ArrayList<>();
-
-    for (final DbiFlags flag : DbiFlags.values()) {
-      if (isSet(flags, flag)) {
-        result.add(flag);
-      }
-    }
-
-    return result;
-  }
-
   private void clean() {
     if (cleaned) {
       return;
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 1e842d0f..a5bf4bab 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -263,6 +263,17 @@ public void getNamesWhenEmpty() {
     assertThat(dbiNames, empty());
   }
 
+  @Test
+  public void listsFlags() {
+    final Dbi<ByteBuffer> dbi = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT,
+                                            MDB_REVERSEKEY);
+
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      final List<DbiFlags> flags = dbi.listFlags(txn);
+      assertThat(flags, containsInAnyOrder(MDB_DUPSORT, MDB_REVERSEKEY));
+    }
+  }
+
   @Test
   public void putAbortGet() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
@@ -478,13 +489,4 @@ public void testParallelWritesStress() {
         });
   }
 
-  @Test
-  public void listsFlags() {
-    final Dbi<ByteBuffer> dbi = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT, MDB_REVERSEKEY);
-
-    try (Txn<ByteBuffer> txn = env.txnRead()) {
-      final List<DbiFlags> flags = dbi.listFlags(txn);
-      assertThat(flags, containsInAnyOrder(MDB_DUPSORT, MDB_REVERSEKEY));
-    }
-  }
 }

From d8224e7ac4d32c4d9382b01cb804ce63d768e4ee Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 27 Apr 2020 12:18:53 +1000
Subject: [PATCH 070/322] Literal formatting only

---
 src/main/java/org/lmdbjava/Verifier.java | 4 ++--
 src/test/java/org/lmdbjava/DbiTest.java  | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/main/java/org/lmdbjava/Verifier.java b/src/main/java/org/lmdbjava/Verifier.java
index 38a0b531..04b7a72c 100644
--- a/src/main/java/org/lmdbjava/Verifier.java
+++ b/src/main/java/org/lmdbjava/Verifier.java
@@ -82,7 +82,7 @@ public final class Verifier implements Callable<Long> {
    */
   public static final int DBI_COUNT = 5;
   private static final int BATCH_SIZE = 64;
-  private static final int BUFFER_LEN = 1024 * BATCH_SIZE;
+  private static final int BUFFER_LEN = 1_024 * BATCH_SIZE;
   private static final int CRC_LENGTH = Long.BYTES;
   private static final int KEY_LENGTH = Long.BYTES;
   private final byte[] ba = new byte[BUFFER_LEN];
@@ -269,7 +269,7 @@ private void updateValue(final long forId) {
 
   private int valueSize(final long forId) {
     final int mod = (int) (forId % BATCH_SIZE);
-    final int base = 1024 * mod;
+    final int base = 1_024 * mod;
     final int value = base == 0 ? 512 : base;
     return value - CRC_LENGTH - KEY_LENGTH; // aim to minimise partial pages
   }
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index a5bf4bab..e4c9eecd 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -147,7 +147,7 @@ public void dbiWithComparatorThreadSafety() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, PROXY_OPTIMAL::compare,
                                            MDB_CREATE);
 
-    final List<Integer> keys = range(0, 1000).boxed().collect(toList());
+    final List<Integer> keys = range(0, 1_000).boxed().collect(toList());
 
     final ExecutorService pool = Executors.newCachedThreadPool();
     final AtomicBoolean proceed = new AtomicBoolean(true);

From a590f9ad5517b800a68cf22052d3e74c77d69808 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 27 Apr 2020 12:32:58 +1000
Subject: [PATCH 071/322] Refactor CursorIterator (#154)

Refactor CursorIterator (#154)
---
 ...ursorIterator.java => CursorIterable.java} | 71 ++++++++++---------
 src/main/java/org/lmdbjava/Dbi.java           | 16 ++---
 .../java/org/lmdbjava/CursorIteratorTest.java | 63 +++++++++-------
 src/test/java/org/lmdbjava/DbiTest.java       |  9 ++-
 src/test/java/org/lmdbjava/TutorialTest.java  | 18 ++---
 src/test/java/org/lmdbjava/TxnTest.java       |  4 +-
 6 files changed, 100 insertions(+), 81 deletions(-)
 rename src/main/java/org/lmdbjava/{CursorIterator.java => CursorIterable.java} (79%)

diff --git a/src/main/java/org/lmdbjava/CursorIterator.java b/src/main/java/org/lmdbjava/CursorIterable.java
similarity index 79%
rename from src/main/java/org/lmdbjava/CursorIterator.java
rename to src/main/java/org/lmdbjava/CursorIterable.java
index 96a570b2..3020b746 100644
--- a/src/main/java/org/lmdbjava/CursorIterator.java
+++ b/src/main/java/org/lmdbjava/CursorIterable.java
@@ -33,8 +33,8 @@
 import org.lmdbjava.KeyRangeType.IteratorOp;
 
 /**
- * {@link Iterator} that iterates over a {@link Cursor} as specified by a
- * {@link KeyRange}.
+ * {@link Iterable} that creates a single {@link Iterator} that will iterate
+ * over a {@link Cursor}as specified by a {@link KeyRange}.
  *
  * <p>
  * An instance will create and close its own cursor.
@@ -47,8 +47,8 @@
  *
  * @param <T> buffer type
  */
-public final class CursorIterator<T> implements
-    Iterator<CursorIterator.KeyVal<T>>, AutoCloseable {
+public final class CursorIterable<T> implements
+    Iterable<CursorIterable.KeyVal<T>>, AutoCloseable {
 
   private final Comparator<T> comparator;
   private final Cursor<T> cursor;
@@ -57,7 +57,7 @@ public final class CursorIterator<T> implements
   private final KeyRange<T> range;
   private State state = REQUIRES_INITIAL_OP;
 
-  CursorIterator(final Txn<T> txn, final Dbi<T> dbi, final KeyRange<T> range,
+  CursorIterable(final Txn<T> txn, final Dbi<T> dbi, final KeyRange<T> range,
                  final Comparator<T> comparator) {
     this.cursor = dbi.openCursor(txn);
     this.range = range;
@@ -70,45 +70,50 @@ public void close() {
     cursor.close();
   }
 
-  @Override
-  @SuppressWarnings("checkstyle:returncount")
-  public boolean hasNext() {
-    while (state != RELEASED && state != TERMINATED) {
-      update();
-    }
-    return state == RELEASED;
-  }
-
   /**
-   * Obtain an iterable.
+   * Obtain an iterator.
    *
    * <p>
-   * As iteration of the returned iterable will cause movement of the underlying
+   * As iteration of the returned iterator will cause movement of the underlying
    * LMDB cursor, an {@link IllegalStateException} is thrown if an attempt is
-   * made to obtain the iterator more than once.
+   * made to obtain the iterator more than once. For advanced cursor control
+   * (such as being able to iterate over the same data multiple times etc)
+   * please instead refer to {@link Dbi#openCursor(org.lmdbjava.Txn)}.
    *
    * @return an iterator
    */
-  public Iterable<KeyVal<T>> iterable() {
+  @Override
+  @SuppressWarnings("checkstyle:AnonInnerLength")
+  public Iterator<KeyVal<T>> iterator() {
     if (iterableReturned) {
       throw new IllegalStateException("Iterable can only be returned once");
     }
     iterableReturned = true;
-    return () -> CursorIterator.this;
-  }
 
-  @Override
-  public KeyVal<T> next() {
-    if (!hasNext()) {
-      throw new NoSuchElementException();
-    }
-    state = REQUIRES_NEXT_OP;
-    return entry;
-  }
+    return new Iterator<KeyVal<T>>() {
+      @Override
+      @SuppressWarnings("checkstyle:returncount")
+      public boolean hasNext() {
+        while (state != RELEASED && state != TERMINATED) {
+          update();
+        }
+        return state == RELEASED;
+      }
 
-  @Override
-  public void remove() {
-    cursor.delete();
+      @Override
+      public KeyVal<T> next() {
+        if (!hasNext()) {
+          throw new NoSuchElementException();
+        }
+        state = REQUIRES_NEXT_OP;
+        return entry;
+      }
+
+      @Override
+      public void remove() {
+        cursor.delete();
+      }
+    };
   }
 
   @SuppressWarnings({"PMD.CyclomaticComplexity", "PMD.NullAssignment"})
@@ -224,9 +229,9 @@ void setV(final T val) {
   }
 
   /**
-   * Direction in terms of key ordering for CursorIterator.
+   * Represents the internal {@link CursorIterable} state.
    *
-   * @deprecated use {@link KeyRange} instead
+   * @deprecated use {@link Dbi} iterate method with a {@link KeyRange} instead
    */
   @Deprecated
   public enum IteratorType {
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index 5e62c235..205de84d 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -30,8 +30,8 @@
 import jnr.ffi.Pointer;
 import jnr.ffi.byref.IntByReference;
 import jnr.ffi.byref.PointerByReference;
-import org.lmdbjava.CursorIterator.IteratorType;
-import static org.lmdbjava.CursorIterator.IteratorType.FORWARD;
+import org.lmdbjava.CursorIterable.IteratorType;
+import static org.lmdbjava.CursorIterable.IteratorType.FORWARD;
 import static org.lmdbjava.Dbi.KeyExistsException.MDB_KEYEXIST;
 import static org.lmdbjava.Dbi.KeyNotFoundException.MDB_NOTFOUND;
 import static org.lmdbjava.Env.SHOULD_CHECK;
@@ -259,7 +259,7 @@ public byte[] getName() {
    * @param txn transaction handle (not null; not committed)
    * @return iterator
    */
-  public CursorIterator<T> iterate(final Txn<T> txn) {
+  public CursorIterable<T> iterate(final Txn<T> txn) {
     return iterate(txn, all());
   }
 
@@ -272,7 +272,7 @@ public CursorIterator<T> iterate(final Txn<T> txn) {
    * @deprecated use iterate method with a {@link KeyRange} instead
    */
   @Deprecated
-  public CursorIterator<T> iterate(final Txn<T> txn, final IteratorType type) {
+  public CursorIterable<T> iterate(final Txn<T> txn, final IteratorType type) {
     if (SHOULD_CHECK) {
       requireNonNull(type);
     }
@@ -291,7 +291,7 @@ public CursorIterator<T> iterate(final Txn<T> txn, final IteratorType type) {
    * @deprecated use iterate method with a {@link KeyRange} instead
    */
   @Deprecated
-  public CursorIterator<T> iterate(final Txn<T> txn, final T key,
+  public CursorIterable<T> iterate(final Txn<T> txn, final T key,
                                    final IteratorType type) {
     if (SHOULD_CHECK) {
       requireNonNull(type);
@@ -315,7 +315,7 @@ public CursorIterator<T> iterate(final Txn<T> txn, final T key,
    * @param range range of acceptable keys (not null)
    * @return iterator (never null)
    */
-  public CursorIterator<T> iterate(final Txn<T> txn, final KeyRange<T> range) {
+  public CursorIterable<T> iterate(final Txn<T> txn, final KeyRange<T> range) {
     return iterate(txn, range, null);
   }
 
@@ -338,7 +338,7 @@ public CursorIterator<T> iterate(final Txn<T> txn, final KeyRange<T> range) {
    * @param comparator custom comparator for keys (may be null)
    * @return iterator (never null)
    */
-  public CursorIterator<T> iterate(final Txn<T> txn, final KeyRange<T> range,
+  public CursorIterable<T> iterate(final Txn<T> txn, final KeyRange<T> range,
                                    final Comparator<T> comparator) {
     if (SHOULD_CHECK) {
       requireNonNull(txn);
@@ -351,7 +351,7 @@ public CursorIterator<T> iterate(final Txn<T> txn, final KeyRange<T> range,
     } else {
       useComp = comparator;
     }
-    return new CursorIterator<>(txn, this, range, useComp);
+    return new CursorIterable<>(txn, this, range, useComp);
   }
 
   /*
diff --git a/src/test/java/org/lmdbjava/CursorIteratorTest.java b/src/test/java/org/lmdbjava/CursorIteratorTest.java
index 04564004..f6b1411a 100644
--- a/src/test/java/org/lmdbjava/CursorIteratorTest.java
+++ b/src/test/java/org/lmdbjava/CursorIteratorTest.java
@@ -29,6 +29,7 @@
 import static java.util.Arrays.asList;
 import java.util.Comparator;
 import java.util.Deque;
+import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.NoSuchElementException;
@@ -40,9 +41,9 @@
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
-import static org.lmdbjava.CursorIterator.IteratorType.BACKWARD;
-import static org.lmdbjava.CursorIterator.IteratorType.FORWARD;
-import org.lmdbjava.CursorIterator.KeyVal;
+import static org.lmdbjava.CursorIterable.IteratorType.BACKWARD;
+import static org.lmdbjava.CursorIterable.IteratorType.FORWARD;
+import org.lmdbjava.CursorIterable.KeyVal;
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
 import static org.lmdbjava.Env.create;
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
@@ -70,7 +71,7 @@
 import static org.lmdbjava.TestUtils.bb;
 
 /**
- * Test {@link CursorIterator}.
+ * Test {@link CursorIterable}.
  */
 public final class CursorIteratorTest {
 
@@ -123,11 +124,10 @@ public void atMostTest() {
   @Test
   public void backwardDeprecated() {
     try (Txn<ByteBuffer> txn = env.txnRead();
-         CursorIterator<ByteBuffer> c = db.iterate(txn, BACKWARD)) {
-      for (final KeyVal<ByteBuffer> kv : c.iterable()) {
+         CursorIterable<ByteBuffer> c = db.iterate(txn, BACKWARD)) {
+      for (final KeyVal<ByteBuffer> kv : c) {
         assertThat(kv.val().getInt(), is(list.pollLast()));
         assertThat(kv.key().getInt(), is(list.pollLast()));
-        assertThat(c.hasNext(), is(list.peekFirst() != null));
       }
     }
   }
@@ -138,8 +138,8 @@ public void backwardSeekDeprecated() {
     list.pollLast();
     list.pollLast();
     try (Txn<ByteBuffer> txn = env.txnRead();
-         CursorIterator<ByteBuffer> c = db.iterate(txn, key, BACKWARD)) {
-      for (final KeyVal<ByteBuffer> kv : c.iterable()) {
+         CursorIterable<ByteBuffer> c = db.iterate(txn, key, BACKWARD)) {
+      for (final KeyVal<ByteBuffer> kv : c) {
         assertThat(kv.val().getInt(), is(list.pollLast()));
         assertThat(kv.key().getInt(), is(list.pollLast()));
       }
@@ -198,11 +198,10 @@ public void closedTest() {
   @Test
   public void forwardDeprecated() {
     try (Txn<ByteBuffer> txn = env.txnRead();
-         CursorIterator<ByteBuffer> c = db.iterate(txn, FORWARD)) {
-      for (final KeyVal<ByteBuffer> kv : c.iterable()) {
+         CursorIterable<ByteBuffer> c = db.iterate(txn, FORWARD)) {
+      for (final KeyVal<ByteBuffer> kv : c) {
         assertThat(kv.key().getInt(), is(list.pollFirst()));
         assertThat(kv.val().getInt(), is(list.pollFirst()));
-        assertThat(c.hasNext(), is(list.peekFirst() != null));
       }
     }
   }
@@ -214,8 +213,8 @@ public void forwardSeekDeprecated() {
     list.pollFirst();
 
     try (Txn<ByteBuffer> txn = env.txnRead();
-         CursorIterator<ByteBuffer> c = db.iterate(txn, key, FORWARD)) {
-      for (final KeyVal<ByteBuffer> kv : c.iterable()) {
+         CursorIterable<ByteBuffer> c = db.iterate(txn, key, FORWARD)) {
+      for (final KeyVal<ByteBuffer> kv : c) {
         assertThat(kv.key().getInt(), is(list.pollFirst()));
         assertThat(kv.val().getInt(), is(list.pollFirst()));
       }
@@ -238,23 +237,32 @@ public void greaterThanTest() {
   @Test(expected = IllegalStateException.class)
   public void iterableOnlyReturnedOnce() {
     try (Txn<ByteBuffer> txn = env.txnRead();
-         CursorIterator<ByteBuffer> c = db.iterate(txn)) {
-      c.iterable(); // ok
-      c.iterable(); // fails
+         CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+      c.iterator(); // ok
+      c.iterator(); // fails
     }
   }
 
   @Test
   public void iterate() {
     try (Txn<ByteBuffer> txn = env.txnRead();
-         CursorIterator<ByteBuffer> c = db.iterate(txn)) {
-      for (final KeyVal<ByteBuffer> kv : c.iterable()) {
+         CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+      for (final KeyVal<ByteBuffer> kv : c) {
         assertThat(kv.key().getInt(), is(list.pollFirst()));
         assertThat(kv.val().getInt(), is(list.pollFirst()));
       }
     }
   }
 
+  @Test(expected = IllegalStateException.class)
+  public void iteratorOnlyReturnedOnce() {
+    try (Txn<ByteBuffer> txn = env.txnRead();
+         CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+      c.iterator(); // ok
+      c.iterator(); // fails
+    }
+  }
+
   @Test
   public void lessThanBackwardTest() {
     verify(lessThanBackward(bb(5)), 8, 6);
@@ -270,13 +278,15 @@ public void lessThanTest() {
   @Test(expected = NoSuchElementException.class)
   public void nextThrowsNoSuchElementExceptionIfNoMoreElements() {
     try (Txn<ByteBuffer> txn = env.txnRead();
-         CursorIterator<ByteBuffer> c = db.iterate(txn)) {
-      for (final KeyVal<ByteBuffer> kv : c.iterable()) {
+         CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+      final Iterator<KeyVal<ByteBuffer>> i = c.iterator();
+      while (i.hasNext()) {
+        final KeyVal<ByteBuffer> kv = i.next();
         assertThat(kv.key().getInt(), is(list.pollFirst()));
         assertThat(kv.val().getInt(), is(list.pollFirst()));
       }
-      assertThat(c.hasNext(), is(false));
-      c.next();
+      assertThat(i.hasNext(), is(false));
+      i.next();
     }
   }
 
@@ -329,7 +339,8 @@ public void removeOddElements() {
     verify(all(), 2, 4, 6, 8);
     int idx = -1;
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      try (CursorIterator<ByteBuffer> c = db.iterate(txn)) {
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn)) {
+        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
         while (c.hasNext()) {
           c.next();
           idx++;
@@ -353,8 +364,8 @@ private void verify(final KeyRange<ByteBuffer> range,
     final List<Integer> results = new ArrayList<>();
 
     try (Txn<ByteBuffer> txn = env.txnRead();
-         CursorIterator<ByteBuffer> c = db.iterate(txn, range, comparator)) {
-      for (final KeyVal<ByteBuffer> kv : c.iterable()) {
+         CursorIterable<ByteBuffer> c = db.iterate(txn, range, comparator)) {
+      for (final KeyVal<ByteBuffer> kv : c) {
         final int key = kv.key().getInt();
         final int val = kv.val().getInt();
         results.add(key);
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index e4c9eecd..6f09739a 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -31,6 +31,7 @@
 import java.util.ArrayList;
 import static java.util.Collections.nCopies;
 import java.util.Comparator;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Random;
 import java.util.concurrent.ExecutionException;
@@ -60,6 +61,7 @@
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
 import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
+import org.lmdbjava.CursorIterable.KeyVal;
 import org.lmdbjava.Dbi.DbFullException;
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
 import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
@@ -126,7 +128,8 @@ public void customComparator() {
       txn.commit();
     }
     try (Txn<ByteBuffer> txn = env.txnRead();
-         CursorIterator<ByteBuffer> iter = db.iterate(txn, atMost(bb(4)))) {
+         CursorIterable<ByteBuffer> ci = db.iterate(txn, atMost(bb(4)))) {
+      final Iterator<KeyVal<ByteBuffer>> iter = ci.iterator();
       assertThat(iter.next().key(), is(bb(8)));
       assertThat(iter.next().key(), is(bb(6)));
       assertThat(iter.next().key(), is(bb(4)));
@@ -167,8 +170,8 @@ public void dbiWithComparatorThreadSafety() {
     }
 
     try (Txn<ByteBuffer> txn = env.txnRead();
-         CursorIterator<ByteBuffer> iter = db.iterate(txn)) {
-
+         CursorIterable<ByteBuffer> ci = db.iterate(txn)) {
+      final Iterator<KeyVal<ByteBuffer>> iter = ci.iterator();
       final List<Integer> result = new ArrayList<>();
       while (iter.hasNext()) {
         result.add(iter.next().key().getInt());
diff --git a/src/test/java/org/lmdbjava/TutorialTest.java b/src/test/java/org/lmdbjava/TutorialTest.java
index 7d4f37f5..5ed75b17 100644
--- a/src/test/java/org/lmdbjava/TutorialTest.java
+++ b/src/test/java/org/lmdbjava/TutorialTest.java
@@ -41,7 +41,7 @@
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
 import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
-import org.lmdbjava.CursorIterator.KeyVal;
+import org.lmdbjava.CursorIterable.KeyVal;
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
 import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
 import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
@@ -319,19 +319,19 @@ public void tutorial4() throws IOException {
       db.put(txn, key, val);
       key.clear();
 
-      // Each iterator uses a cursor and must be closed when finished.
-      // Iterate forward in terms of key ordering starting with the first key.
-      try (CursorIterator<ByteBuffer> it = db.iterate(txn, KeyRange.all())) {
-        for (final KeyVal<ByteBuffer> kv : it.iterable()) {
+      // Each iterable uses a cursor and must be closed when finished. Iterate
+      // forward in terms of key ordering starting with the first key.
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+        for (final KeyVal<ByteBuffer> kv : ci) {
           assertThat(kv.key(), notNullValue());
           assertThat(kv.val(), notNullValue());
         }
       }
 
       // Iterate backward in terms of key ordering starting with the last key.
-      try (CursorIterator<ByteBuffer> it = db.iterate(txn,
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn,
                                                       KeyRange.allBackward())) {
-        for (final KeyVal<ByteBuffer> kv : it.iterable()) {
+        for (final KeyVal<ByteBuffer> kv : ci) {
           assertThat(kv.key(), notNullValue());
           assertThat(kv.val(), notNullValue());
         }
@@ -342,8 +342,8 @@ public void tutorial4() throws IOException {
       // terminology for our range classes (see KeyRangeType for further details).
       key.putInt(1);
       final KeyRange<ByteBuffer> range = KeyRange.atLeastBackward(key);
-      try (CursorIterator<ByteBuffer> it = db.iterate(txn, range)) {
-        for (final KeyVal<ByteBuffer> kv : it.iterable()) {
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, range)) {
+        for (final KeyVal<ByteBuffer> kv : ci) {
           assertThat(kv.key(), notNullValue());
           assertThat(kv.val(), notNullValue());
         }
diff --git a/src/test/java/org/lmdbjava/TxnTest.java b/src/test/java/org/lmdbjava/TxnTest.java
index 21b35808..fe25d9a2 100644
--- a/src/test/java/org/lmdbjava/TxnTest.java
+++ b/src/test/java/org/lmdbjava/TxnTest.java
@@ -120,8 +120,8 @@ public void rangeSearch() {
       end.put("z".getBytes(UTF_8)).flip();
 
       final List<String> keysFound = new ArrayList<>();
-      try (CursorIterator<ByteBuffer> ckr = db.iterate(txn, closed(start, end))) {
-        for (final CursorIterator.KeyVal<ByteBuffer> kv : ckr.iterable()) {
+      try (CursorIterable<ByteBuffer> ckr = db.iterate(txn, closed(start, end))) {
+        for (final CursorIterable.KeyVal<ByteBuffer> kv : ckr) {
           keysFound.add(UTF_8.decode(kv.key()).toString());
         }
       }

From ccf468aba77e465548356c3aa57a22c3a7b53c5f Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 27 Apr 2020 12:29:42 +1000
Subject: [PATCH 072/322] Remove deprecated IteratorType (#154)

---
 .../java/org/lmdbjava/CursorIterable.java     | 17 ------
 src/main/java/org/lmdbjava/Dbi.java           | 50 -----------------
 .../java/org/lmdbjava/CursorIteratorTest.java | 53 -------------------
 3 files changed, 120 deletions(-)

diff --git a/src/main/java/org/lmdbjava/CursorIterable.java b/src/main/java/org/lmdbjava/CursorIterable.java
index 3020b746..4eec8cd8 100644
--- a/src/main/java/org/lmdbjava/CursorIterable.java
+++ b/src/main/java/org/lmdbjava/CursorIterable.java
@@ -228,23 +228,6 @@ void setV(final T val) {
 
   }
 
-  /**
-   * Represents the internal {@link CursorIterable} state.
-   *
-   * @deprecated use {@link Dbi} iterate method with a {@link KeyRange} instead
-   */
-  @Deprecated
-  public enum IteratorType {
-    /**
-     * Move forward.
-     */
-    FORWARD,
-    /**
-     * Move backward.
-     */
-    BACKWARD
-  }
-
   /**
    * Represents the internal {@link CursorIterator} state.
    */
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index 205de84d..2106687d 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -30,15 +30,10 @@
 import jnr.ffi.Pointer;
 import jnr.ffi.byref.IntByReference;
 import jnr.ffi.byref.PointerByReference;
-import org.lmdbjava.CursorIterable.IteratorType;
-import static org.lmdbjava.CursorIterable.IteratorType.FORWARD;
 import static org.lmdbjava.Dbi.KeyExistsException.MDB_KEYEXIST;
 import static org.lmdbjava.Dbi.KeyNotFoundException.MDB_NOTFOUND;
 import static org.lmdbjava.Env.SHOULD_CHECK;
 import static org.lmdbjava.KeyRange.all;
-import static org.lmdbjava.KeyRange.allBackward;
-import static org.lmdbjava.KeyRange.atLeast;
-import static org.lmdbjava.KeyRange.atLeastBackward;
 import org.lmdbjava.Library.ComparatorCallback;
 import static org.lmdbjava.Library.LIB;
 import org.lmdbjava.Library.MDB_stat;
@@ -55,7 +50,6 @@
  *
  * @param <T> buffer type
  */
-@SuppressWarnings("PMD.GodClass")
 public final class Dbi<T> {
 
   private final ComparatorCallback ccb;
@@ -263,50 +257,6 @@ public CursorIterable<T> iterate(final Txn<T> txn) {
     return iterate(txn, all());
   }
 
-  /**
-   * Iterate the database from the first/last item and forwards/backwards.
-   *
-   * @param txn  transaction handle (not null; not committed)
-   * @param type direction of iterator (not null)
-   * @return iterator (never null)
-   * @deprecated use iterate method with a {@link KeyRange} instead
-   */
-  @Deprecated
-  public CursorIterable<T> iterate(final Txn<T> txn, final IteratorType type) {
-    if (SHOULD_CHECK) {
-      requireNonNull(type);
-    }
-    final KeyRange<T> range = type == FORWARD ? all() : allBackward();
-    return iterate(txn, range);
-  }
-
-  /**
-   * Iterate the database from the first/last item and forwards/backwards by
-   * first seeking to the provided key.
-   *
-   * @param txn  transaction handle (not null; not committed)
-   * @param key  the key to search from (may be null to denote first record)
-   * @param type direction of iterator (not null)
-   * @return iterator (never null)
-   * @deprecated use iterate method with a {@link KeyRange} instead
-   */
-  @Deprecated
-  public CursorIterable<T> iterate(final Txn<T> txn, final T key,
-                                   final IteratorType type) {
-    if (SHOULD_CHECK) {
-      requireNonNull(type);
-    }
-
-    final KeyRange<T> range;
-    if (type == FORWARD) {
-      range = key == null ? all() : atLeast(key);
-    } else {
-      range = key == null ? allBackward() : atLeastBackward(key);
-    }
-
-    return iterate(txn, range);
-  }
-
   /**
    * Iterate the database in accordance with the provided {@link KeyRange} and
    * default {@link Comparator}.
diff --git a/src/test/java/org/lmdbjava/CursorIteratorTest.java b/src/test/java/org/lmdbjava/CursorIteratorTest.java
index f6b1411a..0db8de4b 100644
--- a/src/test/java/org/lmdbjava/CursorIteratorTest.java
+++ b/src/test/java/org/lmdbjava/CursorIteratorTest.java
@@ -41,8 +41,6 @@
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
-import static org.lmdbjava.CursorIterable.IteratorType.BACKWARD;
-import static org.lmdbjava.CursorIterable.IteratorType.FORWARD;
 import org.lmdbjava.CursorIterable.KeyVal;
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
 import static org.lmdbjava.Env.create;
@@ -121,31 +119,6 @@ public void atMostTest() {
     verify(atMost(bb(6)), 2, 4, 6);
   }
 
-  @Test
-  public void backwardDeprecated() {
-    try (Txn<ByteBuffer> txn = env.txnRead();
-         CursorIterable<ByteBuffer> c = db.iterate(txn, BACKWARD)) {
-      for (final KeyVal<ByteBuffer> kv : c) {
-        assertThat(kv.val().getInt(), is(list.pollLast()));
-        assertThat(kv.key().getInt(), is(list.pollLast()));
-      }
-    }
-  }
-
-  @Test
-  public void backwardSeekDeprecated() {
-    final ByteBuffer key = bb(6);
-    list.pollLast();
-    list.pollLast();
-    try (Txn<ByteBuffer> txn = env.txnRead();
-         CursorIterable<ByteBuffer> c = db.iterate(txn, key, BACKWARD)) {
-      for (final KeyVal<ByteBuffer> kv : c) {
-        assertThat(kv.val().getInt(), is(list.pollLast()));
-        assertThat(kv.key().getInt(), is(list.pollLast()));
-      }
-    }
-  }
-
   @Before
   @SuppressWarnings("PMD.CloseResource")
   public void before() throws IOException {
@@ -195,32 +168,6 @@ public void closedTest() {
     verify(closed(bb(1), bb(7)), 2, 4, 6);
   }
 
-  @Test
-  public void forwardDeprecated() {
-    try (Txn<ByteBuffer> txn = env.txnRead();
-         CursorIterable<ByteBuffer> c = db.iterate(txn, FORWARD)) {
-      for (final KeyVal<ByteBuffer> kv : c) {
-        assertThat(kv.key().getInt(), is(list.pollFirst()));
-        assertThat(kv.val().getInt(), is(list.pollFirst()));
-      }
-    }
-  }
-
-  @Test
-  public void forwardSeekDeprecated() {
-    final ByteBuffer key = bb(4);
-    list.pollFirst();
-    list.pollFirst();
-
-    try (Txn<ByteBuffer> txn = env.txnRead();
-         CursorIterable<ByteBuffer> c = db.iterate(txn, key, FORWARD)) {
-      for (final KeyVal<ByteBuffer> kv : c) {
-        assertThat(kv.key().getInt(), is(list.pollFirst()));
-        assertThat(kv.val().getInt(), is(list.pollFirst()));
-      }
-    }
-  }
-
   @Test
   public void greaterThanBackwardTest() {
     verify(greaterThanBackward(bb(6)), 4, 2);

From b0dadb0f9f15abdf423c0b6cdeb525967d54f5d8 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 27 Apr 2020 12:42:43 +1000
Subject: [PATCH 073/322] Correct JavaDoc typo

---
 src/main/java/org/lmdbjava/CursorIterable.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/org/lmdbjava/CursorIterable.java b/src/main/java/org/lmdbjava/CursorIterable.java
index 4eec8cd8..4834ebe0 100644
--- a/src/main/java/org/lmdbjava/CursorIterable.java
+++ b/src/main/java/org/lmdbjava/CursorIterable.java
@@ -34,7 +34,7 @@
 
 /**
  * {@link Iterable} that creates a single {@link Iterator} that will iterate
- * over a {@link Cursor}as specified by a {@link KeyRange}.
+ * over a {@link Cursor} as specified by a {@link KeyRange}.
  *
  * <p>
  * An instance will create and close its own cursor.

From e27914a3012387d5ff8a228d68f960fdedf49e7e Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 27 Apr 2020 12:43:58 +1000
Subject: [PATCH 074/322] Rename field and improve exception message (#154)

---
 src/main/java/org/lmdbjava/CursorIterable.java | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/main/java/org/lmdbjava/CursorIterable.java b/src/main/java/org/lmdbjava/CursorIterable.java
index 4834ebe0..72967b7e 100644
--- a/src/main/java/org/lmdbjava/CursorIterable.java
+++ b/src/main/java/org/lmdbjava/CursorIterable.java
@@ -53,7 +53,7 @@ public final class CursorIterable<T> implements
   private final Comparator<T> comparator;
   private final Cursor<T> cursor;
   private final KeyVal<T> entry;
-  private boolean iterableReturned;
+  private boolean iteratorReturned;
   private final KeyRange<T> range;
   private State state = REQUIRES_INITIAL_OP;
 
@@ -85,10 +85,10 @@ public void close() {
   @Override
   @SuppressWarnings("checkstyle:AnonInnerLength")
   public Iterator<KeyVal<T>> iterator() {
-    if (iterableReturned) {
-      throw new IllegalStateException("Iterable can only be returned once");
+    if (iteratorReturned) {
+      throw new IllegalStateException("Iterator can only be returned once");
     }
-    iterableReturned = true;
+    iteratorReturned = true;
 
     return new Iterator<KeyVal<T>>() {
       @Override

From 718f162bc287c2e7cf539d3295fd939ddade80d5 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 27 Apr 2020 12:53:47 +1000
Subject: [PATCH 075/322] Fix EnvFlags JavaDocs (#141)

---
 src/main/java/org/lmdbjava/EnvFlags.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/main/java/org/lmdbjava/EnvFlags.java b/src/main/java/org/lmdbjava/EnvFlags.java
index 5a58c996..b8883706 100644
--- a/src/main/java/org/lmdbjava/EnvFlags.java
+++ b/src/main/java/org/lmdbjava/EnvFlags.java
@@ -57,7 +57,7 @@ public enum EnvFlags implements MaskedFlag {
    */
   MDB_RDONLY_ENV(0x2_0000),
   /**
-   * Use a writeable memory map unless {@link #MDB_RDONLY} is set.
+   * Use a writeable memory map unless {@link #MDB_RDONLY_ENV} is set.
    *
    * <p>
    * This is faster and uses fewer mallocs, but loses protection from
@@ -73,7 +73,7 @@ public enum EnvFlags implements MaskedFlag {
    * <p>
    * Flush system buffers to disk only once per transaction, omit the metadata
    * flush. Defer that until the system flushes files to disk, or next
-   * non-{@link #MDB_RDONLY} commit or {@link Env#sync(boolean)}. This
+   * non-{@link #MDB_RDONLY_ENV} commit or {@link Env#sync(boolean)}. This
    * optimization* maintains database integrity, but a system crash may undo the
    * last* committed transaction. I.e. it preserves the ACI (atomicity,
    * consistency, isolation) but not D (durability) database property.

From 9c9e8dcb5ec34cfb445ecc62b564eb6097e5b1fd Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 27 Apr 2020 12:54:54 +1000
Subject: [PATCH 076/322] Fix JavaDoc references to CursorIterable (#154)

---
 src/main/java/org/lmdbjava/CursorIterable.java | 2 +-
 src/main/java/org/lmdbjava/Env.java            | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/main/java/org/lmdbjava/CursorIterable.java b/src/main/java/org/lmdbjava/CursorIterable.java
index 72967b7e..79bb3e38 100644
--- a/src/main/java/org/lmdbjava/CursorIterable.java
+++ b/src/main/java/org/lmdbjava/CursorIterable.java
@@ -229,7 +229,7 @@ void setV(final T val) {
   }
 
   /**
-   * Represents the internal {@link CursorIterator} state.
+   * Represents the internal {@link CursorIterable} state.
    */
   enum State {
     REQUIRES_INITIAL_OP, REQUIRES_NEXT_OP, REQUIRES_ITERATOR_OP, RELEASED,
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 8b5cd1af..57381576 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -301,7 +301,7 @@ public Dbi<T> openDbi(final byte[] name, final DbiFlags... flags) {
    * If a custom comparator is specified, this comparator is called from LMDB
    * any time it needs to compare two keys. The comparator must be used any time
    * any time this database is opened, otherwise database corruption may occur.
-   * The custom comparator will also be used whenever a {@link CursorIterator}
+   * The custom comparator will also be used whenever a {@link CursorIterable}
    * is created from the returned {@link Dbi}. If a custom comparator is not
    * specified, LMDB's native default lexicographical order is used. The default
    * comparator is typically more efficient (as there is no need for the native

From 958690d3bee2eec6b2d77c9aa7dd33b2b2e82898 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 27 Apr 2020 12:56:25 +1000
Subject: [PATCH 077/322] Rename CursorIteratorTest to CursorIterableTest
 (#154)

---
 .../{CursorIteratorTest.java => CursorIterableTest.java}        | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
 rename src/test/java/org/lmdbjava/{CursorIteratorTest.java => CursorIterableTest.java} (99%)

diff --git a/src/test/java/org/lmdbjava/CursorIteratorTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
similarity index 99%
rename from src/test/java/org/lmdbjava/CursorIteratorTest.java
rename to src/test/java/org/lmdbjava/CursorIterableTest.java
index 0db8de4b..ef6c18a6 100644
--- a/src/test/java/org/lmdbjava/CursorIteratorTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -71,7 +71,7 @@
 /**
  * Test {@link CursorIterable}.
  */
-public final class CursorIteratorTest {
+public final class CursorIterableTest {
 
   @Rule
   public final TemporaryFolder tmp = new TemporaryFolder();

From 972dfe74e2c817c71a7978104160011fbed2d800 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 27 Apr 2020 13:41:51 +1000
Subject: [PATCH 078/322] Tests to compare buffer contents, not buffer
 instances

While ByteBuffer does override equals(Object) and compare the
contents, an unexpected CI test failure log was unhelpful because it
did not reveal the actual contents of the buffer:

Expected: is <java.nio.DirectByteBuffer[pos=0 lim=4 cap=4]>
     but: was <java.nio.DirectByteBuffer[pos=0 lim=4 cap=4]>
	at org.hamcrest.MatcherAssert.assertThat(MatcherAssert.java:20)
	at org.hamcrest.MatcherAssert.assertThat(MatcherAssert.java:6)
	at org.lmdbjava.DbiTest.customComparator(DbiTest.java:133)

This change ensures the actual buffer contents are compared and any
mismatch is reported in the logs.
---
 src/test/java/org/lmdbjava/DbiTest.java | 6 +++---
 src/test/java/org/lmdbjava/EnvTest.java | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 6f09739a..1f059022 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -130,9 +130,9 @@ public void customComparator() {
     try (Txn<ByteBuffer> txn = env.txnRead();
          CursorIterable<ByteBuffer> ci = db.iterate(txn, atMost(bb(4)))) {
       final Iterator<KeyVal<ByteBuffer>> iter = ci.iterator();
-      assertThat(iter.next().key(), is(bb(8)));
-      assertThat(iter.next().key(), is(bb(6)));
-      assertThat(iter.next().key(), is(bb(4)));
+      assertThat(iter.next().key().getInt(), is(8));
+      assertThat(iter.next().key().getInt(), is(6));
+      assertThat(iter.next().key().getInt(), is(4));
     }
   }
 
diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index 8b8e067f..2d450c24 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -333,7 +333,7 @@ public void setMapSize() throws IOException {
       env.setMapSize(500_000);
 
       try (Txn<ByteBuffer> roTxn = env.txnRead()) {
-        assertThat(db.get(roTxn, bb(1)), is(bb(42)));
+        assertThat(db.get(roTxn, bb(1)).getInt(), is(42));
       }
 
       mapFullExThrown = false;

From e787da6aa8b8a716b10affcfa597a85aba06c3c4 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 27 Apr 2020 23:11:46 +1000
Subject: [PATCH 079/322] Add system property to specify native library
 extraction directory (closes #155)

---
 src/main/java/org/lmdbjava/Library.java | 20 +++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

diff --git a/src/main/java/org/lmdbjava/Library.java b/src/main/java/org/lmdbjava/Library.java
index a458152d..cea03bab 100644
--- a/src/main/java/org/lmdbjava/Library.java
+++ b/src/main/java/org/lmdbjava/Library.java
@@ -62,6 +62,15 @@ final class Library {
    * avoiding the library copy etc).
    */
   public static final String DISABLE_EXTRACT_PROP = "lmdbjava.disable.extract";
+  /**
+   * Java system property name that can be set to the path of an existing
+   * directory into which the LMDB system library will be extracted from the
+   * LmdbJava JAR. If unspecified the LMDB system library is extracted to the
+   * <code>java.io.tmpdir</code>. Ignored if the LMDB system library is not
+   * being extracted from the LmdbJava JAR (as would be the case if other
+   * system properties defined in <code>Library</code> have been set).
+   */
+  public static final String LMDB_EXTRACT_DIR_PROP = "lmdbjava.extract.dir";
   /**
    * Java system property name that can be set to provide a custom path to a
    * external LMDB system library. If set, the system property
@@ -73,6 +82,11 @@ final class Library {
    * permitted.
    */
   public static final boolean SHOULD_EXTRACT = !getBoolean(DISABLE_EXTRACT_PROP);
+  /**
+   * Indicates the directory where the LMDB system library will be extracted.
+   */
+  static final String EXTRACT_DIR = getProperty(LMDB_EXTRACT_DIR_PROP,
+                                                getProperty("java.io.tmpdir"));
   static final Lmdb LIB;
   static final jnr.ffi.Runtime RUNTIME;
   /**
@@ -119,7 +133,11 @@ private static String extract(final String name) {
     final String suffix = name.substring(name.lastIndexOf('.'));
     final File file;
     try {
-      file = createTempFile("lmdbjava-native-library-", suffix);
+      final File dir = new File(EXTRACT_DIR);
+      if (!dir.exists() || !dir.isDirectory()) {
+        throw new IllegalStateException("Invalid extraction directory " + dir);
+      }
+      file = createTempFile("lmdbjava-native-library-", suffix, dir);
       file.deleteOnExit();
       final ClassLoader cl = currentThread().getContextClassLoader();
       try (InputStream in = cl.getResourceAsStream(name);

From 0d70e3358dca43f5760eaac69d5dd1b6f385c8f8 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Tue, 28 Apr 2020 04:34:44 +1000
Subject: [PATCH 080/322] Add LGTM badges

---
 README.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/README.md b/README.md
index 4311c86e..0945af36 100644
--- a/README.md
+++ b/README.md
@@ -2,6 +2,8 @@
 [![codecov](https://codecov.io/gh/lmdbjava/lmdbjava/branch/master/graph/badge.svg)](https://codecov.io/gh/lmdbjava/lmdbjava)
 [![Javadocs](http://www.javadoc.io/badge/org.lmdbjava/lmdbjava.svg?color=blue)](http://www.javadoc.io/doc/org.lmdbjava/lmdbjava)
 [![Maven Central](https://img.shields.io/maven-central/v/org.lmdbjava/lmdbjava.svg?maxAge=3600)](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22org.lmdbjava%22%20AND%20a%3A%22lmdbjava%22)
+[![Total alerts](https://img.shields.io/lgtm/alerts/g/lmdbjava/lmdbjava.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/lmdbjava/lmdbjava/alerts/)
+[![Language grade: Java](https://img.shields.io/lgtm/grade/java/g/lmdbjava/lmdbjava.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/lmdbjava/lmdbjava/context:java)
 
 # LMDB for Java
 

From 530296e7fe09b90444ac2defda27c13d62fc61ca Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Wed, 20 May 2020 09:07:33 +1000
Subject: [PATCH 081/322] ByteArrayProxy should be final

---
 src/main/java/org/lmdbjava/ByteArrayProxy.java | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/main/java/org/lmdbjava/ByteArrayProxy.java b/src/main/java/org/lmdbjava/ByteArrayProxy.java
index 237170b4..813259be 100644
--- a/src/main/java/org/lmdbjava/ByteArrayProxy.java
+++ b/src/main/java/org/lmdbjava/ByteArrayProxy.java
@@ -31,7 +31,7 @@
  *
  * {@link Env#create(org.lmdbjava.BufferProxy)}.
  */
-public class ByteArrayProxy extends BufferProxy<byte[]> {
+public final class ByteArrayProxy extends BufferProxy<byte[]> {
 
   /**
    * The byte array proxy. Guaranteed to never be null.
@@ -69,28 +69,28 @@ public static int compareArrays(final byte[] o1, final byte[] o2) {
   }
 
   @Override
-  protected final byte[] allocate() {
+  protected byte[] allocate() {
     return new byte[0];
   }
 
   @Override
-  protected final int compare(final byte[] o1, final byte[] o2) {
+  protected int compare(final byte[] o1, final byte[] o2) {
     return compareArrays(o1, o2);
   }
 
   @Override
-  protected final void deallocate(final byte[] buff) {
+  protected void deallocate(final byte[] buff) {
     // byte arrays cannot be allocated
   }
 
   @Override
-  protected final byte[] getBytes(final byte[] buffer) {
+  protected byte[] getBytes(final byte[] buffer) {
     return Arrays.copyOf(buffer, buffer.length);
   }
 
   @Override
-  protected final void in(final byte[] buffer, final Pointer ptr,
-                          final long ptrAddr) {
+  protected void in(final byte[] buffer, final Pointer ptr,
+                    final long ptrAddr) {
     final Pointer pointer = MEM_MGR.allocateDirect(buffer.length);
     pointer.put(0, buffer, 0, buffer.length);
     ptr.putLong(STRUCT_FIELD_OFFSET_SIZE, buffer.length);
@@ -98,13 +98,13 @@ protected final void in(final byte[] buffer, final Pointer ptr,
   }
 
   @Override
-  protected final void in(final byte[] buffer, final int size, final Pointer ptr,
+  protected void in(final byte[] buffer, final int size, final Pointer ptr,
                           final long ptrAddr) {
     // cannot reserve for byte arrays
   }
 
   @Override
-  protected final byte[] out(final byte[] buffer, final Pointer ptr,
+  protected byte[] out(final byte[] buffer, final Pointer ptr,
                              final long ptrAddr) {
     final long addr = ptr.getAddress(STRUCT_FIELD_OFFSET_DATA);
     final int size = (int) ptr.getLong(STRUCT_FIELD_OFFSET_SIZE);

From 57b1b5b48e150d47d3184c6681e3a0e98a0e1591 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Wed, 20 May 2020 09:09:14 +1000
Subject: [PATCH 082/322] ByteArrayProxy should be used via its static final
 field

---
 src/main/java/org/lmdbjava/ByteArrayProxy.java | 3 +++
 src/test/java/org/lmdbjava/DbiTest.java        | 3 ++-
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/main/java/org/lmdbjava/ByteArrayProxy.java b/src/main/java/org/lmdbjava/ByteArrayProxy.java
index 813259be..aeb9048d 100644
--- a/src/main/java/org/lmdbjava/ByteArrayProxy.java
+++ b/src/main/java/org/lmdbjava/ByteArrayProxy.java
@@ -40,6 +40,9 @@ public final class ByteArrayProxy extends BufferProxy<byte[]> {
 
   private static final MemoryManager MEM_MGR = RUNTIME.getMemoryManager();
 
+  private ByteArrayProxy() {
+  }
+
   /**
    * Lexicographically compare two byte arrays.
    *
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 1f059022..dbbcec6e 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -60,6 +60,7 @@
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
+import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
 import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
 import org.lmdbjava.CursorIterable.KeyVal;
 import org.lmdbjava.Dbi.DbFullException;
@@ -327,7 +328,7 @@ public void putCommitGet() {
   @Test
   public void putCommitGetByteArray() throws IOException {
     final File path = tmp.newFile();
-    try (Env<byte[]> envBa = create(new ByteArrayProxy())
+    try (Env<byte[]> envBa = create(PROXY_BA)
         .setMapSize(MEBIBYTES.toBytes(64))
         .setMaxReaders(1)
         .setMaxDbs(2)

From b60e7d009da57bc3d311e65f0f8c01769b2cf88c Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Wed, 20 May 2020 09:09:31 +1000
Subject: [PATCH 083/322] DirectBufferProxy constructor should be private

---
 src/main/java/org/lmdbjava/DirectBufferProxy.java | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/main/java/org/lmdbjava/DirectBufferProxy.java b/src/main/java/org/lmdbjava/DirectBufferProxy.java
index 2ba68781..d7aeaa57 100644
--- a/src/main/java/org/lmdbjava/DirectBufferProxy.java
+++ b/src/main/java/org/lmdbjava/DirectBufferProxy.java
@@ -56,6 +56,9 @@ public final class DirectBufferProxy extends BufferProxy<DirectBuffer> {
   private static final ThreadLocal<OneToOneConcurrentArrayQueue<DirectBuffer>> BUFFERS
       = withInitial(() -> new OneToOneConcurrentArrayQueue<>(16));
 
+  private DirectBufferProxy() {
+  }
+
   /**
    * Lexicographically compare two buffers.
    *

From c3920de8e8e206cf100419b68e895da3e843e4a2 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Wed, 20 May 2020 09:09:51 +1000
Subject: [PATCH 084/322] Netty ByteBufProxy should be accessed via a static
 final field (#152)

---
 src/main/java/org/lmdbjava/ByteBufProxy.java    | 10 ++++++++++
 src/test/java/org/lmdbjava/ComparatorTest.java  |  2 +-
 src/test/java/org/lmdbjava/CursorParamTest.java |  3 ++-
 3 files changed, 13 insertions(+), 2 deletions(-)

diff --git a/src/main/java/org/lmdbjava/ByteBufProxy.java b/src/main/java/org/lmdbjava/ByteBufProxy.java
index 9e220f16..042416d8 100644
--- a/src/main/java/org/lmdbjava/ByteBufProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufProxy.java
@@ -38,6 +38,13 @@
  */
 public final class ByteBufProxy extends BufferProxy<ByteBuf> {
 
+  /**
+   * A proxy for using Netty {@link ByteBuf}. Guaranteed to never be null,
+   * although a class initialization exception will occur if an attempt is made
+   * to access this field when Netty is unavailable.
+   */
+  public static final BufferProxy<ByteBuf> PROXY_NETTY = new ByteBufProxy();
+
   private static final long ADDRESS_OFFSET;
 
   /**
@@ -66,6 +73,9 @@ public final class ByteBufProxy extends BufferProxy<ByteBuf> {
     }
   }
 
+  private ByteBufProxy() {
+  }
+
   static Field findField(final String c, final String name) {
     Class<?> clazz;
     try {
diff --git a/src/test/java/org/lmdbjava/ComparatorTest.java b/src/test/java/org/lmdbjava/ComparatorTest.java
index a2ea539b..1f5b8f9a 100644
--- a/src/test/java/org/lmdbjava/ComparatorTest.java
+++ b/src/test/java/org/lmdbjava/ComparatorTest.java
@@ -208,7 +208,7 @@ public int compare(final byte[] o1, final byte[] o2) {
       final ByteBuf o2b = DEFAULT.directBuffer(o2.length);
       o1b.writeBytes(o1);
       o2b.writeBytes(o2);
-      return new ByteBufProxy().compare(o1b, o2b);
+      return ByteBufProxy.PROXY_NETTY.compare(o1b, o2b);
     }
   }
 
diff --git a/src/test/java/org/lmdbjava/CursorParamTest.java b/src/test/java/org/lmdbjava/CursorParamTest.java
index 0e2fa9ee..cb943857 100644
--- a/src/test/java/org/lmdbjava/CursorParamTest.java
+++ b/src/test/java/org/lmdbjava/CursorParamTest.java
@@ -40,6 +40,7 @@
 import org.junit.runners.Parameterized.Parameter;
 import org.junit.runners.Parameterized.Parameters;
 import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
+import static org.lmdbjava.ByteBufProxy.PROXY_NETTY;
 import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
 import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
@@ -287,7 +288,7 @@ public void set(final DirectBuffer buff, final int val) {
   private static class NettyBufferRunner extends AbstractBufferRunner<ByteBuf> {
 
     NettyBufferRunner() {
-      super(new ByteBufProxy());
+      super(PROXY_NETTY);
     }
 
     @Override

From dd10ae3424820afecb006c127a02ff56ec95cecd Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Wed, 20 May 2020 09:12:12 +1000
Subject: [PATCH 085/322] Automatic formatting only

---
 src/main/java/org/lmdbjava/ByteArrayProxy.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/main/java/org/lmdbjava/ByteArrayProxy.java b/src/main/java/org/lmdbjava/ByteArrayProxy.java
index aeb9048d..d6c13deb 100644
--- a/src/main/java/org/lmdbjava/ByteArrayProxy.java
+++ b/src/main/java/org/lmdbjava/ByteArrayProxy.java
@@ -102,13 +102,13 @@ protected void in(final byte[] buffer, final Pointer ptr,
 
   @Override
   protected void in(final byte[] buffer, final int size, final Pointer ptr,
-                          final long ptrAddr) {
+                    final long ptrAddr) {
     // cannot reserve for byte arrays
   }
 
   @Override
   protected byte[] out(final byte[] buffer, final Pointer ptr,
-                             final long ptrAddr) {
+                       final long ptrAddr) {
     final long addr = ptr.getAddress(STRUCT_FIELD_OFFSET_DATA);
     final int size = (int) ptr.getLong(STRUCT_FIELD_OFFSET_SIZE);
     final Pointer pointer = MEM_MGR.newPointer(addr, size);

From 6e64befa0aed84500dc1b08f3009d0a0475fc329 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 22 May 2020 17:02:23 +1000
Subject: [PATCH 086/322] Env.copy(..) to support destinations that are files
 (fixes #157)

---
 src/main/java/org/lmdbjava/Env.java     | 50 ++++++++++++++++++-------
 src/test/java/org/lmdbjava/EnvTest.java | 35 +++++++++++++++--
 2 files changed, 68 insertions(+), 17 deletions(-)

diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 57381576..765c1565 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -32,6 +32,7 @@
 import jnr.ffi.Pointer;
 import jnr.ffi.byref.PointerByReference;
 import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
+import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
 import static org.lmdbjava.EnvFlags.MDB_RDONLY_ENV;
 import static org.lmdbjava.Library.LIB;
 import org.lmdbjava.Library.MDB_envinfo;
@@ -65,14 +66,16 @@ public final class Env<T> implements AutoCloseable {
 
   private boolean closed;
   private final int maxKeySize;
+  private final boolean noSubDir;
   private final BufferProxy<T> proxy;
   private final Pointer ptr;
   private final boolean readOnly;
 
   private Env(final BufferProxy<T> proxy, final Pointer ptr,
-              final boolean readOnly) {
+              final boolean readOnly, final boolean noSubDir) {
     this.proxy = proxy;
     this.readOnly = readOnly;
+    this.noSubDir = noSubDir;
     this.ptr = ptr;
     // cache max key size to avoid further JNI calls
     this.maxKeySize = LIB.mdb_env_get_maxkeysize(ptr);
@@ -137,25 +140,22 @@ public void close() {
    * lockfile is created, since it gets recreated at need.
    *
    * <p>
+   * If this environment was created using {@link EnvFlags#MDB_NOSUBDIR}, the
+   * destination path must be a directory that exists but contains no files. If
+   * {@link EnvFlags#MDB_NOSUBDIR} was used, the destination path must not
+   * exist, but it must be possible to create a file at the provided path.
+   *
+   * <p>
    * Note: This call can trigger significant file size growth if run in parallel
    * with write transactions, because it employs a read-only transaction. See
    * long-lived transactions under "Caveats" in the LMDB native documentation.
    *
-   * @param path  destination directory, which must exist, be writable and empty
+   * @param path  writable destination path as described above
    * @param flags special options for this copy
    */
   public void copy(final File path, final CopyFlags... flags) {
     requireNonNull(path);
-    if (!path.exists()) {
-      throw new InvalidCopyDestination("Path must exist");
-    }
-    if (!path.isDirectory()) {
-      throw new InvalidCopyDestination("Path must be a directory");
-    }
-    final String[] files = path.list();
-    if (files != null && files.length > 0) {
-      throw new InvalidCopyDestination("Path must contain no files");
-    }
+    validatePath(path);
     final int flagsMask = mask(flags);
     checkRc(LIB.mdb_env_copy2(ptr, path.getAbsolutePath(), flagsMask));
   }
@@ -392,6 +392,29 @@ Pointer pointer() {
     return ptr;
   }
 
+  private void validateDirectoryEmpty(final File path) {
+    if (!path.exists()) {
+      throw new InvalidCopyDestination("Path does not exist");
+    }
+    if (!path.isDirectory()) {
+      throw new InvalidCopyDestination("Path must be a directory");
+    }
+    final String[] files = path.list();
+    if (files != null && files.length > 0) {
+      throw new InvalidCopyDestination("Path must contain no files");
+    }
+  }
+
+  private void validatePath(final File path) {
+    if (noSubDir) {
+      if (path.exists()) {
+        throw new InvalidCopyDestination("Path must not exist for MDB_NOSUBDIR");
+      }
+      return;
+    }
+    validateDirectoryEmpty(path);
+  }
+
   /**
    * Object has already been closed and the operation is therefore prohibited.
    */
@@ -466,8 +489,9 @@ public Env<T> open(final File path, final int mode,
         checkRc(LIB.mdb_env_set_maxreaders(ptr, maxReaders));
         final int flagsMask = mask(flags);
         final boolean readOnly = isSet(flagsMask, MDB_RDONLY_ENV);
+        final boolean noSubDir = isSet(flagsMask, MDB_NOSUBDIR);
         checkRc(LIB.mdb_env_open(ptr, path.getAbsolutePath(), flagsMask, mode));
-        return new Env<>(proxy, ptr, readOnly);
+        return new Env<>(proxy, ptr, readOnly, noSubDir);
       } catch (final LmdbNativeException e) {
         LIB.mdb_env_close(ptr);
         throw e;
diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index 2d450c24..45fc1714 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -30,6 +30,7 @@
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.CoreMatchers.notNullValue;
 import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.greaterThan;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
@@ -152,7 +153,7 @@ public void cannotSyncOnceClosed() throws IOException {
   }
 
   @Test
-  public void copy() throws IOException {
+  public void copyDirectoryBased() throws IOException {
     final File dest = tmp.newFolder();
     assertThat(dest.exists(), is(true));
     assertThat(dest.isDirectory(), is(true));
@@ -167,7 +168,7 @@ public void copy() throws IOException {
   }
 
   @Test(expected = InvalidCopyDestination.class)
-  public void copyRejectsFileDestination() throws IOException {
+  public void copyDirectoryRejectsFileDestination() throws IOException {
     final File dest = tmp.newFile();
     final File src = tmp.newFolder();
     try (Env<ByteBuffer> env = create()
@@ -178,7 +179,7 @@ public void copyRejectsFileDestination() throws IOException {
   }
 
   @Test(expected = InvalidCopyDestination.class)
-  public void copyRejectsMissingDestination() throws IOException {
+  public void copyDirectoryRejectsMissingDestination() throws IOException {
     final File dest = tmp.newFolder();
     assertThat(dest.delete(), is(true));
     final File src = tmp.newFolder();
@@ -190,7 +191,7 @@ public void copyRejectsMissingDestination() throws IOException {
   }
 
   @Test(expected = InvalidCopyDestination.class)
-  public void copyRejectsNonEmptyDestination() throws IOException {
+  public void copyDirectoryRejectsNonEmptyDestination() throws IOException {
     final File dest = tmp.newFolder();
     final File subDir = new File(dest, "hello");
     assertThat(subDir.mkdir(), is(true));
@@ -202,6 +203,32 @@ public void copyRejectsNonEmptyDestination() throws IOException {
     }
   }
 
+  @Test
+  public void copyFileBased() throws IOException {
+    final File dest = tmp.newFile();
+    assertThat(dest.delete(), is(true));
+    assertThat(dest.exists(), is(false));
+    final File src = tmp.newFile();
+    try (Env<ByteBuffer> env = create()
+        .setMaxReaders(1)
+        .open(src, MDB_NOSUBDIR)) {
+      env.copy(dest, MDB_CP_COMPACT);
+    }
+    assertThat(dest.length(), greaterThan(0L));
+  }
+
+  @Test(expected = InvalidCopyDestination.class)
+  public void copyFileRejectsExistingDestination() throws IOException {
+    final File dest = tmp.newFile();
+    assertThat(dest.exists(), is(true));
+    final File src = tmp.newFile();
+    try (Env<ByteBuffer> env = create()
+        .setMaxReaders(1)
+        .open(src, MDB_NOSUBDIR)) {
+      env.copy(dest, MDB_CP_COMPACT);
+    }
+  }
+
   @Test
   @SuppressWarnings("PMD.CloseResource")
   public void createAsDirectory() throws IOException {

From b8fb7992da917d6fd6f942e03d32615cdd9371fe Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 29 May 2020 11:11:46 +1000
Subject: [PATCH 087/322] Update to Agrona 1.5.1

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 6825e457..7efd286d 100644
--- a/pom.xml
+++ b/pom.xml
@@ -105,7 +105,7 @@
     <dependency>
       <groupId>org.agrona</groupId>
       <artifactId>agrona</artifactId>
-      <version>1.4.1</version>
+      <version>1.5.1</version>
       <optional>true</optional>
     </dependency>
     <dependency>

From aca3c1f42168e7f8369a1e8de0175d61ad4d33c5 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 29 May 2020 11:11:54 +1000
Subject: [PATCH 088/322] Update to Netty 4.1.50

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 7efd286d..a8d66fc5 100644
--- a/pom.xml
+++ b/pom.xml
@@ -111,7 +111,7 @@
     <dependency>
       <groupId>io.netty</groupId>
       <artifactId>netty-all</artifactId>
-      <version>4.1.49.Final</version>
+      <version>4.1.50.Final</version>
       <optional>true</optional>
     </dependency>
     <dependency>

From 96c2ead9465f2e03cbfc03bc6aace69e86ee5bb8 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 29 May 2020 11:12:11 +1000
Subject: [PATCH 089/322] Update to JNR-FFI 2.1.15 and simplify JNR
 dependencies

---
 pom.xml | 19 +------------------
 1 file changed, 1 insertion(+), 18 deletions(-)

diff --git a/pom.xml b/pom.xml
index a8d66fc5..59de6459 100644
--- a/pom.xml
+++ b/pom.xml
@@ -72,24 +72,7 @@
     <dependency>
       <groupId>com.github.jnr</groupId>
       <artifactId>jnr-ffi</artifactId>
-      <version>2.1.13</version>
-      <exclusions>
-        <exclusion>
-          <groupId>com.github.jnr</groupId>
-          <artifactId>jffi</artifactId>
-        </exclusion>
-      </exclusions>
-    </dependency>
-    <dependency>
-      <groupId>com.github.jnr</groupId>
-      <artifactId>jffi</artifactId>
-      <version>1.2.23</version>
-    </dependency>
-    <dependency>
-      <groupId>com.github.jnr</groupId>
-      <artifactId>jffi</artifactId>
-      <classifier>native</classifier>
-      <version>1.2.23</version>
+      <version>2.1.15</version>
     </dependency>
     <dependency>
       <groupId>com.github.jnr</groupId>

From 627388f6510b71aa2bb574fcd09bbd8919f85b9b Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 1 Jun 2020 15:12:59 +1000
Subject: [PATCH 090/322] Update to Acegi Standard Project 0.4.1-SNAPSHOT

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 59de6459..c8ddfd61 100644
--- a/pom.xml
+++ b/pom.xml
@@ -4,7 +4,7 @@
   <parent>
     <groupId>au.com.acegi</groupId>
     <artifactId>acegi-standard-project</artifactId>
-    <version>0.4.0</version>
+    <version>0.4.1-SNAPSHOT</version>
   </parent>
   <groupId>org.lmdbjava</groupId>
   <artifactId>lmdbjava</artifactId>

From ab26d239b3b296fa87abdc8e9e1daaf560dbe072 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 1 Jun 2020 12:28:01 +1000
Subject: [PATCH 091/322] Remove unnecessary Checkstyle suppressions

---
 src/main/java/org/lmdbjava/KeyRange.java | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/main/java/org/lmdbjava/KeyRange.java b/src/main/java/org/lmdbjava/KeyRange.java
index e8cd57ab..c3e35864 100644
--- a/src/main/java/org/lmdbjava/KeyRange.java
+++ b/src/main/java/org/lmdbjava/KeyRange.java
@@ -70,7 +70,6 @@ public KeyRange(final KeyRangeType type, final T start, final T stop) {
    * @param <T> buffer type
    * @return a key range (never null)
    */
-  @SuppressWarnings({"checkstyle:SuppressWarnings", "unchecked"})
   public static <T> KeyRange<T> all() {
     return (KeyRange<T>) FW;
   }
@@ -81,7 +80,6 @@ public static <T> KeyRange<T> all() {
    * @param <T> buffer type
    * @return a key range (never null)
    */
-  @SuppressWarnings({"checkstyle:SuppressWarnings", "unchecked"})
   public static <T> KeyRange<T> allBackward() {
     return (KeyRange<T>) BK;
   }

From c1aa63ddbe68511e3e4a5b14d866eb033d0cb025 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 1 Jun 2020 12:27:48 +1000
Subject: [PATCH 092/322] Fix capitalisation of Checkstyle suppressions

Fix Checkstyle suppression capitalisation
---
 src/main/java/org/lmdbjava/BufferProxy.java     |  2 +-
 src/main/java/org/lmdbjava/CursorIterable.java  |  2 +-
 src/main/java/org/lmdbjava/Library.java         | 10 +++++-----
 src/test/java/org/lmdbjava/CursorParamTest.java |  2 +-
 src/test/java/org/lmdbjava/TutorialTest.java    |  4 ++--
 5 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/main/java/org/lmdbjava/BufferProxy.java b/src/main/java/org/lmdbjava/BufferProxy.java
index 6ad9ef34..4f3536ab 100644
--- a/src/main/java/org/lmdbjava/BufferProxy.java
+++ b/src/main/java/org/lmdbjava/BufferProxy.java
@@ -33,7 +33,7 @@
  *
  * @param <T> buffer type
  */
-@SuppressWarnings("checkstyle:abstractclassname")
+@SuppressWarnings("checkstyle:AbstractClassName")
 public abstract class BufferProxy<T> {
 
   /**
diff --git a/src/main/java/org/lmdbjava/CursorIterable.java b/src/main/java/org/lmdbjava/CursorIterable.java
index 79bb3e38..e02da2b6 100644
--- a/src/main/java/org/lmdbjava/CursorIterable.java
+++ b/src/main/java/org/lmdbjava/CursorIterable.java
@@ -92,7 +92,7 @@ public Iterator<KeyVal<T>> iterator() {
 
     return new Iterator<KeyVal<T>>() {
       @Override
-      @SuppressWarnings("checkstyle:returncount")
+      @SuppressWarnings("checkstyle:ReturnCount")
       public boolean hasNext() {
         while (state != RELEASED && state != TERMINATED) {
           update();
diff --git a/src/main/java/org/lmdbjava/Library.java b/src/main/java/org/lmdbjava/Library.java
index cea03bab..bffcb0b7 100644
--- a/src/main/java/org/lmdbjava/Library.java
+++ b/src/main/java/org/lmdbjava/Library.java
@@ -158,8 +158,8 @@ private static String extract(final String name) {
   /**
    * Structure to wrap a native <code>MDB_envinfo</code>. Not for external use.
    */
-  @SuppressWarnings({"checkstyle:typename", "checkstyle:visibilitymodifier",
-                     "checkstyle:membername"})
+  @SuppressWarnings({"checkstyle:TypeName", "checkstyle:VisibilityModifier",
+                     "checkstyle:MemberName"})
   public static final class MDB_envinfo extends Struct {
 
     public final Pointer f0_me_mapaddr;
@@ -183,8 +183,8 @@ public static final class MDB_envinfo extends Struct {
   /**
    * Structure to wrap a native <code>MDB_stat</code>. Not for external use.
    */
-  @SuppressWarnings({"checkstyle:typename", "checkstyle:visibilitymodifier",
-                     "checkstyle:membername"})
+  @SuppressWarnings({"checkstyle:TypeName", "checkstyle:VisibilityModifier",
+                     "checkstyle:MemberName"})
   public static final class MDB_stat extends Struct {
 
     public final u_int32_t f0_ms_psize;
@@ -218,7 +218,7 @@ public interface ComparatorCallback {
   /**
    * JNR API for MDB-defined C functions. Not for external use.
    */
-  @SuppressWarnings("checkstyle:methodname")
+  @SuppressWarnings("checkstyle:MethodName")
   public interface Lmdb {
 
     void mdb_cursor_close(@In Pointer cursor);
diff --git a/src/test/java/org/lmdbjava/CursorParamTest.java b/src/test/java/org/lmdbjava/CursorParamTest.java
index cb943857..a0a3260e 100644
--- a/src/test/java/org/lmdbjava/CursorParamTest.java
+++ b/src/test/java/org/lmdbjava/CursorParamTest.java
@@ -105,7 +105,7 @@ protected AbstractBufferRunner(final BufferProxy<T> proxy) {
       this.proxy = proxy;
     }
 
-    @SuppressWarnings("checkstyle:executablestatementcount")
+    @SuppressWarnings("checkstyle:ExecutableStatementCount")
     @Override
     public final void execute(final TemporaryFolder tmp) {
       try (Env<T> env = env(tmp)) {
diff --git a/src/test/java/org/lmdbjava/TutorialTest.java b/src/test/java/org/lmdbjava/TutorialTest.java
index 5ed75b17..b0a083d8 100644
--- a/src/test/java/org/lmdbjava/TutorialTest.java
+++ b/src/test/java/org/lmdbjava/TutorialTest.java
@@ -149,7 +149,7 @@ public void tutorial1() throws IOException {
    */
   @Test
   @SuppressWarnings({"ConvertToTryWithResources", "PMD.DoNotUseThreads",
-                     "checkstyle:executablestatementcount"})
+                     "checkstyle:ExecutableStatementCount"})
   public void tutorial2() throws IOException, InterruptedException {
     final Env<ByteBuffer> env = createSimpleEnv(tmp.newFolder());
     final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
@@ -224,7 +224,7 @@ public void tutorial2() throws IOException, InterruptedException {
    */
   @Test
   @SuppressWarnings({"ConvertToTryWithResources",
-                     "checkstyle:executablestatementcount"})
+                     "checkstyle:ExecutableStatementCount"})
   public void tutorial3() throws IOException {
     final Env<ByteBuffer> env = createSimpleEnv(tmp.newFolder());
     final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);

From e9d77207f58d993d9063e0389ccaa83d9247b8e5 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 1 Jun 2020 14:12:10 +1000
Subject: [PATCH 093/322] Remove unnecessary static analysis warning
 suppressions

---
 src/main/java/org/lmdbjava/ByteArrayProxy.java     | 1 -
 src/main/java/org/lmdbjava/ByteBufferProxy.java    | 3 +--
 src/main/java/org/lmdbjava/CursorIterable.java     | 1 -
 src/main/java/org/lmdbjava/DirectBufferProxy.java  | 1 -
 src/main/java/org/lmdbjava/KeyRangeType.java       | 2 --
 src/main/java/org/lmdbjava/Library.java            | 1 -
 src/main/java/org/lmdbjava/Verifier.java           | 1 -
 src/test/java/org/lmdbjava/CursorIterableTest.java | 1 -
 src/test/java/org/lmdbjava/CursorParamTest.java    | 1 -
 src/test/java/org/lmdbjava/CursorTest.java         | 3 ---
 src/test/java/org/lmdbjava/DbiTest.java            | 1 -
 src/test/java/org/lmdbjava/EnvTest.java            | 4 ----
 src/test/java/org/lmdbjava/KeyRangeTest.java       | 1 -
 src/test/java/org/lmdbjava/TutorialTest.java       | 7 ++-----
 src/test/java/org/lmdbjava/TxnTest.java            | 1 -
 15 files changed, 3 insertions(+), 26 deletions(-)

diff --git a/src/main/java/org/lmdbjava/ByteArrayProxy.java b/src/main/java/org/lmdbjava/ByteArrayProxy.java
index d6c13deb..51fee48c 100644
--- a/src/main/java/org/lmdbjava/ByteArrayProxy.java
+++ b/src/main/java/org/lmdbjava/ByteArrayProxy.java
@@ -50,7 +50,6 @@ private ByteArrayProxy() {
    * @param o2 right operand (required)
    * @return as specified by {@link Comparable} interface
    */
-  @SuppressWarnings("checkstyle:ReturnCount")
   public static int compareArrays(final byte[] o1, final byte[] o2) {
     requireNonNull(o1);
     requireNonNull(o2);
diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
index de6db50b..9d143808 100644
--- a/src/main/java/org/lmdbjava/ByteBufferProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -49,7 +49,6 @@
  * {@link #PROXY_OPTIMAL} or {@link #PROXY_SAFE} field when invoking
  * {@link Env#create(org.lmdbjava.BufferProxy)}.
  */
-@SuppressWarnings("PMD.AvoidCatchingGenericException")
 public final class ByteBufferProxy {
 
   /**
@@ -121,7 +120,7 @@ abstract static class AbstractByteBufferProxy extends BufferProxy<ByteBuffer> {
      * @param o2 right operand (required)
      * @return as specified by {@link Comparable} interface
      */
-    @SuppressWarnings({"checkstyle:ReturnCount", "PMD.CyclomaticComplexity"})
+    @SuppressWarnings("PMD.CyclomaticComplexity")
     public static int compareBuff(final ByteBuffer o1, final ByteBuffer o2) {
       requireNonNull(o1);
       requireNonNull(o2);
diff --git a/src/main/java/org/lmdbjava/CursorIterable.java b/src/main/java/org/lmdbjava/CursorIterable.java
index e02da2b6..1676a3db 100644
--- a/src/main/java/org/lmdbjava/CursorIterable.java
+++ b/src/main/java/org/lmdbjava/CursorIterable.java
@@ -92,7 +92,6 @@ public Iterator<KeyVal<T>> iterator() {
 
     return new Iterator<KeyVal<T>>() {
       @Override
-      @SuppressWarnings("checkstyle:ReturnCount")
       public boolean hasNext() {
         while (state != RELEASED && state != TERMINATED) {
           update();
diff --git a/src/main/java/org/lmdbjava/DirectBufferProxy.java b/src/main/java/org/lmdbjava/DirectBufferProxy.java
index d7aeaa57..adcbfb7f 100644
--- a/src/main/java/org/lmdbjava/DirectBufferProxy.java
+++ b/src/main/java/org/lmdbjava/DirectBufferProxy.java
@@ -66,7 +66,6 @@ private DirectBufferProxy() {
    * @param o2 right operand (required)
    * @return as specified by {@link Comparable} interface
    */
-  @SuppressWarnings("checkstyle:ReturnCount")
   public static int compareBuff(final DirectBuffer o1, final DirectBuffer o2) {
     requireNonNull(o1);
     requireNonNull(o2);
diff --git a/src/main/java/org/lmdbjava/KeyRangeType.java b/src/main/java/org/lmdbjava/KeyRangeType.java
index b286f72c..767bdeeb 100644
--- a/src/main/java/org/lmdbjava/KeyRangeType.java
+++ b/src/main/java/org/lmdbjava/KeyRangeType.java
@@ -320,7 +320,6 @@ public boolean isStopKeyRequired() {
    *
    * @return appropriate action in response to this buffer
    */
-  @SuppressWarnings("checkstyle:ReturnCount")
   CursorOp initialOp() {
     switch (this) {
       case FORWARD_ALL:
@@ -375,7 +374,6 @@ CursorOp initialOp() {
    * @param c      comparator (required)
    * @return response to this key
    */
-  @SuppressWarnings("checkstyle:ReturnCount")
   <T, C extends Comparator<T>> IteratorOp iteratorOp(final T start, final T stop,
                                                      final T buffer, final C c) {
     requireNonNull(c, "Comparator required");
diff --git a/src/main/java/org/lmdbjava/Library.java b/src/main/java/org/lmdbjava/Library.java
index bffcb0b7..dfecb2c4 100644
--- a/src/main/java/org/lmdbjava/Library.java
+++ b/src/main/java/org/lmdbjava/Library.java
@@ -127,7 +127,6 @@ final class Library {
   private Library() {
   }
 
-  @SuppressWarnings("PMD.AssignmentInOperand")
   @SuppressFBWarnings("OBL_UNSATISFIED_OBLIGATION") // Spotbugs issue #432
   private static String extract(final String name) {
     final String suffix = name.substring(name.lastIndexOf('.'));
diff --git a/src/main/java/org/lmdbjava/Verifier.java b/src/main/java/org/lmdbjava/Verifier.java
index 04b7a72c..b8dbc87b 100644
--- a/src/main/java/org/lmdbjava/Verifier.java
+++ b/src/main/java/org/lmdbjava/Verifier.java
@@ -163,7 +163,6 @@ public Long call() {
    * @param unit     units used to express the duration
    * @return number of database rows successfully verified
    */
-  @SuppressWarnings("PMD.DoNotUseThreads")
   public long runFor(final long duration, final TimeUnit unit) {
     final long deadline = System.currentTimeMillis() + unit.toMillis(duration);
     final ExecutorService es = Executors.newSingleThreadExecutor();
diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index ef6c18a6..f3e04d87 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -120,7 +120,6 @@ public void atMostTest() {
   }
 
   @Before
-  @SuppressWarnings("PMD.CloseResource")
   public void before() throws IOException {
     final File path = tmp.newFile();
     env = create()
diff --git a/src/test/java/org/lmdbjava/CursorParamTest.java b/src/test/java/org/lmdbjava/CursorParamTest.java
index a0a3260e..39475285 100644
--- a/src/test/java/org/lmdbjava/CursorParamTest.java
+++ b/src/test/java/org/lmdbjava/CursorParamTest.java
@@ -105,7 +105,6 @@ protected AbstractBufferRunner(final BufferProxy<T> proxy) {
       this.proxy = proxy;
     }
 
-    @SuppressWarnings("checkstyle:ExecutableStatementCount")
     @Override
     public final void execute(final TemporaryFolder tmp) {
       try (Env<T> env = env(tmp)) {
diff --git a/src/test/java/org/lmdbjava/CursorTest.java b/src/test/java/org/lmdbjava/CursorTest.java
index 3f376bd6..55af22ec 100644
--- a/src/test/java/org/lmdbjava/CursorTest.java
+++ b/src/test/java/org/lmdbjava/CursorTest.java
@@ -85,7 +85,6 @@ public void before() throws IOException {
   }
 
   @Test(expected = ClosedException.class)
-  @SuppressWarnings("PMD.CloseResource")
   public void closedCursorRejectsSubsequentGets() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
@@ -225,7 +224,6 @@ public void putMultipleWithoutMdbMultipleFlag() {
   }
 
   @Test
-  @SuppressWarnings("PMD.CloseResource")
   public void renewTxRo() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
 
@@ -256,7 +254,6 @@ public void renewTxRw() {
   }
 
   @Test
-  @SuppressWarnings("PMD.CloseResource")
   public void repeatedCloseCausesNotError() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index dbbcec6e..3db1eabf 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -146,7 +146,6 @@ public void dbOpenMaxDatabases() {
   }
 
   @Test
-  @SuppressWarnings("PMD.DoNotUseThreads")
   public void dbiWithComparatorThreadSafety() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, PROXY_OPTIMAL::compare,
                                            MDB_CREATE);
diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index 45fc1714..60e1dc27 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -101,7 +101,6 @@ public void cannotChangeMaxReadersAfterOpen() throws IOException {
   }
 
   @Test(expected = AlreadyClosedException.class)
-  @SuppressWarnings("PMD.CloseResource")
   public void cannotInfoOnceClosed() throws IOException {
     final File path = tmp.newFile();
     final Env<ByteBuffer> env = create()
@@ -131,7 +130,6 @@ public void cannotOverflowMapSize() {
   }
 
   @Test(expected = AlreadyClosedException.class)
-  @SuppressWarnings("PMD.CloseResource")
   public void cannotStatOnceClosed() throws IOException {
     final File path = tmp.newFile();
     final Env<ByteBuffer> env = create()
@@ -142,7 +140,6 @@ public void cannotStatOnceClosed() throws IOException {
   }
 
   @Test(expected = AlreadyClosedException.class)
-  @SuppressWarnings("PMD.CloseResource")
   public void cannotSyncOnceClosed() throws IOException {
     final File path = tmp.newFile();
     final Env<ByteBuffer> env = create()
@@ -230,7 +227,6 @@ public void copyFileRejectsExistingDestination() throws IOException {
   }
 
   @Test
-  @SuppressWarnings("PMD.CloseResource")
   public void createAsDirectory() throws IOException {
     final File path = tmp.newFolder();
     final Env<ByteBuffer> env = create()
diff --git a/src/test/java/org/lmdbjava/KeyRangeTest.java b/src/test/java/org/lmdbjava/KeyRangeTest.java
index 68fed292..d6556272 100644
--- a/src/test/java/org/lmdbjava/KeyRangeTest.java
+++ b/src/test/java/org/lmdbjava/KeyRangeTest.java
@@ -236,7 +236,6 @@ private static class FakeCursor {
     private static final int[] KEYS = new int[]{2, 4, 6, 8};
     private int position;
 
-    @SuppressWarnings("checkstyle:ReturnCount")
     Integer apply(final CursorOp op, final Integer startKey) {
       final Integer key;
       switch (op) {
diff --git a/src/test/java/org/lmdbjava/TutorialTest.java b/src/test/java/org/lmdbjava/TutorialTest.java
index b0a083d8..74e99c6d 100644
--- a/src/test/java/org/lmdbjava/TutorialTest.java
+++ b/src/test/java/org/lmdbjava/TutorialTest.java
@@ -64,7 +64,6 @@
  * need to install the LMDB system library yourself. 32-bit platforms are not
  * supported.
  */
-@SuppressWarnings("PMD.CloseResource")
 public final class TutorialTest {
 
   private static final String DB_NAME = "my DB";
@@ -148,8 +147,7 @@ public void tutorial1() throws IOException {
    * @throws InterruptedException if executor shutdown interrupted
    */
   @Test
-  @SuppressWarnings({"ConvertToTryWithResources", "PMD.DoNotUseThreads",
-                     "checkstyle:ExecutableStatementCount"})
+  @SuppressWarnings("ConvertToTryWithResources")
   public void tutorial2() throws IOException, InterruptedException {
     final Env<ByteBuffer> env = createSimpleEnv(tmp.newFolder());
     final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
@@ -223,8 +221,7 @@ public void tutorial2() throws IOException, InterruptedException {
    * @throws IOException if a path was unavailable for memory mapping
    */
   @Test
-  @SuppressWarnings({"ConvertToTryWithResources",
-                     "checkstyle:ExecutableStatementCount"})
+  @SuppressWarnings("ConvertToTryWithResources")
   public void tutorial3() throws IOException {
     final Env<ByteBuffer> env = createSimpleEnv(tmp.newFolder());
     final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
diff --git a/src/test/java/org/lmdbjava/TxnTest.java b/src/test/java/org/lmdbjava/TxnTest.java
index fe25d9a2..29dae897 100644
--- a/src/test/java/org/lmdbjava/TxnTest.java
+++ b/src/test/java/org/lmdbjava/TxnTest.java
@@ -271,7 +271,6 @@ public void txReadOnly() {
   }
 
   @Test
-  @SuppressWarnings("PMD.CloseResource")
   public void txReadWrite() {
     final Txn<ByteBuffer> txn = env.txnWrite();
     assertThat(txn.getParent(), is(nullValue()));

From 25fe08af39e909dcbbbea1be651eb023bc559f90 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 1 Jun 2020 15:13:20 +1000
Subject: [PATCH 094/322] Update import ordering to reflect new standard

---
 src/main/java/org/lmdbjava/BufferProxy.java   |  1 +
 .../java/org/lmdbjava/ByteArrayProxy.java     |  6 ++-
 src/main/java/org/lmdbjava/ByteBufProxy.java  |  6 ++-
 .../java/org/lmdbjava/ByteBufferProxy.java    | 12 +++--
 src/main/java/org/lmdbjava/Cursor.java        |  5 +-
 .../java/org/lmdbjava/CursorIterable.java     |  8 +--
 src/main/java/org/lmdbjava/Dbi.java           | 20 +++----
 .../java/org/lmdbjava/DirectBufferProxy.java  |  6 ++-
 src/main/java/org/lmdbjava/Env.java           | 22 ++++----
 src/main/java/org/lmdbjava/KeyRangeType.java  |  3 +-
 src/main/java/org/lmdbjava/KeyVal.java        |  5 +-
 src/main/java/org/lmdbjava/Library.java       | 16 +++---
 src/main/java/org/lmdbjava/Meta.java          |  3 +-
 .../java/org/lmdbjava/ResultCodeMapper.java   |  3 +-
 src/main/java/org/lmdbjava/Txn.java           |  6 ++-
 src/main/java/org/lmdbjava/UnsafeAccess.java  |  2 +
 src/main/java/org/lmdbjava/Verifier.java      |  7 +--
 .../org/lmdbjava/ByteBufferProxyTest.java     | 24 +++++----
 .../java/org/lmdbjava/ComparatorTest.java     | 26 +++++-----
 .../java/org/lmdbjava/CursorIterableTest.java | 36 +++++++------
 .../java/org/lmdbjava/CursorParamTest.java    | 28 +++++-----
 src/test/java/org/lmdbjava/CursorTest.java    | 20 +++----
 src/test/java/org/lmdbjava/DbiTest.java       | 52 ++++++++++---------
 src/test/java/org/lmdbjava/EnvTest.java       | 26 +++++-----
 src/test/java/org/lmdbjava/KeyRangeTest.java  | 12 +++--
 src/test/java/org/lmdbjava/LibraryTest.java   |  5 +-
 .../java/org/lmdbjava/MaskedFlagTest.java     |  3 +-
 src/test/java/org/lmdbjava/MetaTest.java      |  5 +-
 .../org/lmdbjava/ResultCodeMapperTest.java    | 12 +++--
 src/test/java/org/lmdbjava/TestUtils.java     |  6 ++-
 src/test/java/org/lmdbjava/TutorialTest.java  | 24 +++++----
 src/test/java/org/lmdbjava/TxnTest.java       | 38 +++++++-------
 src/test/java/org/lmdbjava/VerifierTest.java  | 10 ++--
 33 files changed, 257 insertions(+), 201 deletions(-)

diff --git a/src/main/java/org/lmdbjava/BufferProxy.java b/src/main/java/org/lmdbjava/BufferProxy.java
index 4f3536ab..0fe73f3f 100644
--- a/src/main/java/org/lmdbjava/BufferProxy.java
+++ b/src/main/java/org/lmdbjava/BufferProxy.java
@@ -21,6 +21,7 @@
 package org.lmdbjava;
 
 import static java.lang.Long.BYTES;
+
 import jnr.ffi.Pointer;
 
 /**
diff --git a/src/main/java/org/lmdbjava/ByteArrayProxy.java b/src/main/java/org/lmdbjava/ByteArrayProxy.java
index 51fee48c..dc964bcc 100644
--- a/src/main/java/org/lmdbjava/ByteArrayProxy.java
+++ b/src/main/java/org/lmdbjava/ByteArrayProxy.java
@@ -20,11 +20,13 @@
 
 package org.lmdbjava;
 
-import java.util.Arrays;
 import static java.util.Objects.requireNonNull;
+import static org.lmdbjava.Library.RUNTIME;
+
+import java.util.Arrays;
+
 import jnr.ffi.Pointer;
 import jnr.ffi.provider.MemoryManager;
-import static org.lmdbjava.Library.RUNTIME;
 
 /**
  * Byte array proxy.
diff --git a/src/main/java/org/lmdbjava/ByteBufProxy.java b/src/main/java/org/lmdbjava/ByteBufProxy.java
index 042416d8..ca580363 100644
--- a/src/main/java/org/lmdbjava/ByteBufProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufProxy.java
@@ -20,14 +20,16 @@
 
 package org.lmdbjava;
 
-import io.netty.buffer.ByteBuf;
 import static io.netty.buffer.PooledByteBufAllocator.DEFAULT;
 import static java.lang.Class.forName;
 import static java.lang.ThreadLocal.withInitial;
+import static org.lmdbjava.UnsafeAccess.UNSAFE;
+
 import java.lang.reflect.Field;
 import java.util.ArrayDeque;
+
+import io.netty.buffer.ByteBuf;
 import jnr.ffi.Pointer;
-import static org.lmdbjava.UnsafeAccess.UNSAFE;
 
 /**
  * A buffer proxy backed by Netty's {@link ByteBuf}.
diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
index 9d143808..9d1b0f81 100644
--- a/src/main/java/org/lmdbjava/ByteBufferProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -22,18 +22,20 @@
 
 import static java.lang.Long.reverseBytes;
 import static java.lang.ThreadLocal.withInitial;
-import java.lang.reflect.Field;
-import java.nio.Buffer;
-import java.nio.ByteBuffer;
 import static java.nio.ByteBuffer.allocateDirect;
 import static java.nio.ByteOrder.BIG_ENDIAN;
 import static java.nio.ByteOrder.LITTLE_ENDIAN;
-import java.util.ArrayDeque;
 import static java.util.Objects.requireNonNull;
-import jnr.ffi.Pointer;
 import static org.lmdbjava.Env.SHOULD_CHECK;
 import static org.lmdbjava.UnsafeAccess.UNSAFE;
 
+import java.lang.reflect.Field;
+import java.nio.Buffer;
+import java.nio.ByteBuffer;
+import java.util.ArrayDeque;
+
+import jnr.ffi.Pointer;
+
 /**
  * {@link ByteBuffer}-based proxy.
  *
diff --git a/src/main/java/org/lmdbjava/Cursor.java b/src/main/java/org/lmdbjava/Cursor.java
index 2ae2140d..5dac5b58 100644
--- a/src/main/java/org/lmdbjava/Cursor.java
+++ b/src/main/java/org/lmdbjava/Cursor.java
@@ -21,8 +21,6 @@
 package org.lmdbjava;
 
 import static java.util.Objects.requireNonNull;
-import jnr.ffi.Pointer;
-import jnr.ffi.byref.NativeLongByReference;
 import static org.lmdbjava.Dbi.KeyExistsException.MDB_KEYEXIST;
 import static org.lmdbjava.Dbi.KeyNotFoundException.MDB_NOTFOUND;
 import static org.lmdbjava.Env.SHOULD_CHECK;
@@ -39,6 +37,9 @@
 import static org.lmdbjava.SeekOp.MDB_NEXT;
 import static org.lmdbjava.SeekOp.MDB_PREV;
 
+import jnr.ffi.Pointer;
+import jnr.ffi.byref.NativeLongByReference;
+
 /**
  * A cursor handle.
  *
diff --git a/src/main/java/org/lmdbjava/CursorIterable.java b/src/main/java/org/lmdbjava/CursorIterable.java
index 1676a3db..19729443 100644
--- a/src/main/java/org/lmdbjava/CursorIterable.java
+++ b/src/main/java/org/lmdbjava/CursorIterable.java
@@ -20,15 +20,17 @@
 
 package org.lmdbjava;
 
-import java.util.Comparator;
-import java.util.Iterator;
-import java.util.NoSuchElementException;
 import static org.lmdbjava.CursorIterable.State.RELEASED;
 import static org.lmdbjava.CursorIterable.State.REQUIRES_INITIAL_OP;
 import static org.lmdbjava.CursorIterable.State.REQUIRES_ITERATOR_OP;
 import static org.lmdbjava.CursorIterable.State.REQUIRES_NEXT_OP;
 import static org.lmdbjava.CursorIterable.State.TERMINATED;
 import static org.lmdbjava.GetOp.MDB_SET_RANGE;
+
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
 import org.lmdbjava.KeyRangeType.CursorOp;
 import org.lmdbjava.KeyRangeType.IteratorOp;
 
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index 2106687d..62fbc0f2 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -20,23 +20,14 @@
 
 package org.lmdbjava;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Comparator;
-import java.util.List;
 import static java.util.Objects.requireNonNull;
 import static jnr.ffi.Memory.allocateDirect;
 import static jnr.ffi.NativeType.ADDRESS;
-import jnr.ffi.Pointer;
-import jnr.ffi.byref.IntByReference;
-import jnr.ffi.byref.PointerByReference;
 import static org.lmdbjava.Dbi.KeyExistsException.MDB_KEYEXIST;
 import static org.lmdbjava.Dbi.KeyNotFoundException.MDB_NOTFOUND;
 import static org.lmdbjava.Env.SHOULD_CHECK;
 import static org.lmdbjava.KeyRange.all;
-import org.lmdbjava.Library.ComparatorCallback;
 import static org.lmdbjava.Library.LIB;
-import org.lmdbjava.Library.MDB_stat;
 import static org.lmdbjava.Library.RUNTIME;
 import static org.lmdbjava.MaskedFlag.isSet;
 import static org.lmdbjava.MaskedFlag.mask;
@@ -45,6 +36,17 @@
 import static org.lmdbjava.PutFlags.MDB_RESERVE;
 import static org.lmdbjava.ResultCodeMapper.checkRc;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+
+import jnr.ffi.Pointer;
+import jnr.ffi.byref.IntByReference;
+import jnr.ffi.byref.PointerByReference;
+import org.lmdbjava.Library.ComparatorCallback;
+import org.lmdbjava.Library.MDB_stat;
+
 /**
  * LMDB Database.
  *
diff --git a/src/main/java/org/lmdbjava/DirectBufferProxy.java b/src/main/java/org/lmdbjava/DirectBufferProxy.java
index adcbfb7f..af911afa 100644
--- a/src/main/java/org/lmdbjava/DirectBufferProxy.java
+++ b/src/main/java/org/lmdbjava/DirectBufferProxy.java
@@ -21,16 +21,18 @@
 package org.lmdbjava;
 
 import static java.lang.ThreadLocal.withInitial;
-import java.nio.ByteBuffer;
 import static java.nio.ByteBuffer.allocateDirect;
 import static java.nio.ByteOrder.BIG_ENDIAN;
 import static java.util.Objects.requireNonNull;
+import static org.lmdbjava.UnsafeAccess.UNSAFE;
+
+import java.nio.ByteBuffer;
+
 import jnr.ffi.Pointer;
 import org.agrona.DirectBuffer;
 import org.agrona.MutableDirectBuffer;
 import org.agrona.concurrent.OneToOneConcurrentArrayQueue;
 import org.agrona.concurrent.UnsafeBuffer;
-import static org.lmdbjava.UnsafeAccess.UNSAFE;
 
 /**
  * A buffer proxy backed by Agrona's {@link DirectBuffer}.
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 765c1565..7634a342 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -20,29 +20,31 @@
 
 package org.lmdbjava;
 
-import java.io.File;
 import static java.lang.Boolean.getBoolean;
-import java.nio.ByteBuffer;
 import static java.nio.charset.StandardCharsets.UTF_8;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.List;
 import static java.util.Objects.requireNonNull;
-import jnr.ffi.Pointer;
-import jnr.ffi.byref.PointerByReference;
 import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
 import static org.lmdbjava.EnvFlags.MDB_RDONLY_ENV;
 import static org.lmdbjava.Library.LIB;
-import org.lmdbjava.Library.MDB_envinfo;
-import org.lmdbjava.Library.MDB_stat;
 import static org.lmdbjava.Library.RUNTIME;
 import static org.lmdbjava.MaskedFlag.isSet;
 import static org.lmdbjava.MaskedFlag.mask;
 import static org.lmdbjava.ResultCodeMapper.checkRc;
 import static org.lmdbjava.TxnFlags.MDB_RDONLY_TXN;
 
+import java.io.File;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+import jnr.ffi.Pointer;
+import jnr.ffi.byref.PointerByReference;
+import org.lmdbjava.Library.MDB_envinfo;
+import org.lmdbjava.Library.MDB_stat;
+
 /**
  * LMDB environment.
  *
diff --git a/src/main/java/org/lmdbjava/KeyRangeType.java b/src/main/java/org/lmdbjava/KeyRangeType.java
index 767bdeeb..156daf99 100644
--- a/src/main/java/org/lmdbjava/KeyRangeType.java
+++ b/src/main/java/org/lmdbjava/KeyRangeType.java
@@ -20,7 +20,6 @@
 
 package org.lmdbjava;
 
-import java.util.Comparator;
 import static java.util.Objects.requireNonNull;
 import static org.lmdbjava.KeyRangeType.CursorOp.FIRST;
 import static org.lmdbjava.KeyRangeType.CursorOp.GET_START_KEY;
@@ -32,6 +31,8 @@
 import static org.lmdbjava.KeyRangeType.IteratorOp.RELEASE;
 import static org.lmdbjava.KeyRangeType.IteratorOp.TERMINATE;
 
+import java.util.Comparator;
+
 /**
  * Key range type.
  *
diff --git a/src/main/java/org/lmdbjava/KeyVal.java b/src/main/java/org/lmdbjava/KeyVal.java
index 6bfd4546..481d34ed 100644
--- a/src/main/java/org/lmdbjava/KeyVal.java
+++ b/src/main/java/org/lmdbjava/KeyVal.java
@@ -21,12 +21,13 @@
 package org.lmdbjava;
 
 import static java.util.Objects.requireNonNull;
-import jnr.ffi.Pointer;
-import jnr.ffi.provider.MemoryManager;
 import static org.lmdbjava.BufferProxy.MDB_VAL_STRUCT_SIZE;
 import static org.lmdbjava.BufferProxy.STRUCT_FIELD_OFFSET_SIZE;
 import static org.lmdbjava.Library.RUNTIME;
 
+import jnr.ffi.Pointer;
+import jnr.ffi.provider.MemoryManager;
+
 /**
  * Represents off-heap memory holding a key and value pair.
  *
diff --git a/src/main/java/org/lmdbjava/Library.java b/src/main/java/org/lmdbjava/Library.java
index dfecb2c4..18d3e717 100644
--- a/src/main/java/org/lmdbjava/Library.java
+++ b/src/main/java/org/lmdbjava/Library.java
@@ -20,22 +20,24 @@
 
 package org.lmdbjava;
 
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-import java.io.File;
 import static java.io.File.createTempFile;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
 import static java.lang.Boolean.getBoolean;
 import static java.lang.System.getProperty;
 import static java.lang.Thread.currentThread;
-import java.nio.file.Files;
 import static java.util.Locale.ENGLISH;
 import static java.util.Objects.nonNull;
 import static java.util.Objects.requireNonNull;
 import static jnr.ffi.LibraryLoader.create;
-import jnr.ffi.Pointer;
 import static jnr.ffi.Runtime.getRuntime;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.nio.file.Files;
+
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+import jnr.ffi.Pointer;
 import jnr.ffi.Struct;
 import jnr.ffi.annotations.Delegate;
 import jnr.ffi.annotations.In;
diff --git a/src/main/java/org/lmdbjava/Meta.java b/src/main/java/org/lmdbjava/Meta.java
index 46807f3c..699b182d 100644
--- a/src/main/java/org/lmdbjava/Meta.java
+++ b/src/main/java/org/lmdbjava/Meta.java
@@ -20,9 +20,10 @@
 
 package org.lmdbjava;
 
-import jnr.ffi.byref.IntByReference;
 import static org.lmdbjava.Library.LIB;
 
+import jnr.ffi.byref.IntByReference;
+
 /**
  * LMDB metadata functions.
  */
diff --git a/src/main/java/org/lmdbjava/ResultCodeMapper.java b/src/main/java/org/lmdbjava/ResultCodeMapper.java
index 63310fcd..ed209f41 100644
--- a/src/main/java/org/lmdbjava/ResultCodeMapper.java
+++ b/src/main/java/org/lmdbjava/ResultCodeMapper.java
@@ -20,9 +20,10 @@
 
 package org.lmdbjava;
 
+import static jnr.constants.ConstantSet.getConstantSet;
+
 import jnr.constants.Constant;
 import jnr.constants.ConstantSet;
-import static jnr.constants.ConstantSet.getConstantSet;
 import org.lmdbjava.Txn.BadException;
 import org.lmdbjava.Txn.BadReaderLockException;
 import org.lmdbjava.Txn.TxFullException;
diff --git a/src/main/java/org/lmdbjava/Txn.java b/src/main/java/org/lmdbjava/Txn.java
index 67c84343..dfdfc60a 100644
--- a/src/main/java/org/lmdbjava/Txn.java
+++ b/src/main/java/org/lmdbjava/Txn.java
@@ -20,10 +20,8 @@
 
 package org.lmdbjava;
 
-import java.util.Comparator;
 import static jnr.ffi.Memory.allocateDirect;
 import static jnr.ffi.NativeType.ADDRESS;
-import jnr.ffi.Pointer;
 import static org.lmdbjava.Library.LIB;
 import static org.lmdbjava.Library.RUNTIME;
 import static org.lmdbjava.MaskedFlag.isSet;
@@ -35,6 +33,10 @@
 import static org.lmdbjava.Txn.State.RESET;
 import static org.lmdbjava.TxnFlags.MDB_RDONLY_TXN;
 
+import java.util.Comparator;
+
+import jnr.ffi.Pointer;
+
 /**
  * LMDB transaction.
  *
diff --git a/src/main/java/org/lmdbjava/UnsafeAccess.java b/src/main/java/org/lmdbjava/UnsafeAccess.java
index 92d1df5e..7114e34d 100644
--- a/src/main/java/org/lmdbjava/UnsafeAccess.java
+++ b/src/main/java/org/lmdbjava/UnsafeAccess.java
@@ -21,7 +21,9 @@
 package org.lmdbjava;
 
 import static java.lang.Boolean.getBoolean;
+
 import java.lang.reflect.Field;
+
 import sun.misc.Unsafe;
 
 /**
diff --git a/src/main/java/org/lmdbjava/Verifier.java b/src/main/java/org/lmdbjava/Verifier.java
index b8dbc87b..9bc7b89e 100644
--- a/src/main/java/org/lmdbjava/Verifier.java
+++ b/src/main/java/org/lmdbjava/Verifier.java
@@ -20,11 +20,13 @@
 
 package org.lmdbjava;
 
-import java.nio.ByteBuffer;
 import static java.nio.ByteOrder.BIG_ENDIAN;
+import static java.util.Objects.requireNonNull;
+import static org.lmdbjava.DbiFlags.MDB_CREATE;
+
+import java.nio.ByteBuffer;
 import java.util.ArrayList;
 import java.util.List;
-import static java.util.Objects.requireNonNull;
 import java.util.Random;
 import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutionException;
@@ -34,7 +36,6 @@
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.zip.CRC32;
-import static org.lmdbjava.DbiFlags.MDB_CREATE;
 
 /**
  * Verifies correct operation of LmdbJava in a given environment.
diff --git a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
index 9399eada..ba882281 100644
--- a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
+++ b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
@@ -20,38 +20,40 @@
 
 package org.lmdbjava;
 
-import java.io.File;
-import java.io.IOException;
 import static java.lang.Integer.BYTES;
-import java.lang.reflect.Field;
-import java.nio.ByteBuffer;
 import static java.nio.ByteBuffer.allocate;
 import static java.nio.ByteBuffer.allocateDirect;
 import static java.nio.ByteOrder.BIG_ENDIAN;
 import static java.nio.ByteOrder.LITTLE_ENDIAN;
-import jnr.ffi.Pointer;
-import jnr.ffi.provider.MemoryManager;
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.CoreMatchers.notNullValue;
 import static org.hamcrest.CoreMatchers.startsWith;
 import static org.hamcrest.MatcherAssert.assertThat;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
 import static org.lmdbjava.BufferProxy.MDB_VAL_STRUCT_SIZE;
 import static org.lmdbjava.ByteBufferProxy.AbstractByteBufferProxy.findField;
-import org.lmdbjava.ByteBufferProxy.BufferMustBeDirectException;
 import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
 import static org.lmdbjava.ByteBufferProxy.PROXY_SAFE;
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
-import org.lmdbjava.Env.ReadersFullException;
 import static org.lmdbjava.Env.create;
 import static org.lmdbjava.Library.RUNTIME;
 import static org.lmdbjava.TestUtils.DB_1;
 import static org.lmdbjava.TestUtils.invokePrivateConstructor;
 import static org.lmdbjava.UnsafeAccess.ALLOW_UNSAFE;
 
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.Field;
+import java.nio.ByteBuffer;
+
+import jnr.ffi.Pointer;
+import jnr.ffi.provider.MemoryManager;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.lmdbjava.ByteBufferProxy.BufferMustBeDirectException;
+import org.lmdbjava.Env.ReadersFullException;
+
 /**
  * Test {@link ByteBufferProxy}.
  */
diff --git a/src/test/java/org/lmdbjava/ComparatorTest.java b/src/test/java/org/lmdbjava/ComparatorTest.java
index 1f5b8f9a..e8499838 100644
--- a/src/test/java/org/lmdbjava/ComparatorTest.java
+++ b/src/test/java/org/lmdbjava/ComparatorTest.java
@@ -20,22 +20,10 @@
 
 package org.lmdbjava;
 
-import com.google.common.primitives.SignedBytes;
-import com.google.common.primitives.UnsignedBytes;
-import io.netty.buffer.ByteBuf;
 import static io.netty.buffer.PooledByteBufAllocator.DEFAULT;
-import java.nio.ByteBuffer;
 import static java.nio.charset.StandardCharsets.US_ASCII;
-import java.util.Comparator;
-import org.agrona.DirectBuffer;
-import org.agrona.concurrent.UnsafeBuffer;
 import static org.hamcrest.core.Is.is;
 import static org.junit.Assert.assertThat;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameter;
-import org.junit.runners.Parameterized.Parameters;
 import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
 import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
 import static org.lmdbjava.ComparatorTest.ComparatorResult.EQUAL_TO;
@@ -44,6 +32,20 @@
 import static org.lmdbjava.ComparatorTest.ComparatorResult.get;
 import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
 
+import java.nio.ByteBuffer;
+import java.util.Comparator;
+
+import com.google.common.primitives.SignedBytes;
+import com.google.common.primitives.UnsignedBytes;
+import io.netty.buffer.ByteBuf;
+import org.agrona.DirectBuffer;
+import org.agrona.concurrent.UnsafeBuffer;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
 /**
  * Tests comparator functions are consistent across buffers.
  */
diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index f3e04d87..cc6cd0b6 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -20,28 +20,11 @@
 
 package org.lmdbjava;
 
-import com.google.common.primitives.UnsignedBytes;
 import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
-import java.io.File;
-import java.io.IOException;
-import java.nio.ByteBuffer;
-import java.util.ArrayList;
 import static java.util.Arrays.asList;
-import java.util.Comparator;
-import java.util.Deque;
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.NoSuchElementException;
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.hasSize;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
-import org.lmdbjava.CursorIterable.KeyVal;
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
 import static org.lmdbjava.Env.create;
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
@@ -68,6 +51,25 @@
 import static org.lmdbjava.TestUtils.POSIX_MODE;
 import static org.lmdbjava.TestUtils.bb;
 
+import java.io.File;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.Deque;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.NoSuchElementException;
+
+import com.google.common.primitives.UnsignedBytes;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.lmdbjava.CursorIterable.KeyVal;
+
 /**
  * Test {@link CursorIterable}.
  */
diff --git a/src/test/java/org/lmdbjava/CursorParamTest.java b/src/test/java/org/lmdbjava/CursorParamTest.java
index 39475285..c105aae7 100644
--- a/src/test/java/org/lmdbjava/CursorParamTest.java
+++ b/src/test/java/org/lmdbjava/CursorParamTest.java
@@ -21,24 +21,11 @@
 package org.lmdbjava;
 
 import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
-import io.netty.buffer.ByteBuf;
-import java.io.File;
-import java.io.IOException;
 import static java.lang.Long.BYTES;
-import java.nio.ByteBuffer;
 import static java.nio.charset.StandardCharsets.UTF_8;
-import org.agrona.DirectBuffer;
-import org.agrona.MutableDirectBuffer;
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.collection.IsEmptyCollection.empty;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameter;
-import org.junit.runners.Parameterized.Parameters;
 import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
 import static org.lmdbjava.ByteBufProxy.PROXY_NETTY;
 import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
@@ -61,6 +48,21 @@
 import static org.lmdbjava.TestUtils.mdb;
 import static org.lmdbjava.TestUtils.nb;
 
+import java.io.File;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+import io.netty.buffer.ByteBuf;
+import org.agrona.DirectBuffer;
+import org.agrona.MutableDirectBuffer;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameter;
+import org.junit.runners.Parameterized.Parameters;
+
 /**
  * Test {@link Cursor} with different buffer implementations.
  */
diff --git a/src/test/java/org/lmdbjava/CursorTest.java b/src/test/java/org/lmdbjava/CursorTest.java
index 55af22ec..137732f5 100644
--- a/src/test/java/org/lmdbjava/CursorTest.java
+++ b/src/test/java/org/lmdbjava/CursorTest.java
@@ -21,23 +21,14 @@
 package org.lmdbjava;
 
 import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
-import java.io.File;
-import java.io.IOException;
 import static java.lang.Long.BYTES;
 import static java.lang.Long.MIN_VALUE;
-import java.nio.ByteBuffer;
 import static java.nio.ByteBuffer.allocateDirect;
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.MatcherAssert.assertThat;
-import org.junit.After;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
 import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
-import org.lmdbjava.Cursor.ClosedException;
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
 import static org.lmdbjava.DbiFlags.MDB_DUPFIXED;
 import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
@@ -52,6 +43,17 @@
 import static org.lmdbjava.TestUtils.DB_1;
 import static org.lmdbjava.TestUtils.POSIX_MODE;
 import static org.lmdbjava.TestUtils.bb;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.lmdbjava.Cursor.ClosedException;
 import org.lmdbjava.Txn.NotReadyException;
 import org.lmdbjava.Txn.ReadOnlyRequiredException;
 
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 3db1eabf..b9bf453c 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -21,64 +21,66 @@
 package org.lmdbjava;
 
 import static com.jakewharton.byteunits.BinaryByteUnit.MEBIBYTES;
-import java.io.File;
-import java.io.IOException;
 import static java.lang.Long.MAX_VALUE;
 import static java.lang.System.getProperty;
-import java.nio.ByteBuffer;
 import static java.nio.ByteBuffer.allocateDirect;
 import static java.nio.charset.StandardCharsets.UTF_8;
-import java.util.ArrayList;
 import static java.util.Collections.nCopies;
-import java.util.Comparator;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Random;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.Future;
 import static java.util.concurrent.TimeUnit.SECONDS;
-import java.util.concurrent.TimeoutException;
-import java.util.concurrent.atomic.AtomicBoolean;
 import static java.util.stream.Collectors.toList;
 import static java.util.stream.IntStream.range;
-import org.agrona.concurrent.UnsafeBuffer;
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.CoreMatchers.notNullValue;
 import static org.hamcrest.CoreMatchers.nullValue;
 import static org.hamcrest.MatcherAssert.assertThat;
-import org.hamcrest.Matchers;
 import static org.hamcrest.Matchers.containsInAnyOrder;
 import static org.hamcrest.Matchers.hasSize;
 import static org.hamcrest.collection.IsEmptyCollection.empty;
-import org.junit.After;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
 import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
 import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
-import org.lmdbjava.CursorIterable.KeyVal;
-import org.lmdbjava.Dbi.DbFullException;
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
 import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
 import static org.lmdbjava.DbiFlags.MDB_REVERSEKEY;
-import org.lmdbjava.Env.MapFullException;
 import static org.lmdbjava.Env.create;
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
 import static org.lmdbjava.GetOp.MDB_SET_KEY;
 import static org.lmdbjava.KeyRange.atMost;
-import org.lmdbjava.LmdbNativeException.ConstantDerivedException;
 import static org.lmdbjava.PutFlags.MDB_NODUPDATA;
 import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
 import static org.lmdbjava.TestUtils.DB_1;
 import static org.lmdbjava.TestUtils.ba;
 import static org.lmdbjava.TestUtils.bb;
 
+import java.io.File;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.agrona.concurrent.UnsafeBuffer;
+import org.hamcrest.Matchers;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.lmdbjava.CursorIterable.KeyVal;
+import org.lmdbjava.Dbi.DbFullException;
+import org.lmdbjava.Env.MapFullException;
+import org.lmdbjava.LmdbNativeException.ConstantDerivedException;
+
 /**
  * Test {@link Dbi}.
  */
diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index 60e1dc27..3e9ece95 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -21,33 +21,35 @@
 package org.lmdbjava;
 
 import static com.jakewharton.byteunits.BinaryByteUnit.MEBIBYTES;
-import java.io.File;
-import java.io.IOException;
-import java.nio.ByteBuffer;
 import static java.nio.ByteBuffer.allocateDirect;
-import java.util.Random;
 import static org.hamcrest.CoreMatchers.containsString;
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.CoreMatchers.notNullValue;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.greaterThan;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
 import static org.lmdbjava.CopyFlags.MDB_CP_COMPACT;
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
-import org.lmdbjava.Env.AlreadyClosedException;
-import org.lmdbjava.Env.AlreadyOpenException;
-import org.lmdbjava.Env.Builder;
 import static org.lmdbjava.Env.Builder.MAX_READERS_DEFAULT;
-import org.lmdbjava.Env.InvalidCopyDestination;
-import org.lmdbjava.Env.MapFullException;
 import static org.lmdbjava.Env.create;
 import static org.lmdbjava.Env.open;
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
 import static org.lmdbjava.EnvFlags.MDB_RDONLY_ENV;
 import static org.lmdbjava.TestUtils.DB_1;
 import static org.lmdbjava.TestUtils.bb;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.Random;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.lmdbjava.Env.AlreadyClosedException;
+import org.lmdbjava.Env.AlreadyOpenException;
+import org.lmdbjava.Env.Builder;
+import org.lmdbjava.Env.InvalidCopyDestination;
+import org.lmdbjava.Env.MapFullException;
 import org.lmdbjava.Txn.BadReaderLockException;
 
 /**
diff --git a/src/test/java/org/lmdbjava/KeyRangeTest.java b/src/test/java/org/lmdbjava/KeyRangeTest.java
index d6556272..0cb3d1f5 100644
--- a/src/test/java/org/lmdbjava/KeyRangeTest.java
+++ b/src/test/java/org/lmdbjava/KeyRangeTest.java
@@ -20,13 +20,9 @@
 
 package org.lmdbjava;
 
-import java.util.ArrayList;
-import java.util.List;
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.CoreMatchers.nullValue;
 import static org.hamcrest.MatcherAssert.assertThat;
-import org.junit.Before;
-import org.junit.Test;
 import static org.lmdbjava.KeyRange.all;
 import static org.lmdbjava.KeyRange.allBackward;
 import static org.lmdbjava.KeyRange.atLeast;
@@ -45,9 +41,15 @@
 import static org.lmdbjava.KeyRange.openBackward;
 import static org.lmdbjava.KeyRange.openClosed;
 import static org.lmdbjava.KeyRange.openClosedBackward;
+import static org.lmdbjava.KeyRangeType.IteratorOp.TERMINATE;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Before;
+import org.junit.Test;
 import org.lmdbjava.KeyRangeType.CursorOp;
 import org.lmdbjava.KeyRangeType.IteratorOp;
-import static org.lmdbjava.KeyRangeType.IteratorOp.TERMINATE;
 
 /**
  * Test {@link KeyRange}.
diff --git a/src/test/java/org/lmdbjava/LibraryTest.java b/src/test/java/org/lmdbjava/LibraryTest.java
index 35523272..08c6ea9f 100644
--- a/src/test/java/org/lmdbjava/LibraryTest.java
+++ b/src/test/java/org/lmdbjava/LibraryTest.java
@@ -23,11 +23,12 @@
 import static java.lang.Long.BYTES;
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.MatcherAssert.assertThat;
-import org.junit.Test;
-import org.lmdbjava.Library.MDB_envinfo;
 import static org.lmdbjava.Library.RUNTIME;
 import static org.lmdbjava.TestUtils.invokePrivateConstructor;
 
+import org.junit.Test;
+import org.lmdbjava.Library.MDB_envinfo;
+
 /**
  * Test {@link Library}.
  */
diff --git a/src/test/java/org/lmdbjava/MaskedFlagTest.java b/src/test/java/org/lmdbjava/MaskedFlagTest.java
index e5a63952..34acb3f8 100644
--- a/src/test/java/org/lmdbjava/MaskedFlagTest.java
+++ b/src/test/java/org/lmdbjava/MaskedFlagTest.java
@@ -23,13 +23,14 @@
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.arrayWithSize;
-import org.junit.Test;
 import static org.lmdbjava.EnvFlags.MDB_FIXEDMAP;
 import static org.lmdbjava.EnvFlags.MDB_NOSYNC;
 import static org.lmdbjava.EnvFlags.MDB_RDONLY_ENV;
 import static org.lmdbjava.MaskedFlag.isSet;
 import static org.lmdbjava.MaskedFlag.mask;
 
+import org.junit.Test;
+
 /**
  * Test {@link MaskedFlag}.
  */
diff --git a/src/test/java/org/lmdbjava/MetaTest.java b/src/test/java/org/lmdbjava/MetaTest.java
index 18967fec..d20f6510 100644
--- a/src/test/java/org/lmdbjava/MetaTest.java
+++ b/src/test/java/org/lmdbjava/MetaTest.java
@@ -24,12 +24,13 @@
 import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.CoreMatchers.nullValue;
 import static org.hamcrest.MatcherAssert.assertThat;
-import org.junit.Test;
 import static org.lmdbjava.LmdbNativeException.PageCorruptedException.MDB_CORRUPTED;
-import org.lmdbjava.Meta.Version;
 import static org.lmdbjava.Meta.error;
 import static org.lmdbjava.TestUtils.invokePrivateConstructor;
 
+import org.junit.Test;
+import org.lmdbjava.Meta.Version;
+
 /**
  * Test {@link Meta}.
  */
diff --git a/src/test/java/org/lmdbjava/ResultCodeMapperTest.java b/src/test/java/org/lmdbjava/ResultCodeMapperTest.java
index 5d915f84..f2382021 100644
--- a/src/test/java/org/lmdbjava/ResultCodeMapperTest.java
+++ b/src/test/java/org/lmdbjava/ResultCodeMapperTest.java
@@ -21,17 +21,21 @@
 package org.lmdbjava;
 
 import static java.lang.Integer.MAX_VALUE;
-import java.util.HashSet;
-import java.util.Set;
 import static org.hamcrest.CoreMatchers.containsString;
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.CoreMatchers.notNullValue;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.hasSize;
 import static org.junit.Assert.fail;
+import static org.lmdbjava.Cursor.FullException.MDB_CURSOR_FULL;
+import static org.lmdbjava.ResultCodeMapper.checkRc;
+import static org.lmdbjava.TestUtils.invokePrivateConstructor;
+
+import java.util.HashSet;
+import java.util.Set;
+
 import org.junit.Test;
 import org.lmdbjava.Cursor.FullException;
-import static org.lmdbjava.Cursor.FullException.MDB_CURSOR_FULL;
 import org.lmdbjava.Dbi.BadDbiException;
 import org.lmdbjava.Dbi.BadValueSizeException;
 import org.lmdbjava.Dbi.DbFullException;
@@ -49,8 +53,6 @@
 import org.lmdbjava.LmdbNativeException.PageNotFoundException;
 import org.lmdbjava.LmdbNativeException.PanicException;
 import org.lmdbjava.LmdbNativeException.TlsFullException;
-import static org.lmdbjava.ResultCodeMapper.checkRc;
-import static org.lmdbjava.TestUtils.invokePrivateConstructor;
 import org.lmdbjava.Txn.BadException;
 import org.lmdbjava.Txn.BadReaderLockException;
 import org.lmdbjava.Txn.TxFullException;
diff --git a/src/test/java/org/lmdbjava/TestUtils.java b/src/test/java/org/lmdbjava/TestUtils.java
index afc9c418..1de8218e 100644
--- a/src/test/java/org/lmdbjava/TestUtils.java
+++ b/src/test/java/org/lmdbjava/TestUtils.java
@@ -20,13 +20,15 @@
 
 package org.lmdbjava;
 
-import io.netty.buffer.ByteBuf;
 import static io.netty.buffer.PooledByteBufAllocator.DEFAULT;
 import static java.lang.Integer.BYTES;
+import static java.nio.ByteBuffer.allocateDirect;
+
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
 import java.nio.ByteBuffer;
-import static java.nio.ByteBuffer.allocateDirect;
+
+import io.netty.buffer.ByteBuf;
 import org.agrona.MutableDirectBuffer;
 import org.agrona.concurrent.UnsafeBuffer;
 
diff --git a/src/test/java/org/lmdbjava/TutorialTest.java b/src/test/java/org/lmdbjava/TutorialTest.java
index 74e99c6d..61154ea3 100644
--- a/src/test/java/org/lmdbjava/TutorialTest.java
+++ b/src/test/java/org/lmdbjava/TutorialTest.java
@@ -20,28 +20,17 @@
 
 package org.lmdbjava;
 
-import java.io.File;
-import java.io.IOException;
-import java.nio.ByteBuffer;
 import static java.nio.ByteBuffer.allocateDirect;
 import static java.nio.charset.StandardCharsets.UTF_8;
-import java.util.concurrent.ExecutorService;
 import static java.util.concurrent.Executors.newCachedThreadPool;
 import static java.util.concurrent.TimeUnit.SECONDS;
-import org.agrona.DirectBuffer;
-import org.agrona.MutableDirectBuffer;
-import org.agrona.concurrent.UnsafeBuffer;
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.CoreMatchers.notNullValue;
 import static org.hamcrest.CoreMatchers.startsWith;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
 import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
-import org.lmdbjava.CursorIterable.KeyVal;
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
 import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
 import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
@@ -51,6 +40,19 @@
 import static org.lmdbjava.SeekOp.MDB_LAST;
 import static org.lmdbjava.SeekOp.MDB_PREV;
 
+import java.io.File;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.concurrent.ExecutorService;
+
+import org.agrona.DirectBuffer;
+import org.agrona.MutableDirectBuffer;
+import org.agrona.concurrent.UnsafeBuffer;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.lmdbjava.CursorIterable.KeyVal;
+
 /**
  * Welcome to LmdbJava!
  *
diff --git a/src/test/java/org/lmdbjava/TxnTest.java b/src/test/java/org/lmdbjava/TxnTest.java
index 29dae897..dda4694e 100644
--- a/src/test/java/org/lmdbjava/TxnTest.java
+++ b/src/test/java/org/lmdbjava/TxnTest.java
@@ -21,28 +21,15 @@
 package org.lmdbjava;
 
 import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
-import java.io.File;
-import java.io.IOException;
-import java.nio.ByteBuffer;
 import static java.nio.ByteBuffer.allocateDirect;
 import static java.nio.charset.StandardCharsets.UTF_8;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.concurrent.atomic.AtomicLong;
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.CoreMatchers.notNullValue;
 import static org.hamcrest.CoreMatchers.nullValue;
 import static org.hamcrest.MatcherAssert.assertThat;
-import org.junit.After;
 import static org.junit.Assert.assertEquals;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
-import org.lmdbjava.Dbi.BadValueSizeException;
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
-import org.lmdbjava.Env.AlreadyClosedException;
 import static org.lmdbjava.Env.create;
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
 import static org.lmdbjava.EnvFlags.MDB_RDONLY_ENV;
@@ -50,6 +37,26 @@
 import static org.lmdbjava.TestUtils.DB_1;
 import static org.lmdbjava.TestUtils.POSIX_MODE;
 import static org.lmdbjava.TestUtils.bb;
+import static org.lmdbjava.Txn.State.DONE;
+import static org.lmdbjava.Txn.State.READY;
+import static org.lmdbjava.Txn.State.RELEASED;
+import static org.lmdbjava.Txn.State.RESET;
+import static org.lmdbjava.TxnFlags.MDB_RDONLY_TXN;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicLong;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.lmdbjava.Dbi.BadValueSizeException;
+import org.lmdbjava.Env.AlreadyClosedException;
 import org.lmdbjava.Txn.EnvIsReadOnly;
 import org.lmdbjava.Txn.IncompatibleParent;
 import org.lmdbjava.Txn.NotReadyException;
@@ -57,11 +64,6 @@
 import org.lmdbjava.Txn.ReadOnlyRequiredException;
 import org.lmdbjava.Txn.ReadWriteRequiredException;
 import org.lmdbjava.Txn.ResetException;
-import static org.lmdbjava.Txn.State.DONE;
-import static org.lmdbjava.Txn.State.READY;
-import static org.lmdbjava.Txn.State.RELEASED;
-import static org.lmdbjava.Txn.State.RESET;
-import static org.lmdbjava.TxnFlags.MDB_RDONLY_TXN;
 
 /**
  * Test {@link Txn}.
diff --git a/src/test/java/org/lmdbjava/VerifierTest.java b/src/test/java/org/lmdbjava/VerifierTest.java
index ad0b42d9..16f228d2 100644
--- a/src/test/java/org/lmdbjava/VerifierTest.java
+++ b/src/test/java/org/lmdbjava/VerifierTest.java
@@ -21,17 +21,19 @@
 package org.lmdbjava;
 
 import static com.jakewharton.byteunits.BinaryByteUnit.MEBIBYTES;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.greaterThan;
+import static org.lmdbjava.Env.create;
+import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
+
 import java.io.File;
 import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.util.concurrent.TimeUnit;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.greaterThan;
+
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
-import static org.lmdbjava.Env.create;
-import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
 
 /**
  * Test {@link Verifier}.

From ace015470cc0bff72bf2d48cc2e932efec6b5b88 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 1 Jun 2020 17:58:35 +1000
Subject: [PATCH 095/322] Update to Acegi Standard Project 0.5.0

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index c8ddfd61..8991bf80 100644
--- a/pom.xml
+++ b/pom.xml
@@ -4,7 +4,7 @@
   <parent>
     <groupId>au.com.acegi</groupId>
     <artifactId>acegi-standard-project</artifactId>
-    <version>0.4.1-SNAPSHOT</version>
+    <version>0.5.0</version>
   </parent>
   <groupId>org.lmdbjava</groupId>
   <artifactId>lmdbjava</artifactId>

From a88c2bc416cdb5a92c8d9228a97b2d87097d0e65 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 1 Jun 2020 17:59:55 +1000
Subject: [PATCH 096/322] Add sortpom plugin and apply resulting changes

---
 pom.xml | 222 +++++++++++++++++++++++++++++---------------------------
 1 file changed, 114 insertions(+), 108 deletions(-)

diff --git a/pom.xml b/pom.xml
index 8991bf80..54dec6c0 100644
--- a/pom.xml
+++ b/pom.xml
@@ -12,49 +12,6 @@
   <packaging>jar</packaging>
   <name>LmdbJava</name>
   <description>Low latency Java API for the ultra-fast, embedded Symas Lightning Database (LMDB)</description>
-  <inceptionYear>2016</inceptionYear>
-  <organization>
-    <name>The LmdbJava Open Source Project</name>
-    <url>https://github.com/${github.org}</url>
-  </organization>
-  <licenses>
-    <license>
-      <name>The Apache Software License, Version 2.0</name>
-      <url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
-    </license>
-  </licenses>
-  <developers>
-    <developer>
-      <name>Kristoffer Sjogren</name>
-      <id>krisskross</id>
-      <email>stoffe -at- gmail.com</email>
-      <organization/>
-      <url>http://stoffe.deephacks.org/</url>
-      <timezone>+1</timezone>
-    </developer>
-    <developer>
-      <name>Ben Alex</name>
-      <id>benalexau</id>
-      <email>ben.alex@acegi.com.au</email>
-      <url>https://github.com/benalexau/</url>
-      <organization>Acegi Technology Pty Limited</organization>
-      <timezone>+10</timezone>
-    </developer>
-  </developers>
-  <scm>
-    <connection>scm:git:git@github.com:${github.org}/${github.repo}.git</connection>
-    <developerConnection>scm:git:git@github.com:${github.org}/${github.repo}.git</developerConnection>
-    <url>git@github.com:${github.org}/${github.repo}.git</url>
-    <tag>HEAD</tag>
-  </scm>
-  <issueManagement>
-    <system>GitHub Issues</system>
-    <url>https://github.com/${github.org}/${github.repo}/issues</url>
-  </issueManagement>
-  <ciManagement>
-    <system>GitHub Actions</system>
-    <url>https://github.com/${github.org}/${github.repo}/actions</url>
-  </ciManagement>
   <properties>
     <github.org>lmdbjava</github.org>
     <github.repo>lmdbjava</github.repo>
@@ -62,12 +19,9 @@
   </properties>
   <dependencies>
     <dependency>
-      <groupId>junit</groupId>
-      <artifactId>junit</artifactId>
-    </dependency>
-    <dependency>
-      <groupId>org.hamcrest</groupId>
-      <artifactId>hamcrest</artifactId>
+      <groupId>com.github.jnr</groupId>
+      <artifactId>jnr-constants</artifactId>
+      <version>0.9.15</version>
     </dependency>
     <dependency>
       <groupId>com.github.jnr</groupId>
@@ -75,9 +29,20 @@
       <version>2.1.15</version>
     </dependency>
     <dependency>
-      <groupId>com.github.jnr</groupId>
-      <artifactId>jnr-constants</artifactId>
-      <version>0.9.15</version>
+      <groupId>com.google.code.findbugs</groupId>
+      <artifactId>annotations</artifactId>
+    </dependency>
+    <dependency>
+      <groupId>com.google.guava</groupId>
+      <artifactId>guava</artifactId>
+      <version>29.0-jre</version>
+      <scope>test</scope>
+      <exclusions>
+        <exclusion>
+          <groupId>com.google.code.findbugs</groupId>
+          <artifactId>jsr305</artifactId>
+        </exclusion>
+      </exclusions>
     </dependency>
     <dependency>
       <groupId>com.jakewharton.byteunits</groupId>
@@ -85,12 +50,6 @@
       <version>0.9.1</version>
       <scope>test</scope>
     </dependency>
-    <dependency>
-      <groupId>org.agrona</groupId>
-      <artifactId>agrona</artifactId>
-      <version>1.5.1</version>
-      <optional>true</optional>
-    </dependency>
     <dependency>
       <groupId>io.netty</groupId>
       <artifactId>netty-all</artifactId>
@@ -98,26 +57,22 @@
       <optional>true</optional>
     </dependency>
     <dependency>
-      <groupId>com.google.guava</groupId>
-      <artifactId>guava</artifactId>
-      <version>29.0-jre</version>
-      <scope>test</scope>
-      <exclusions>
-        <exclusion>
-          <groupId>com.google.code.findbugs</groupId>
-          <artifactId>jsr305</artifactId>
-        </exclusion>
-      </exclusions>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
     </dependency>
     <dependency>
-      <groupId>org.lmdbjava</groupId>
-      <artifactId>lmdbjava-native-linux-x86_64</artifactId>
-      <version>0.9.24-1</version>
+      <groupId>org.agrona</groupId>
+      <artifactId>agrona</artifactId>
+      <version>1.5.1</version>
       <optional>true</optional>
     </dependency>
+    <dependency>
+      <groupId>org.hamcrest</groupId>
+      <artifactId>hamcrest</artifactId>
+    </dependency>
     <dependency>
       <groupId>org.lmdbjava</groupId>
-      <artifactId>lmdbjava-native-windows-x86_64</artifactId>
+      <artifactId>lmdbjava-native-linux-x86_64</artifactId>
       <version>0.9.24-1</version>
       <optional>true</optional>
     </dependency>
@@ -128,16 +83,32 @@
       <optional>true</optional>
     </dependency>
     <dependency>
-      <groupId>com.google.code.findbugs</groupId>
-      <artifactId>annotations</artifactId>
+      <groupId>org.lmdbjava</groupId>
+      <artifactId>lmdbjava-native-windows-x86_64</artifactId>
+      <version>0.9.24-1</version>
+      <optional>true</optional>
     </dependency>
   </dependencies>
   <build>
     <plugins>
       <plugin>
-        <artifactId>maven-enforcer-plugin</artifactId>
+        <groupId>au.com.acegi</groupId>
+        <artifactId>xml-format-maven-plugin</artifactId>
+      </plugin>
+      <plugin>
+        <groupId>com.github.ekryd.sortpom</groupId>
+        <artifactId>sortpom-maven-plugin</artifactId>
+      </plugin>
+      <plugin>
+        <groupId>com.github.spotbugs</groupId>
+        <artifactId>spotbugs-maven-plugin</artifactId>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-checkstyle-plugin</artifactId>
       </plugin>
       <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-dependency-plugin</artifactId>
         <configuration>
           <usedDependencies>
@@ -145,54 +116,26 @@
             <usedDependency>org.lmdbjava:lmdbjava-native-windows-x86_64</usedDependency>
             <usedDependency>org.lmdbjava:lmdbjava-native-osx-x86_64</usedDependency>
           </usedDependencies>
-          <ignoredDependencies>
-            <ignoredDependency>com.github.jnr:jffi</ignoredDependency>
-          </ignoredDependencies>
         </configuration>
       </plugin>
       <plugin>
-        <artifactId>maven-checkstyle-plugin</artifactId>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-enforcer-plugin</artifactId>
       </plugin>
       <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-pmd-plugin</artifactId>
       </plugin>
       <plugin>
-        <groupId>org.basepom.maven</groupId>
-        <artifactId>duplicate-finder-maven-plugin</artifactId>
-      </plugin>
-      <plugin>
-        <groupId>org.codehaus.mojo</groupId>
-        <artifactId>versions-maven-plugin</artifactId>
-      </plugin>
-      <plugin>
-        <groupId>org.codehaus.mojo</groupId>
-        <artifactId>buildnumber-maven-plugin</artifactId>
-      </plugin>
-      <plugin>
-        <groupId>org.jacoco</groupId>
-        <artifactId>jacoco-maven-plugin</artifactId>
-      </plugin>
-      <plugin>
-        <groupId>com.github.spotbugs</groupId>
-        <artifactId>spotbugs-maven-plugin</artifactId>
-      </plugin>
-      <plugin>
-        <groupId>au.com.acegi</groupId>
-        <artifactId>xml-format-maven-plugin</artifactId>
-      </plugin>
-      <plugin>
-        <groupId>org.codehaus.mojo</groupId>
-        <artifactId>license-maven-plugin</artifactId>
-      </plugin>
-      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-shade-plugin</artifactId>
         <executions>
           <execution>
             <id>lmdbjava-shade</id>
-            <phase>package</phase>
             <goals>
               <goal>shade</goal>
             </goals>
+            <phase>package</phase>
             <configuration>
               <artifactSet>
                 <includes>
@@ -205,6 +148,69 @@
           </execution>
         </executions>
       </plugin>
+      <plugin>
+        <groupId>org.basepom.maven</groupId>
+        <artifactId>duplicate-finder-maven-plugin</artifactId>
+      </plugin>
+      <plugin>
+        <groupId>org.codehaus.mojo</groupId>
+        <artifactId>buildnumber-maven-plugin</artifactId>
+      </plugin>
+      <plugin>
+        <groupId>org.codehaus.mojo</groupId>
+        <artifactId>license-maven-plugin</artifactId>
+      </plugin>
+      <plugin>
+        <groupId>org.codehaus.mojo</groupId>
+        <artifactId>versions-maven-plugin</artifactId>
+      </plugin>
+      <plugin>
+        <groupId>org.jacoco</groupId>
+        <artifactId>jacoco-maven-plugin</artifactId>
+      </plugin>
     </plugins>
   </build>
+  <inceptionYear>2016</inceptionYear>
+  <organization>
+    <name>The LmdbJava Open Source Project</name>
+    <url>https://github.com/${github.org}</url>
+  </organization>
+  <licenses>
+    <license>
+      <name>The Apache Software License, Version 2.0</name>
+      <url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
+    </license>
+  </licenses>
+  <developers>
+    <developer>
+      <id>krisskross</id>
+      <name>Kristoffer Sjogren</name>
+      <email>stoffe -at- gmail.com</email>
+      <url>http://stoffe.deephacks.org/</url>
+      <organization/>
+      <timezone>+1</timezone>
+    </developer>
+    <developer>
+      <id>benalexau</id>
+      <name>Ben Alex</name>
+      <email>ben.alex@acegi.com.au</email>
+      <url>https://github.com/benalexau/</url>
+      <organization>Acegi Technology Pty Limited</organization>
+      <timezone>+10</timezone>
+    </developer>
+  </developers>
+  <scm>
+    <connection>scm:git:git@github.com:${github.org}/${github.repo}.git</connection>
+    <developerConnection>scm:git:git@github.com:${github.org}/${github.repo}.git</developerConnection>
+    <url>git@github.com:${github.org}/${github.repo}.git</url>
+    <tag>HEAD</tag>
+  </scm>
+  <issueManagement>
+    <system>GitHub Issues</system>
+    <url>https://github.com/${github.org}/${github.repo}/issues</url>
+  </issueManagement>
+  <ciManagement>
+    <system>GitHub Actions</system>
+    <url>https://github.com/${github.org}/${github.repo}/actions</url>
+  </ciManagement>
 </project>

From 262202bbaf5f80cc91011ff515c4f1177943a7fa Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 1 Jun 2020 18:18:07 +1000
Subject: [PATCH 097/322] Revert to JNR-FFI 2.1.13

Windows CI builds on GitHub fail with 2.1.15. This reverts back to the
version before commit 96c2ead9465f2e03cbfc03bc6aace69e86ee5bb8.
---
 pom.xml | 22 +++++++++++++++++++++-
 1 file changed, 21 insertions(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 54dec6c0..5c89b39e 100644
--- a/pom.xml
+++ b/pom.xml
@@ -18,6 +18,17 @@
     <license.licenseName>apache_v2</license.licenseName>
   </properties>
   <dependencies>
+    <dependency>
+      <groupId>com.github.jnr</groupId>
+      <artifactId>jffi</artifactId>
+      <version>1.2.23</version>
+    </dependency>
+    <dependency>
+      <groupId>com.github.jnr</groupId>
+      <artifactId>jffi</artifactId>
+      <version>1.2.23</version>
+      <classifier>native</classifier>
+    </dependency>
     <dependency>
       <groupId>com.github.jnr</groupId>
       <artifactId>jnr-constants</artifactId>
@@ -26,7 +37,13 @@
     <dependency>
       <groupId>com.github.jnr</groupId>
       <artifactId>jnr-ffi</artifactId>
-      <version>2.1.15</version>
+      <version>2.1.13</version>
+      <exclusions>
+        <exclusion>
+          <groupId>com.github.jnr</groupId>
+          <artifactId>jffi</artifactId>
+        </exclusion>
+      </exclusions>
     </dependency>
     <dependency>
       <groupId>com.google.code.findbugs</groupId>
@@ -116,6 +133,9 @@
             <usedDependency>org.lmdbjava:lmdbjava-native-windows-x86_64</usedDependency>
             <usedDependency>org.lmdbjava:lmdbjava-native-osx-x86_64</usedDependency>
           </usedDependencies>
+          <ignoredDependencies>
+            <ignoredDependency>com.github.jnr:jffi</ignoredDependency>
+          </ignoredDependencies>
         </configuration>
       </plugin>
       <plugin>

From 165b3f7c0bfbbf02d81d0208b46f35d638f0d291 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Tue, 2 Jun 2020 09:53:31 +1000
Subject: [PATCH 098/322] Test with JNR-FFI 2.1.14

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 5c89b39e..1416774e 100644
--- a/pom.xml
+++ b/pom.xml
@@ -37,7 +37,7 @@
     <dependency>
       <groupId>com.github.jnr</groupId>
       <artifactId>jnr-ffi</artifactId>
-      <version>2.1.13</version>
+      <version>2.1.14</version>
       <exclusions>
         <exclusion>
           <groupId>com.github.jnr</groupId>

From 72c2d02ba90b025843d8e404fab9fde804fa8cb1 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Tue, 2 Jun 2020 10:05:55 +1000
Subject: [PATCH 099/322] Test again with JNR-FFI 2.1.15 (and explicit
 jnr-native dependencies)

This is following Windows CI failures, but success with 2.1.14.
---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 1416774e..05b8d422 100644
--- a/pom.xml
+++ b/pom.xml
@@ -37,7 +37,7 @@
     <dependency>
       <groupId>com.github.jnr</groupId>
       <artifactId>jnr-ffi</artifactId>
-      <version>2.1.14</version>
+      <version>2.1.15</version>
       <exclusions>
         <exclusion>
           <groupId>com.github.jnr</groupId>

From 180ea1d24af92e9f086e712cf8cc8b805aa9b254 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Tue, 2 Jun 2020 10:48:17 +1000
Subject: [PATCH 100/322] Test with JNR-FFI 2.1.15 using jffi scope=runtime

GitHub CI tests were successful for commit
72c2d02ba90b025843d8e404fab9fde804fa8cb1, which used JNR-FFI 2.1.15
and explicit JFFI dependencies. The native dependency had the default
scope, which is compile. Evaluation of
https://github.com/jnr/jnr-ffi/blob/master/pom.xml confirms JNR-FFI
uses scope=runtime, so this is to test an equivalent explicit scope
given the earlier transitively-acquired dependency (see commit
96c2ead9465f2e03cbfc03bc6aace69e86ee5bb8) did not succeed.

This commit reflects the following dependency graph:

$ mvn dependency:tree | grep jnr
[INFO] +- com.github.jnr:jffi:jar:1.2.23:compile
[INFO] +- com.github.jnr:jffi:jar:native:1.2.23:runtime
[INFO] +- com.github.jnr:jnr-constants:jar:0.9.15:compile
[INFO] +- com.github.jnr:jnr-ffi:jar:2.1.15:compile
[INFO] |  +- com.github.jnr:jnr-a64asm:jar:1.0.0:compile
[INFO] |  \- com.github.jnr:jnr-x86asm:jar:1.0.2:compile
---
 pom.xml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/pom.xml b/pom.xml
index 05b8d422..a9ca7a72 100644
--- a/pom.xml
+++ b/pom.xml
@@ -28,6 +28,7 @@
       <artifactId>jffi</artifactId>
       <version>1.2.23</version>
       <classifier>native</classifier>
+      <scope>runtime</scope>
     </dependency>
     <dependency>
       <groupId>com.github.jnr</groupId>

From 4465a3a9c59e846334c9aeaaba62cf1c4bb262e5 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Tue, 2 Jun 2020 11:07:12 +1000
Subject: [PATCH 101/322] Remove explicit JFFI dependencies (fetched
 transitively via JNR-FFI)

Prior commit 180ea1d24af92e9f086e712cf8cc8b805aa9b254 was successful
and as per its commit message used the following dependency graph:

$ mvn dependency:tree | grep jnr
[INFO] +- com.github.jnr:jffi:jar:1.2.23:compile
[INFO] +- com.github.jnr:jffi:jar:native:1.2.23:runtime
[INFO] +- com.github.jnr:jnr-constants:jar:0.9.15:compile
[INFO] +- com.github.jnr:jnr-ffi:jar:2.1.15:compile
[INFO] |  +- com.github.jnr:jnr-a64asm:jar:1.0.0:compile
[INFO] |  \- com.github.jnr:jnr-x86asm:jar:1.0.2:compile

This commit removes the explicit JFFI dependencies, instead relying on
their transitive provision via JNR-FFI. The revised dependency graph:

$ mvn dependency:tree | grep jnr
[INFO] +- com.github.jnr:jnr-constants:jar:0.9.15:compile
[INFO] +- com.github.jnr:jnr-ffi:jar:2.1.15:compile
[INFO] |  +- com.github.jnr:jffi:jar:1.2.23:compile
[INFO] |  +- com.github.jnr:jffi:jar:native:1.2.23:runtime
[INFO] |  +- com.github.jnr:jnr-a64asm:jar:1.0.0:compile
[INFO] |  \- com.github.jnr:jnr-x86asm:jar:1.0.2:compile
---
 pom.xml | 18 ------------------
 1 file changed, 18 deletions(-)

diff --git a/pom.xml b/pom.xml
index a9ca7a72..6ab61086 100644
--- a/pom.xml
+++ b/pom.xml
@@ -18,18 +18,6 @@
     <license.licenseName>apache_v2</license.licenseName>
   </properties>
   <dependencies>
-    <dependency>
-      <groupId>com.github.jnr</groupId>
-      <artifactId>jffi</artifactId>
-      <version>1.2.23</version>
-    </dependency>
-    <dependency>
-      <groupId>com.github.jnr</groupId>
-      <artifactId>jffi</artifactId>
-      <version>1.2.23</version>
-      <classifier>native</classifier>
-      <scope>runtime</scope>
-    </dependency>
     <dependency>
       <groupId>com.github.jnr</groupId>
       <artifactId>jnr-constants</artifactId>
@@ -39,12 +27,6 @@
       <groupId>com.github.jnr</groupId>
       <artifactId>jnr-ffi</artifactId>
       <version>2.1.15</version>
-      <exclusions>
-        <exclusion>
-          <groupId>com.github.jnr</groupId>
-          <artifactId>jffi</artifactId>
-        </exclusion>
-      </exclusions>
     </dependency>
     <dependency>
       <groupId>com.google.code.findbugs</groupId>

From 148279b89e2268d23a07d36b7267a6dfe8db5909 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Tue, 2 Jun 2020 11:50:19 +1000
Subject: [PATCH 102/322] Update to Acegi Standard Project 0.5.1

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 6ab61086..b21598b9 100644
--- a/pom.xml
+++ b/pom.xml
@@ -4,7 +4,7 @@
   <parent>
     <groupId>au.com.acegi</groupId>
     <artifactId>acegi-standard-project</artifactId>
-    <version>0.5.0</version>
+    <version>0.5.1</version>
   </parent>
   <groupId>org.lmdbjava</groupId>
   <artifactId>lmdbjava</artifactId>

From 9041754ad1b1e4993bccdf59fe342160d1af697d Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Tue, 2 Jun 2020 13:21:21 +1000
Subject: [PATCH 103/322] Update to Acegi Standard Project 0.5.2

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index b21598b9..0e06b964 100644
--- a/pom.xml
+++ b/pom.xml
@@ -4,7 +4,7 @@
   <parent>
     <groupId>au.com.acegi</groupId>
     <artifactId>acegi-standard-project</artifactId>
-    <version>0.5.1</version>
+    <version>0.5.2</version>
   </parent>
   <groupId>org.lmdbjava</groupId>
   <artifactId>lmdbjava</artifactId>

From 0bccfdddf4bb0a145e0bdcf5c7591b32687a45ee Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Tue, 2 Jun 2020 14:44:56 +1000
Subject: [PATCH 104/322] [maven-release-plugin] prepare release lmdbjava-0.8.0

---
 pom.xml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pom.xml b/pom.xml
index 0e06b964..4210e1cd 100644
--- a/pom.xml
+++ b/pom.xml
@@ -8,7 +8,7 @@
   </parent>
   <groupId>org.lmdbjava</groupId>
   <artifactId>lmdbjava</artifactId>
-  <version>0.8.0-SNAPSHOT</version>
+  <version>0.8.0</version>
   <packaging>jar</packaging>
   <name>LmdbJava</name>
   <description>Low latency Java API for the ultra-fast, embedded Symas Lightning Database (LMDB)</description>
@@ -206,7 +206,7 @@
     <connection>scm:git:git@github.com:${github.org}/${github.repo}.git</connection>
     <developerConnection>scm:git:git@github.com:${github.org}/${github.repo}.git</developerConnection>
     <url>git@github.com:${github.org}/${github.repo}.git</url>
-    <tag>HEAD</tag>
+    <tag>lmdbjava-0.8.0</tag>
   </scm>
   <issueManagement>
     <system>GitHub Issues</system>

From 24f136b74d1aa2e6064fb8038f1c5f01a7f34732 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Tue, 2 Jun 2020 14:45:09 +1000
Subject: [PATCH 105/322] [maven-release-plugin] prepare for next development
 iteration

---
 pom.xml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pom.xml b/pom.xml
index 4210e1cd..1d7b0577 100644
--- a/pom.xml
+++ b/pom.xml
@@ -8,7 +8,7 @@
   </parent>
   <groupId>org.lmdbjava</groupId>
   <artifactId>lmdbjava</artifactId>
-  <version>0.8.0</version>
+  <version>0.8.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>LmdbJava</name>
   <description>Low latency Java API for the ultra-fast, embedded Symas Lightning Database (LMDB)</description>
@@ -206,7 +206,7 @@
     <connection>scm:git:git@github.com:${github.org}/${github.repo}.git</connection>
     <developerConnection>scm:git:git@github.com:${github.org}/${github.repo}.git</developerConnection>
     <url>git@github.com:${github.org}/${github.repo}.git</url>
-    <tag>lmdbjava-0.8.0</tag>
+    <tag>HEAD</tag>
   </scm>
   <issueManagement>
     <system>GitHub Issues</system>

From 2f8527b6e6510c92f80e14b9a8ddaab914ad7e87 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Wed, 3 Jun 2020 11:46:25 +1000
Subject: [PATCH 106/322] Build with Java 8 due to ByteBuffer NoSuchMethodError
 (#116, #158)

As detailed at https://github.com/lmdbjava/lmdbjava/issues/116, Java 9
introduced overridden methods with covariant return types in
ByteBuffer. The consequence is that Java 8 compatibility is
problematic if compiling with Java 9 or above. This commit therefore
performs the deployment step using Java 8. The fuller verification
step is still completed on Java 11.
---
 .github/workflows/maven.yml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml
index c8ef2d4a..5ec25a8b 100644
--- a/.github/workflows/maven.yml
+++ b/.github/workflows/maven.yml
@@ -89,7 +89,8 @@ jobs:
     - name: Set up Java and Maven
       uses: actions/setup-java@v1
       with:
-        java-version: 11
+        # Java version 8 required due to https://github.com/lmdbjava/lmdbjava/issues/116
+        java-version: 8
 
     - name: Add OSSRH to the snapshot repositories list
       uses: s4u/maven-settings-action@v2.1.0

From d7d89884bdc2922e95a3b6aac37aeb5b789e7963 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Thu, 4 Jun 2020 09:47:34 +1000
Subject: [PATCH 107/322] [maven-release-plugin] prepare release lmdbjava-0.8.1

---
 pom.xml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pom.xml b/pom.xml
index 1d7b0577..fe02c7fd 100644
--- a/pom.xml
+++ b/pom.xml
@@ -8,7 +8,7 @@
   </parent>
   <groupId>org.lmdbjava</groupId>
   <artifactId>lmdbjava</artifactId>
-  <version>0.8.1-SNAPSHOT</version>
+  <version>0.8.1</version>
   <packaging>jar</packaging>
   <name>LmdbJava</name>
   <description>Low latency Java API for the ultra-fast, embedded Symas Lightning Database (LMDB)</description>
@@ -206,7 +206,7 @@
     <connection>scm:git:git@github.com:${github.org}/${github.repo}.git</connection>
     <developerConnection>scm:git:git@github.com:${github.org}/${github.repo}.git</developerConnection>
     <url>git@github.com:${github.org}/${github.repo}.git</url>
-    <tag>HEAD</tag>
+    <tag>lmdbjava-0.8.1</tag>
   </scm>
   <issueManagement>
     <system>GitHub Issues</system>

From 26d76be888c11d1f645f9c6902954c348e474f79 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Thu, 4 Jun 2020 09:47:46 +1000
Subject: [PATCH 108/322] [maven-release-plugin] prepare for next development
 iteration

---
 pom.xml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pom.xml b/pom.xml
index fe02c7fd..1e8874a0 100644
--- a/pom.xml
+++ b/pom.xml
@@ -8,7 +8,7 @@
   </parent>
   <groupId>org.lmdbjava</groupId>
   <artifactId>lmdbjava</artifactId>
-  <version>0.8.1</version>
+  <version>0.8.2-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>LmdbJava</name>
   <description>Low latency Java API for the ultra-fast, embedded Symas Lightning Database (LMDB)</description>
@@ -206,7 +206,7 @@
     <connection>scm:git:git@github.com:${github.org}/${github.repo}.git</connection>
     <developerConnection>scm:git:git@github.com:${github.org}/${github.repo}.git</developerConnection>
     <url>git@github.com:${github.org}/${github.repo}.git</url>
-    <tag>lmdbjava-0.8.1</tag>
+    <tag>HEAD</tag>
   </scm>
   <issueManagement>
     <system>GitHub Issues</system>

From cb19f5919d9200ff4cea7696fefe5a3aef094423 Mon Sep 17 00:00:00 2001
From: Maithem <Maithem@users.noreply.github.com>
Date: Tue, 18 Aug 2020 01:23:15 -0700
Subject: [PATCH 109/322] Support User Defined PooledByteBufAllocator

This patch allows users to pass a PooledByteBufAllocator instance
if they wish to not use the DEFAULT instance. Also, this patch
fixes a minor bug where a ByteBuf is created during initialization
without ever being released.
---
 src/main/java/org/lmdbjava/ByteBufProxy.java | 64 ++++++++------------
 1 file changed, 24 insertions(+), 40 deletions(-)

diff --git a/src/main/java/org/lmdbjava/ByteBufProxy.java b/src/main/java/org/lmdbjava/ByteBufProxy.java
index ca580363..271c4e2f 100644
--- a/src/main/java/org/lmdbjava/ByteBufProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufProxy.java
@@ -22,13 +22,12 @@
 
 import static io.netty.buffer.PooledByteBufAllocator.DEFAULT;
 import static java.lang.Class.forName;
-import static java.lang.ThreadLocal.withInitial;
 import static org.lmdbjava.UnsafeAccess.UNSAFE;
 
 import java.lang.reflect.Field;
-import java.util.ArrayDeque;
 
 import io.netty.buffer.ByteBuf;
+import io.netty.buffer.PooledByteBufAllocator;
 import jnr.ffi.Pointer;
 
 /**
@@ -47,37 +46,34 @@ public final class ByteBufProxy extends BufferProxy<ByteBuf> {
    */
   public static final BufferProxy<ByteBuf> PROXY_NETTY = new ByteBufProxy();
 
-  private static final long ADDRESS_OFFSET;
-
-  /**
-   * A thread-safe pool for a given length. If the buffer found is bigger then
-   * the buffer in the pool creates a new buffer. If no buffer is found creates
-   * a new buffer.
-   */
-  private static final ThreadLocal<ArrayDeque<ByteBuf>> BUFFERS = withInitial(()
-      -> new ArrayDeque<>(16));
-
   private static final int BUFFER_RETRIES = 10;
   private static final String FIELD_NAME_ADDRESS = "memoryAddress";
   private static final String FIELD_NAME_LENGTH = "length";
-  private static final long LENGTH_OFFSET;
   private static final String NAME = "io.netty.buffer.PooledUnsafeDirectByteBuf";
+  private final long lengthOffset;
+  private final long addressOffset;
+  
+  private final PooledByteBufAllocator nettyAllocator;
+
+  private ByteBufProxy() {
+    this(DEFAULT);
+  }
+
+  public ByteBufProxy(final PooledByteBufAllocator allocator) {
+    this.nettyAllocator = allocator;
 
-  static {
     try {
-      createBuffer();
+      final ByteBuf initBuf = this.allocate();
+      initBuf.release();
       final Field address = findField(NAME, FIELD_NAME_ADDRESS);
       final Field length = findField(NAME, FIELD_NAME_LENGTH);
-      ADDRESS_OFFSET = UNSAFE.objectFieldOffset(address);
-      LENGTH_OFFSET = UNSAFE.objectFieldOffset(length);
+      addressOffset = UNSAFE.objectFieldOffset(address);
+      lengthOffset = UNSAFE.objectFieldOffset(length);
     } catch (final SecurityException e) {
       throw new LmdbException("Field access error", e);
     }
   }
 
-  private ByteBufProxy() {
-  }
-
   static Field findField(final String c, final String name) {
     Class<?> clazz;
     try {
@@ -97,28 +93,19 @@ static Field findField(final String c, final String name) {
     throw new LmdbException(name + " not found");
   }
 
-  private static ByteBuf createBuffer() {
+  @Override
+  protected ByteBuf allocate() {
     for (int i = 0; i < BUFFER_RETRIES; i++) {
-      final ByteBuf bb = DEFAULT.directBuffer(0);
+      final ByteBuf bb = nettyAllocator.directBuffer();
       if (NAME.equals(bb.getClass().getName())) {
         return bb;
+      } else {
+        bb.release();
       }
     }
     throw new IllegalStateException("Netty buffer must be " + NAME);
   }
 
-  @Override
-  protected ByteBuf allocate() {
-    final ArrayDeque<ByteBuf> queue = BUFFERS.get();
-    final ByteBuf buffer = queue.poll();
-
-    if (buffer != null && buffer.capacity() >= 0) {
-      return buffer;
-    } else {
-      return createBuffer();
-    }
-  }
-
   @Override
   protected int compare(final ByteBuf o1, final ByteBuf o2) {
     return o1.compareTo(o2);
@@ -126,10 +113,7 @@ protected int compare(final ByteBuf o1, final ByteBuf o2) {
 
   @Override
   protected void deallocate(final ByteBuf buff) {
-    final ArrayDeque<ByteBuf> queue = BUFFERS.get();
-    if (!queue.offer(buff)) {
-      buff.release();
-    }
+    buff.release();
   }
 
   @Override
@@ -161,8 +145,8 @@ protected ByteBuf out(final ByteBuf buffer, final Pointer ptr,
                         final long ptrAddr) {
     final long addr = UNSAFE.getLong(ptrAddr + STRUCT_FIELD_OFFSET_DATA);
     final long size = UNSAFE.getLong(ptrAddr + STRUCT_FIELD_OFFSET_SIZE);
-    UNSAFE.putLong(buffer, ADDRESS_OFFSET, addr);
-    UNSAFE.putInt(buffer, LENGTH_OFFSET, (int) size);
+    UNSAFE.putLong(buffer, addressOffset, addr);
+    UNSAFE.putInt(buffer, lengthOffset, (int) size);
     buffer.writerIndex((int) size).readerIndex(0);
     return buffer;
   }

From fc0bdb469137ac9d1b41481ea22659d8fbafbecb Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 12 Mar 2021 11:52:10 +1100
Subject: [PATCH 110/322] Copyright year

---
 src/main/java/org/lmdbjava/BufferProxy.java          | 2 +-
 src/main/java/org/lmdbjava/ByteArrayProxy.java       | 2 +-
 src/main/java/org/lmdbjava/ByteBufProxy.java         | 2 +-
 src/main/java/org/lmdbjava/ByteBufferProxy.java      | 2 +-
 src/main/java/org/lmdbjava/CopyFlags.java            | 2 +-
 src/main/java/org/lmdbjava/Cursor.java               | 2 +-
 src/main/java/org/lmdbjava/CursorIterable.java       | 2 +-
 src/main/java/org/lmdbjava/Dbi.java                  | 2 +-
 src/main/java/org/lmdbjava/DbiFlags.java             | 2 +-
 src/main/java/org/lmdbjava/DirectBufferProxy.java    | 2 +-
 src/main/java/org/lmdbjava/Env.java                  | 2 +-
 src/main/java/org/lmdbjava/EnvFlags.java             | 2 +-
 src/main/java/org/lmdbjava/EnvInfo.java              | 2 +-
 src/main/java/org/lmdbjava/GetOp.java                | 2 +-
 src/main/java/org/lmdbjava/KeyRange.java             | 2 +-
 src/main/java/org/lmdbjava/KeyRangeType.java         | 2 +-
 src/main/java/org/lmdbjava/KeyVal.java               | 2 +-
 src/main/java/org/lmdbjava/Library.java              | 2 +-
 src/main/java/org/lmdbjava/LmdbException.java        | 2 +-
 src/main/java/org/lmdbjava/LmdbNativeException.java  | 2 +-
 src/main/java/org/lmdbjava/MaskedFlag.java           | 2 +-
 src/main/java/org/lmdbjava/Meta.java                 | 2 +-
 src/main/java/org/lmdbjava/PutFlags.java             | 2 +-
 src/main/java/org/lmdbjava/ResultCodeMapper.java     | 2 +-
 src/main/java/org/lmdbjava/SeekOp.java               | 2 +-
 src/main/java/org/lmdbjava/Stat.java                 | 2 +-
 src/main/java/org/lmdbjava/Txn.java                  | 2 +-
 src/main/java/org/lmdbjava/TxnFlags.java             | 2 +-
 src/main/java/org/lmdbjava/UnsafeAccess.java         | 2 +-
 src/main/java/org/lmdbjava/Verifier.java             | 2 +-
 src/main/java/org/lmdbjava/package-info.java         | 2 +-
 src/test/java/org/lmdbjava/ByteBufferProxyTest.java  | 2 +-
 src/test/java/org/lmdbjava/ComparatorTest.java       | 2 +-
 src/test/java/org/lmdbjava/CursorIterableTest.java   | 2 +-
 src/test/java/org/lmdbjava/CursorParamTest.java      | 2 +-
 src/test/java/org/lmdbjava/CursorTest.java           | 2 +-
 src/test/java/org/lmdbjava/DbiTest.java              | 2 +-
 src/test/java/org/lmdbjava/EnvTest.java              | 2 +-
 src/test/java/org/lmdbjava/KeyRangeTest.java         | 2 +-
 src/test/java/org/lmdbjava/LibraryTest.java          | 2 +-
 src/test/java/org/lmdbjava/MaskedFlagTest.java       | 2 +-
 src/test/java/org/lmdbjava/MetaTest.java             | 2 +-
 src/test/java/org/lmdbjava/ResultCodeMapperTest.java | 2 +-
 src/test/java/org/lmdbjava/TestUtils.java            | 2 +-
 src/test/java/org/lmdbjava/TutorialTest.java         | 2 +-
 src/test/java/org/lmdbjava/TxnTest.java              | 2 +-
 src/test/java/org/lmdbjava/VerifierTest.java         | 2 +-
 src/test/java/org/lmdbjava/package-info.java         | 2 +-
 48 files changed, 48 insertions(+), 48 deletions(-)

diff --git a/src/main/java/org/lmdbjava/BufferProxy.java b/src/main/java/org/lmdbjava/BufferProxy.java
index 0fe73f3f..dc7aaadd 100644
--- a/src/main/java/org/lmdbjava/BufferProxy.java
+++ b/src/main/java/org/lmdbjava/BufferProxy.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/ByteArrayProxy.java b/src/main/java/org/lmdbjava/ByteArrayProxy.java
index dc964bcc..0bc05376 100644
--- a/src/main/java/org/lmdbjava/ByteArrayProxy.java
+++ b/src/main/java/org/lmdbjava/ByteArrayProxy.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/ByteBufProxy.java b/src/main/java/org/lmdbjava/ByteBufProxy.java
index 271c4e2f..54d8a44b 100644
--- a/src/main/java/org/lmdbjava/ByteBufProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufProxy.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
index 9d1b0f81..6daa5c16 100644
--- a/src/main/java/org/lmdbjava/ByteBufferProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/CopyFlags.java b/src/main/java/org/lmdbjava/CopyFlags.java
index d85ffb06..685df3c3 100644
--- a/src/main/java/org/lmdbjava/CopyFlags.java
+++ b/src/main/java/org/lmdbjava/CopyFlags.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/Cursor.java b/src/main/java/org/lmdbjava/Cursor.java
index 5dac5b58..f165423b 100644
--- a/src/main/java/org/lmdbjava/Cursor.java
+++ b/src/main/java/org/lmdbjava/Cursor.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/CursorIterable.java b/src/main/java/org/lmdbjava/CursorIterable.java
index 19729443..5bd86272 100644
--- a/src/main/java/org/lmdbjava/CursorIterable.java
+++ b/src/main/java/org/lmdbjava/CursorIterable.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index 62fbc0f2..7ccb1940 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/DbiFlags.java b/src/main/java/org/lmdbjava/DbiFlags.java
index 0f9573dd..12ea80f0 100644
--- a/src/main/java/org/lmdbjava/DbiFlags.java
+++ b/src/main/java/org/lmdbjava/DbiFlags.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/DirectBufferProxy.java b/src/main/java/org/lmdbjava/DirectBufferProxy.java
index af911afa..39911515 100644
--- a/src/main/java/org/lmdbjava/DirectBufferProxy.java
+++ b/src/main/java/org/lmdbjava/DirectBufferProxy.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 7634a342..326763f6 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/EnvFlags.java b/src/main/java/org/lmdbjava/EnvFlags.java
index b8883706..a713547d 100644
--- a/src/main/java/org/lmdbjava/EnvFlags.java
+++ b/src/main/java/org/lmdbjava/EnvFlags.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/EnvInfo.java b/src/main/java/org/lmdbjava/EnvInfo.java
index fe16e92b..de21edd0 100644
--- a/src/main/java/org/lmdbjava/EnvInfo.java
+++ b/src/main/java/org/lmdbjava/EnvInfo.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/GetOp.java b/src/main/java/org/lmdbjava/GetOp.java
index 82550f82..fa600ebd 100644
--- a/src/main/java/org/lmdbjava/GetOp.java
+++ b/src/main/java/org/lmdbjava/GetOp.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/KeyRange.java b/src/main/java/org/lmdbjava/KeyRange.java
index c3e35864..61d9e434 100644
--- a/src/main/java/org/lmdbjava/KeyRange.java
+++ b/src/main/java/org/lmdbjava/KeyRange.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/KeyRangeType.java b/src/main/java/org/lmdbjava/KeyRangeType.java
index 156daf99..d92ec054 100644
--- a/src/main/java/org/lmdbjava/KeyRangeType.java
+++ b/src/main/java/org/lmdbjava/KeyRangeType.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/KeyVal.java b/src/main/java/org/lmdbjava/KeyVal.java
index 481d34ed..0da61a8e 100644
--- a/src/main/java/org/lmdbjava/KeyVal.java
+++ b/src/main/java/org/lmdbjava/KeyVal.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/Library.java b/src/main/java/org/lmdbjava/Library.java
index 18d3e717..fc54dda0 100644
--- a/src/main/java/org/lmdbjava/Library.java
+++ b/src/main/java/org/lmdbjava/Library.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/LmdbException.java b/src/main/java/org/lmdbjava/LmdbException.java
index e6004f19..92ff72e4 100644
--- a/src/main/java/org/lmdbjava/LmdbException.java
+++ b/src/main/java/org/lmdbjava/LmdbException.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/LmdbNativeException.java b/src/main/java/org/lmdbjava/LmdbNativeException.java
index 81b46d15..1bef719d 100644
--- a/src/main/java/org/lmdbjava/LmdbNativeException.java
+++ b/src/main/java/org/lmdbjava/LmdbNativeException.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/MaskedFlag.java b/src/main/java/org/lmdbjava/MaskedFlag.java
index 21dde5a1..dfd6df16 100644
--- a/src/main/java/org/lmdbjava/MaskedFlag.java
+++ b/src/main/java/org/lmdbjava/MaskedFlag.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/Meta.java b/src/main/java/org/lmdbjava/Meta.java
index 699b182d..b157b950 100644
--- a/src/main/java/org/lmdbjava/Meta.java
+++ b/src/main/java/org/lmdbjava/Meta.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/PutFlags.java b/src/main/java/org/lmdbjava/PutFlags.java
index 87bdacd9..58589e68 100644
--- a/src/main/java/org/lmdbjava/PutFlags.java
+++ b/src/main/java/org/lmdbjava/PutFlags.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/ResultCodeMapper.java b/src/main/java/org/lmdbjava/ResultCodeMapper.java
index ed209f41..0c076bc7 100644
--- a/src/main/java/org/lmdbjava/ResultCodeMapper.java
+++ b/src/main/java/org/lmdbjava/ResultCodeMapper.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/SeekOp.java b/src/main/java/org/lmdbjava/SeekOp.java
index 1d214adb..829458a9 100644
--- a/src/main/java/org/lmdbjava/SeekOp.java
+++ b/src/main/java/org/lmdbjava/SeekOp.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/Stat.java b/src/main/java/org/lmdbjava/Stat.java
index de43577e..66480a08 100644
--- a/src/main/java/org/lmdbjava/Stat.java
+++ b/src/main/java/org/lmdbjava/Stat.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/Txn.java b/src/main/java/org/lmdbjava/Txn.java
index dfdfc60a..36f8eaf9 100644
--- a/src/main/java/org/lmdbjava/Txn.java
+++ b/src/main/java/org/lmdbjava/Txn.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/TxnFlags.java b/src/main/java/org/lmdbjava/TxnFlags.java
index a4cf3e8d..906170ba 100644
--- a/src/main/java/org/lmdbjava/TxnFlags.java
+++ b/src/main/java/org/lmdbjava/TxnFlags.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/UnsafeAccess.java b/src/main/java/org/lmdbjava/UnsafeAccess.java
index 7114e34d..8a853429 100644
--- a/src/main/java/org/lmdbjava/UnsafeAccess.java
+++ b/src/main/java/org/lmdbjava/UnsafeAccess.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/Verifier.java b/src/main/java/org/lmdbjava/Verifier.java
index 9bc7b89e..0674a069 100644
--- a/src/main/java/org/lmdbjava/Verifier.java
+++ b/src/main/java/org/lmdbjava/Verifier.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/package-info.java b/src/main/java/org/lmdbjava/package-info.java
index 05e35587..aa1b4570 100644
--- a/src/main/java/org/lmdbjava/package-info.java
+++ b/src/main/java/org/lmdbjava/package-info.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
index ba882281..19b6aba5 100644
--- a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
+++ b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/ComparatorTest.java b/src/test/java/org/lmdbjava/ComparatorTest.java
index e8499838..23b2a80b 100644
--- a/src/test/java/org/lmdbjava/ComparatorTest.java
+++ b/src/test/java/org/lmdbjava/ComparatorTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index cc6cd0b6..05819835 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/CursorParamTest.java b/src/test/java/org/lmdbjava/CursorParamTest.java
index c105aae7..6cac2be5 100644
--- a/src/test/java/org/lmdbjava/CursorParamTest.java
+++ b/src/test/java/org/lmdbjava/CursorParamTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/CursorTest.java b/src/test/java/org/lmdbjava/CursorTest.java
index 137732f5..373b68e9 100644
--- a/src/test/java/org/lmdbjava/CursorTest.java
+++ b/src/test/java/org/lmdbjava/CursorTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index b9bf453c..0c897268 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index 3e9ece95..bd36f2f2 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/KeyRangeTest.java b/src/test/java/org/lmdbjava/KeyRangeTest.java
index 0cb3d1f5..8d0077ae 100644
--- a/src/test/java/org/lmdbjava/KeyRangeTest.java
+++ b/src/test/java/org/lmdbjava/KeyRangeTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/LibraryTest.java b/src/test/java/org/lmdbjava/LibraryTest.java
index 08c6ea9f..9ac57fba 100644
--- a/src/test/java/org/lmdbjava/LibraryTest.java
+++ b/src/test/java/org/lmdbjava/LibraryTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/MaskedFlagTest.java b/src/test/java/org/lmdbjava/MaskedFlagTest.java
index 34acb3f8..d28666ea 100644
--- a/src/test/java/org/lmdbjava/MaskedFlagTest.java
+++ b/src/test/java/org/lmdbjava/MaskedFlagTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/MetaTest.java b/src/test/java/org/lmdbjava/MetaTest.java
index d20f6510..3df23f41 100644
--- a/src/test/java/org/lmdbjava/MetaTest.java
+++ b/src/test/java/org/lmdbjava/MetaTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/ResultCodeMapperTest.java b/src/test/java/org/lmdbjava/ResultCodeMapperTest.java
index f2382021..37d6e166 100644
--- a/src/test/java/org/lmdbjava/ResultCodeMapperTest.java
+++ b/src/test/java/org/lmdbjava/ResultCodeMapperTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/TestUtils.java b/src/test/java/org/lmdbjava/TestUtils.java
index 1de8218e..6ab21584 100644
--- a/src/test/java/org/lmdbjava/TestUtils.java
+++ b/src/test/java/org/lmdbjava/TestUtils.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/TutorialTest.java b/src/test/java/org/lmdbjava/TutorialTest.java
index 61154ea3..b92582d0 100644
--- a/src/test/java/org/lmdbjava/TutorialTest.java
+++ b/src/test/java/org/lmdbjava/TutorialTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/TxnTest.java b/src/test/java/org/lmdbjava/TxnTest.java
index dda4694e..69f0815f 100644
--- a/src/test/java/org/lmdbjava/TxnTest.java
+++ b/src/test/java/org/lmdbjava/TxnTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/VerifierTest.java b/src/test/java/org/lmdbjava/VerifierTest.java
index 16f228d2..4a4c487a 100644
--- a/src/test/java/org/lmdbjava/VerifierTest.java
+++ b/src/test/java/org/lmdbjava/VerifierTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/package-info.java b/src/test/java/org/lmdbjava/package-info.java
index caa25a12..042d4e65 100644
--- a/src/test/java/org/lmdbjava/package-info.java
+++ b/src/test/java/org/lmdbjava/package-info.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2020 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

From 18fbd77aebedebcf78bec008528418249a2fc2a3 Mon Sep 17 00:00:00 2001
From: Huahai Yang <hyang@juji-inc.com>
Date: Thu, 11 Mar 2021 16:54:28 -0800
Subject: [PATCH 111/322] fix a typo in ByteBufferProxy (#172)

---
 src/main/java/org/lmdbjava/ByteBufferProxy.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
index 6daa5c16..37baf656 100644
--- a/src/main/java/org/lmdbjava/ByteBufferProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -133,7 +133,7 @@ public static int compareBuff(final ByteBuffer o1, final ByteBuffer o2) {
       final int minWords = minLength / Long.BYTES;
 
       final boolean reverse1 = o1.order() == LITTLE_ENDIAN;
-      final boolean reverse2 = o1.order() == LITTLE_ENDIAN;
+      final boolean reverse2 = o2.order() == LITTLE_ENDIAN;
       for (int i = 0; i < minWords * Long.BYTES; i += Long.BYTES) {
         final long lw = reverse1 ? reverseBytes(o1.getLong(i)) : o1.getLong(i);
         final long rw = reverse2 ? reverseBytes(o2.getLong(i)) : o2.getLong(i);

From 823062383313dc075bf895ea7762cfa35170f376 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 12 Mar 2021 00:58:54 +0000
Subject: [PATCH 112/322] Fix AbstractByteBufferProxy.compareBuff and Improve
 ComparatorTest (PR #170) (fixes #169)

---
 .../java/org/lmdbjava/ByteBufferProxy.java    |  2 +-
 .../java/org/lmdbjava/ComparatorTest.java     | 36 +++++++++++++++++--
 2 files changed, 34 insertions(+), 4 deletions(-)

diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
index 37baf656..2dd337c0 100644
--- a/src/main/java/org/lmdbjava/ByteBufferProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -152,7 +152,7 @@ public static int compareBuff(final ByteBuffer o1, final ByteBuffer o2) {
         }
       }
 
-      return o1.capacity() - o2.capacity();
+      return o1.remaining() - o2.remaining();
     }
 
     static Field findField(final Class<?> c, final String name) {
diff --git a/src/test/java/org/lmdbjava/ComparatorTest.java b/src/test/java/org/lmdbjava/ComparatorTest.java
index 23b2a80b..a9aa920e 100644
--- a/src/test/java/org/lmdbjava/ComparatorTest.java
+++ b/src/test/java/org/lmdbjava/ComparatorTest.java
@@ -33,6 +33,7 @@
 import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
 
 import java.nio.ByteBuffer;
+import java.util.Arrays;
 import java.util.Comparator;
 
 import com.google.common.primitives.SignedBytes;
@@ -156,9 +157,38 @@ private static class ByteBufferRunner implements ComparatorRunner {
 
     @Override
     public int compare(final byte[] o1, final byte[] o2) {
-      final ByteBuffer o1b = ByteBuffer.wrap(o1);
-      final ByteBuffer o2b = ByteBuffer.wrap(o2);
-      return PROXY_OPTIMAL.compare(o1b, o2b);
+      // Convert arrays to buffers that are larger than the array, with
+      // limit set at the array length. One buffer bigger than the other.
+      ByteBuffer o1b = arrayToBuffer(o1, o1.length * 3);
+      ByteBuffer o2b = arrayToBuffer(o2, o2.length * 2);
+      final int result = PROXY_OPTIMAL.compare(o1b, o2b);
+
+      // Now swap which buffer is bigger
+      o1b = arrayToBuffer(o1, o1.length * 2);
+      o2b = arrayToBuffer(o2, o2.length * 3);
+      final int result2 = PROXY_OPTIMAL.compare(o1b, o2b);
+
+      assertThat(result2, is(result));
+
+      // Now try with buffers sized to the array.
+      o1b = ByteBuffer.wrap(o1);
+      o2b = ByteBuffer.wrap(o2);
+      final int result3 = PROXY_OPTIMAL.compare(o1b, o2b);
+
+      assertThat(result3, is(result));
+
+      return result;
+    }
+
+    private ByteBuffer arrayToBuffer(final byte[] arr, final int bufferCapacity) {
+      if (bufferCapacity < arr.length) {
+        throw new IllegalArgumentException("bufferCapacity < arr.length");
+      }
+      final byte[] newArr = Arrays.copyOf(arr, bufferCapacity);
+      final ByteBuffer byteBuffer = ByteBuffer.wrap(newArr);
+      byteBuffer.limit(arr.length);
+      byteBuffer.position(0);
+      return byteBuffer;
     }
   }
 

From 958eb115be4e6f6c6a00ed7cb638efb000f2bbaa Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Sat, 13 Mar 2021 02:16:59 +0000
Subject: [PATCH 113/322] Update to JNR-FFI to 2.2.2 (PR #175, Issue #174)

* lmdbjava/lmdbjava#174 Uplift jnr-ffi to v2.2.2

* lmdbjava/lmdbjava#174 Add java 15 to github workflows matrix
---
 .github/workflows/maven.yml | 2 +-
 pom.xml                     | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml
index 5ec25a8b..4112d072 100644
--- a/.github/workflows/maven.yml
+++ b/.github/workflows/maven.yml
@@ -44,7 +44,7 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-16.04, ubuntu-latest, macos-latest, windows-latest]
-        java: [8, 11, 14]
+        java: [8, 11, 14, 15]
 
     steps:
       - name: Check out Git repository
diff --git a/pom.xml b/pom.xml
index 1e8874a0..ff9d4895 100644
--- a/pom.xml
+++ b/pom.xml
@@ -26,7 +26,7 @@
     <dependency>
       <groupId>com.github.jnr</groupId>
       <artifactId>jnr-ffi</artifactId>
-      <version>2.1.15</version>
+      <version>2.2.2</version>
     </dependency>
     <dependency>
       <groupId>com.google.code.findbugs</groupId>

From dfba4dabfe68d335ec6c5126900e082deb8d3f24 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 2 Aug 2021 16:36:40 +1000
Subject: [PATCH 114/322] Add JVM options required to test under Java 16

---
 pom.xml | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/pom.xml b/pom.xml
index ff9d4895..de4d3558 100644
--- a/pom.xml
+++ b/pom.xml
@@ -151,6 +151,13 @@
           </execution>
         </executions>
       </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-surefire-plugin</artifactId>
+        <configuration>
+          <argLine>--add-opens java.base/java.nio=ALL-UNNAMED --add-opens java.base/sun.nio.ch=ALL-UNNAMED</argLine>
+        </configuration>
+      </plugin>
       <plugin>
         <groupId>org.basepom.maven</groupId>
         <artifactId>duplicate-finder-maven-plugin</artifactId>

From 29a1543329b6b4f2cc54c519c26236e56095c52a Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 2 Aug 2021 16:37:08 +1000
Subject: [PATCH 115/322] Minor adjustments so FindBugs passes the build

---
 src/main/java/org/lmdbjava/Verifier.java | 4 ++++
 src/test/java/org/lmdbjava/DbiTest.java  | 4 +---
 src/test/java/org/lmdbjava/EnvTest.java  | 3 +++
 3 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/src/main/java/org/lmdbjava/Verifier.java b/src/main/java/org/lmdbjava/Verifier.java
index 0674a069..05e5eb83 100644
--- a/src/main/java/org/lmdbjava/Verifier.java
+++ b/src/main/java/org/lmdbjava/Verifier.java
@@ -37,6 +37,8 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.zip.CRC32;
 
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+
 /**
  * Verifies correct operation of LmdbJava in a given environment.
  *
@@ -112,6 +114,7 @@ public final class Verifier implements Callable<Long> {
    *
    * @param env target that complies with the above requirements (required)
    */
+  @SuppressFBWarnings("EI_EXPOSE_REP2")
   public Verifier(final Env<ByteBuffer> env) {
     requireNonNull(env);
     this.env = env;
@@ -237,6 +240,7 @@ private void stop() {
     proceed.set(false);
   }
 
+  @SuppressFBWarnings("DMI_RANDOM_USED_ONLY_ONCE")
   private void transactionControl() {
     if (id % BATCH_SIZE == 0) {
       if (txn != null) {
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 0c897268..689eab58 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -61,7 +61,6 @@
 import java.util.Comparator;
 import java.util.Iterator;
 import java.util.List;
-import java.util.Random;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
@@ -487,9 +486,8 @@ public void testParallelWritesStress() {
     // Travis CI has 1.5 cores for legacy builds
     nCopies(2, null).parallelStream()
         .forEach(ignored -> {
-          final Random random = new Random();
           for (int i = 0; i < 15_000; i++) {
-            db.put(bb(random.nextInt()), bb(random.nextInt()));
+            db.put(bb(i), bb(i));
           }
         });
   }
diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index bd36f2f2..bf766ff7 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -42,6 +42,7 @@
 import java.nio.ByteBuffer;
 import java.util.Random;
 
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
@@ -286,6 +287,7 @@ public void info() throws IOException {
   }
 
   @Test(expected = MapFullException.class)
+  @SuppressFBWarnings("DMI_RANDOM_USED_ONLY_ONCE")
   public void mapFull() throws IOException {
     final File path = tmp.newFolder();
     final byte[] k = new byte[500];
@@ -327,6 +329,7 @@ public void readOnlySupported() throws IOException {
   }
 
   @Test
+  @SuppressFBWarnings("DMI_RANDOM_USED_ONLY_ONCE")
   public void setMapSize() throws IOException {
     final File path = tmp.newFolder();
     final byte[] k = new byte[500];

From 0282cac96ae751ddffd4aeaeaeff88c04e954203 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 2 Aug 2021 16:40:53 +1000
Subject: [PATCH 116/322] Suppress PMD.CompareObjectsWithEquals warning

---
 src/main/java/org/lmdbjava/ByteArrayProxy.java | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/main/java/org/lmdbjava/ByteArrayProxy.java b/src/main/java/org/lmdbjava/ByteArrayProxy.java
index 0bc05376..2b72a833 100644
--- a/src/main/java/org/lmdbjava/ByteArrayProxy.java
+++ b/src/main/java/org/lmdbjava/ByteArrayProxy.java
@@ -52,6 +52,7 @@ private ByteArrayProxy() {
    * @param o2 right operand (required)
    * @return as specified by {@link Comparable} interface
    */
+  @SuppressWarnings("PMD.CompareObjectsWithEquals")
   public static int compareArrays(final byte[] o1, final byte[] o2) {
     requireNonNull(o1);
     requireNonNull(o2);

From b3bdcef13872504c200e0416ab94bda2056f8912 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 2 Aug 2021 16:41:49 +1000
Subject: [PATCH 117/322] Update to Agrona 1.11.0

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index de4d3558..621ca6d2 100644
--- a/pom.xml
+++ b/pom.xml
@@ -63,7 +63,7 @@
     <dependency>
       <groupId>org.agrona</groupId>
       <artifactId>agrona</artifactId>
-      <version>1.5.1</version>
+      <version>1.11.0</version>
       <optional>true</optional>
     </dependency>
     <dependency>

From 70cd28614cc024dd2be01a2e8cdc9618de94b32c Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 2 Aug 2021 16:42:06 +1000
Subject: [PATCH 118/322] Update to Netty 4.1.66

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 621ca6d2..89503468 100644
--- a/pom.xml
+++ b/pom.xml
@@ -53,7 +53,7 @@
     <dependency>
       <groupId>io.netty</groupId>
       <artifactId>netty-all</artifactId>
-      <version>4.1.50.Final</version>
+      <version>4.1.66.Final</version>
       <optional>true</optional>
     </dependency>
     <dependency>

From ab59ac5af4fa873bb31ec079d50209a7fe95e24c Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 2 Aug 2021 16:51:06 +1000
Subject: [PATCH 119/322] Remove Ubuntu 16.04 from test matrix as ubuntu-latest
 is sufficient

https://github.blog/changelog/2020-10-29-github-actions-ubuntu-latest-workflows-will-use-ubuntu-20-04/
---
 .github/workflows/maven.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml
index 4112d072..c5b57c99 100644
--- a/.github/workflows/maven.yml
+++ b/.github/workflows/maven.yml
@@ -43,7 +43,7 @@ jobs:
 
     strategy:
       matrix:
-        os: [ubuntu-16.04, ubuntu-latest, macos-latest, windows-latest]
+        os: [ubuntu-latest, macos-latest, windows-latest]
         java: [8, 11, 14, 15]
 
     steps:

From 656fd671235f468ad7a26f15590589d179bc9c1c Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 2 Aug 2021 16:54:20 +1000
Subject: [PATCH 120/322] Test on Java LTS versions 8, 11 and 16

---
 .github/workflows/maven.yml | 2 +-
 README.md                   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml
index c5b57c99..a272d491 100644
--- a/.github/workflows/maven.yml
+++ b/.github/workflows/maven.yml
@@ -44,7 +44,7 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest]
-        java: [8, 11, 14, 15]
+        java: [8, 11, 16]
 
     steps:
       - name: Check out Git repository
diff --git a/README.md b/README.md
index 0945af36..5abc21c0 100644
--- a/README.md
+++ b/README.md
@@ -34,7 +34,7 @@
 * Mature code (commenced in 2016) and used for heavy production workloads (eg > 500 TB of HFT data)
 * Actively maintained and with a "Zero Bug Policy" before every release (see [issues](https://github.com/lmdbjava/lmdbjava/issues))
 * Available from [Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22org.lmdbjava%22%20AND%20a%3A%22lmdbjava%22) and [OSS Sonatype Snapshots](https://oss.sonatype.org/content/repositories/snapshots/org/lmdbjava/lmdbjava)
-* [Continuous integration](https://github.com/lmdbjava/lmdbjava/actions) testing on Linux, Windows and macOS with Java 8, 11 and 14
+* [Continuous integration](https://github.com/lmdbjava/lmdbjava/actions) testing on Linux, Windows and macOS with Java 8, 11 and 16
 
 ### Performance
 

From 5687bd61ff8de770800fa319b4b98a0f61a92b24 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 2 Aug 2021 16:57:07 +1000
Subject: [PATCH 121/322] Activate Surefire JVM 9+ options via a Maven profile

---
 pom.xml | 26 +++++++++++++++++++-------
 1 file changed, 19 insertions(+), 7 deletions(-)

diff --git a/pom.xml b/pom.xml
index 89503468..a5ca1d50 100644
--- a/pom.xml
+++ b/pom.xml
@@ -151,13 +151,6 @@
           </execution>
         </executions>
       </plugin>
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-surefire-plugin</artifactId>
-        <configuration>
-          <argLine>--add-opens java.base/java.nio=ALL-UNNAMED --add-opens java.base/sun.nio.ch=ALL-UNNAMED</argLine>
-        </configuration>
-      </plugin>
       <plugin>
         <groupId>org.basepom.maven</groupId>
         <artifactId>duplicate-finder-maven-plugin</artifactId>
@@ -223,4 +216,23 @@
     <system>GitHub Actions</system>
     <url>https://github.com/${github.org}/${github.repo}/actions</url>
   </ciManagement>
+  <profiles>
+    <profile>
+      <id>add-opens-on-java-9-and-above</id>
+      <activation>
+        <jdk>[1.9</jdk>
+      </activation>
+      <build>
+        <plugins>
+          <plugin>
+            <groupId>org.apache.maven.plugins</groupId>
+            <artifactId>maven-surefire-plugin</artifactId>
+            <configuration>
+              <argLine>--add-opens java.base/java.nio=ALL-UNNAMED --add-opens java.base/sun.nio.ch=ALL-UNNAMED</argLine>
+            </configuration>
+          </plugin>
+        </plugins>
+      </build>
+    </profile>
+  </profiles>
 </project>

From a7c38f5bb14aecf7666805148962d069dd0cbce5 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 2 Aug 2021 17:14:47 +1000
Subject: [PATCH 122/322] Update to Guava 30.1.1

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index a5ca1d50..a110b527 100644
--- a/pom.xml
+++ b/pom.xml
@@ -35,7 +35,7 @@
     <dependency>
       <groupId>com.google.guava</groupId>
       <artifactId>guava</artifactId>
-      <version>29.0-jre</version>
+      <version>30.1.1-jre</version>
       <scope>test</scope>
       <exclusions>
         <exclusion>

From f28d1b196114795570cfd047f4fd1668eaeaae7b Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Wed, 4 Aug 2021 18:37:33 +1000
Subject: [PATCH 123/322] Update to Acegi Standard Project 0.6.1

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index a110b527..916340df 100644
--- a/pom.xml
+++ b/pom.xml
@@ -4,7 +4,7 @@
   <parent>
     <groupId>au.com.acegi</groupId>
     <artifactId>acegi-standard-project</artifactId>
-    <version>0.5.2</version>
+    <version>0.6.1</version>
   </parent>
   <groupId>org.lmdbjava</groupId>
   <artifactId>lmdbjava</artifactId>

From 3666782e1dc6efee2745d3758fe071beef0825ed Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 24 Sep 2021 09:45:56 +1000
Subject: [PATCH 124/322] [maven-release-plugin] prepare release lmdbjava-0.8.2

---
 pom.xml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pom.xml b/pom.xml
index 916340df..2c817035 100644
--- a/pom.xml
+++ b/pom.xml
@@ -8,7 +8,7 @@
   </parent>
   <groupId>org.lmdbjava</groupId>
   <artifactId>lmdbjava</artifactId>
-  <version>0.8.2-SNAPSHOT</version>
+  <version>0.8.2</version>
   <packaging>jar</packaging>
   <name>LmdbJava</name>
   <description>Low latency Java API for the ultra-fast, embedded Symas Lightning Database (LMDB)</description>
@@ -206,7 +206,7 @@
     <connection>scm:git:git@github.com:${github.org}/${github.repo}.git</connection>
     <developerConnection>scm:git:git@github.com:${github.org}/${github.repo}.git</developerConnection>
     <url>git@github.com:${github.org}/${github.repo}.git</url>
-    <tag>HEAD</tag>
+    <tag>lmdbjava-0.8.2</tag>
   </scm>
   <issueManagement>
     <system>GitHub Issues</system>

From 3d95bf1a81e90b14b8db5e8a0f79d52d5249b248 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 24 Sep 2021 09:46:02 +1000
Subject: [PATCH 125/322] [maven-release-plugin] prepare for next development
 iteration

---
 pom.xml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pom.xml b/pom.xml
index 2c817035..ce6eeb21 100644
--- a/pom.xml
+++ b/pom.xml
@@ -8,7 +8,7 @@
   </parent>
   <groupId>org.lmdbjava</groupId>
   <artifactId>lmdbjava</artifactId>
-  <version>0.8.2</version>
+  <version>0.8.3-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>LmdbJava</name>
   <description>Low latency Java API for the ultra-fast, embedded Symas Lightning Database (LMDB)</description>
@@ -206,7 +206,7 @@
     <connection>scm:git:git@github.com:${github.org}/${github.repo}.git</connection>
     <developerConnection>scm:git:git@github.com:${github.org}/${github.repo}.git</developerConnection>
     <url>git@github.com:${github.org}/${github.repo}.git</url>
-    <tag>lmdbjava-0.8.2</tag>
+    <tag>HEAD</tag>
   </scm>
   <issueManagement>
     <system>GitHub Issues</system>

From 1d991f8e4b0e19fc003f8a093aeaee37ea3ecf72 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Sun, 24 Oct 2021 14:12:20 +1100
Subject: [PATCH 126/322] Support Netty ByteBuf variable sized data (#183)

---
 src/main/java/org/lmdbjava/ByteBufProxy.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/org/lmdbjava/ByteBufProxy.java b/src/main/java/org/lmdbjava/ByteBufProxy.java
index 54d8a44b..51fe0617 100644
--- a/src/main/java/org/lmdbjava/ByteBufProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufProxy.java
@@ -147,7 +147,7 @@ protected ByteBuf out(final ByteBuf buffer, final Pointer ptr,
     final long size = UNSAFE.getLong(ptrAddr + STRUCT_FIELD_OFFSET_SIZE);
     UNSAFE.putLong(buffer, addressOffset, addr);
     UNSAFE.putInt(buffer, lengthOffset, (int) size);
-    buffer.writerIndex((int) size).readerIndex(0);
+    buffer.clear().writerIndex((int) size);
     return buffer;
   }
 }

From eb2abea1f85db0b6004756fb75db8f0c6b7d2771 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Sun, 7 Nov 2021 14:01:53 +1100
Subject: [PATCH 127/322] Update to Acegi Standard Project 0.6.2

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index ce6eeb21..98e1292f 100644
--- a/pom.xml
+++ b/pom.xml
@@ -4,7 +4,7 @@
   <parent>
     <groupId>au.com.acegi</groupId>
     <artifactId>acegi-standard-project</artifactId>
-    <version>0.6.1</version>
+    <version>0.6.2</version>
   </parent>
   <groupId>org.lmdbjava</groupId>
   <artifactId>lmdbjava</artifactId>

From 680e0a820753695255e1849e710bde1975848125 Mon Sep 17 00:00:00 2001
From: Jan Doms <jan.doms@gmail.com>
Date: Thu, 13 Jan 2022 23:47:44 +0000
Subject: [PATCH 128/322] fix lmdb link in readme (#189)

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 5abc21c0..4547b786 100644
--- a/README.md
+++ b/README.md
@@ -7,7 +7,7 @@
 
 # LMDB for Java
 
-[LMDB](http://symas.com/mdb/) offers:
+[LMDB](http://symas.com/lmdb/) offers:
 
 * Transactions (full ACID semantics)
 * Ordered keys (enabling very fast cursor-based iteration)

From b9b331bf21834d8aa9322a8aaf3592bd05f6313e Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Thu, 24 Mar 2022 12:29:13 +1100
Subject: [PATCH 129/322] Update to LMDB 0.9.29 (closes #194)

---
 pom.xml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/pom.xml b/pom.xml
index 98e1292f..2ed6eb40 100644
--- a/pom.xml
+++ b/pom.xml
@@ -73,19 +73,19 @@
     <dependency>
       <groupId>org.lmdbjava</groupId>
       <artifactId>lmdbjava-native-linux-x86_64</artifactId>
-      <version>0.9.24-1</version>
+      <version>0.9.29-1</version>
       <optional>true</optional>
     </dependency>
     <dependency>
       <groupId>org.lmdbjava</groupId>
       <artifactId>lmdbjava-native-osx-x86_64</artifactId>
-      <version>0.9.24-1</version>
+      <version>0.9.29-1</version>
       <optional>true</optional>
     </dependency>
     <dependency>
       <groupId>org.lmdbjava</groupId>
       <artifactId>lmdbjava-native-windows-x86_64</artifactId>
-      <version>0.9.24-1</version>
+      <version>0.9.29-1</version>
       <optional>true</optional>
     </dependency>
   </dependencies>

From da2a849566e34eaa9a1fc79d132fdee1f80dfb29 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 15 Apr 2022 16:06:48 +1000
Subject: [PATCH 130/322] Update copyright year

---
 src/main/java/org/lmdbjava/BufferProxy.java          | 2 +-
 src/main/java/org/lmdbjava/ByteArrayProxy.java       | 2 +-
 src/main/java/org/lmdbjava/ByteBufProxy.java         | 2 +-
 src/main/java/org/lmdbjava/ByteBufferProxy.java      | 2 +-
 src/main/java/org/lmdbjava/CopyFlags.java            | 2 +-
 src/main/java/org/lmdbjava/Cursor.java               | 2 +-
 src/main/java/org/lmdbjava/CursorIterable.java       | 2 +-
 src/main/java/org/lmdbjava/Dbi.java                  | 2 +-
 src/main/java/org/lmdbjava/DbiFlags.java             | 2 +-
 src/main/java/org/lmdbjava/DirectBufferProxy.java    | 2 +-
 src/main/java/org/lmdbjava/Env.java                  | 2 +-
 src/main/java/org/lmdbjava/EnvFlags.java             | 2 +-
 src/main/java/org/lmdbjava/EnvInfo.java              | 2 +-
 src/main/java/org/lmdbjava/GetOp.java                | 2 +-
 src/main/java/org/lmdbjava/KeyRange.java             | 2 +-
 src/main/java/org/lmdbjava/KeyRangeType.java         | 2 +-
 src/main/java/org/lmdbjava/KeyVal.java               | 2 +-
 src/main/java/org/lmdbjava/Library.java              | 2 +-
 src/main/java/org/lmdbjava/LmdbException.java        | 2 +-
 src/main/java/org/lmdbjava/LmdbNativeException.java  | 2 +-
 src/main/java/org/lmdbjava/MaskedFlag.java           | 2 +-
 src/main/java/org/lmdbjava/Meta.java                 | 2 +-
 src/main/java/org/lmdbjava/PutFlags.java             | 2 +-
 src/main/java/org/lmdbjava/ResultCodeMapper.java     | 2 +-
 src/main/java/org/lmdbjava/SeekOp.java               | 2 +-
 src/main/java/org/lmdbjava/Stat.java                 | 2 +-
 src/main/java/org/lmdbjava/Txn.java                  | 2 +-
 src/main/java/org/lmdbjava/TxnFlags.java             | 2 +-
 src/main/java/org/lmdbjava/UnsafeAccess.java         | 2 +-
 src/main/java/org/lmdbjava/Verifier.java             | 2 +-
 src/main/java/org/lmdbjava/package-info.java         | 2 +-
 src/test/java/org/lmdbjava/ByteBufferProxyTest.java  | 2 +-
 src/test/java/org/lmdbjava/ComparatorTest.java       | 2 +-
 src/test/java/org/lmdbjava/CursorIterableTest.java   | 2 +-
 src/test/java/org/lmdbjava/CursorParamTest.java      | 2 +-
 src/test/java/org/lmdbjava/CursorTest.java           | 2 +-
 src/test/java/org/lmdbjava/DbiTest.java              | 2 +-
 src/test/java/org/lmdbjava/EnvTest.java              | 2 +-
 src/test/java/org/lmdbjava/KeyRangeTest.java         | 2 +-
 src/test/java/org/lmdbjava/LibraryTest.java          | 2 +-
 src/test/java/org/lmdbjava/MaskedFlagTest.java       | 2 +-
 src/test/java/org/lmdbjava/MetaTest.java             | 2 +-
 src/test/java/org/lmdbjava/ResultCodeMapperTest.java | 2 +-
 src/test/java/org/lmdbjava/TestUtils.java            | 2 +-
 src/test/java/org/lmdbjava/TutorialTest.java         | 2 +-
 src/test/java/org/lmdbjava/TxnTest.java              | 2 +-
 src/test/java/org/lmdbjava/VerifierTest.java         | 2 +-
 src/test/java/org/lmdbjava/package-info.java         | 2 +-
 48 files changed, 48 insertions(+), 48 deletions(-)

diff --git a/src/main/java/org/lmdbjava/BufferProxy.java b/src/main/java/org/lmdbjava/BufferProxy.java
index dc7aaadd..01ff0608 100644
--- a/src/main/java/org/lmdbjava/BufferProxy.java
+++ b/src/main/java/org/lmdbjava/BufferProxy.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/ByteArrayProxy.java b/src/main/java/org/lmdbjava/ByteArrayProxy.java
index 2b72a833..4afa20ae 100644
--- a/src/main/java/org/lmdbjava/ByteArrayProxy.java
+++ b/src/main/java/org/lmdbjava/ByteArrayProxy.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/ByteBufProxy.java b/src/main/java/org/lmdbjava/ByteBufProxy.java
index 51fe0617..1029cdf3 100644
--- a/src/main/java/org/lmdbjava/ByteBufProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufProxy.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
index 2dd337c0..1292e2bd 100644
--- a/src/main/java/org/lmdbjava/ByteBufferProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/CopyFlags.java b/src/main/java/org/lmdbjava/CopyFlags.java
index 685df3c3..52cbb234 100644
--- a/src/main/java/org/lmdbjava/CopyFlags.java
+++ b/src/main/java/org/lmdbjava/CopyFlags.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/Cursor.java b/src/main/java/org/lmdbjava/Cursor.java
index f165423b..ad6aaf8b 100644
--- a/src/main/java/org/lmdbjava/Cursor.java
+++ b/src/main/java/org/lmdbjava/Cursor.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/CursorIterable.java b/src/main/java/org/lmdbjava/CursorIterable.java
index 5bd86272..37edad1b 100644
--- a/src/main/java/org/lmdbjava/CursorIterable.java
+++ b/src/main/java/org/lmdbjava/CursorIterable.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index 7ccb1940..426e461e 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/DbiFlags.java b/src/main/java/org/lmdbjava/DbiFlags.java
index 12ea80f0..da263868 100644
--- a/src/main/java/org/lmdbjava/DbiFlags.java
+++ b/src/main/java/org/lmdbjava/DbiFlags.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/DirectBufferProxy.java b/src/main/java/org/lmdbjava/DirectBufferProxy.java
index 39911515..3073fd64 100644
--- a/src/main/java/org/lmdbjava/DirectBufferProxy.java
+++ b/src/main/java/org/lmdbjava/DirectBufferProxy.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 326763f6..ea54b7a3 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/EnvFlags.java b/src/main/java/org/lmdbjava/EnvFlags.java
index a713547d..fe942f58 100644
--- a/src/main/java/org/lmdbjava/EnvFlags.java
+++ b/src/main/java/org/lmdbjava/EnvFlags.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/EnvInfo.java b/src/main/java/org/lmdbjava/EnvInfo.java
index de21edd0..274b341c 100644
--- a/src/main/java/org/lmdbjava/EnvInfo.java
+++ b/src/main/java/org/lmdbjava/EnvInfo.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/GetOp.java b/src/main/java/org/lmdbjava/GetOp.java
index fa600ebd..7fe2697f 100644
--- a/src/main/java/org/lmdbjava/GetOp.java
+++ b/src/main/java/org/lmdbjava/GetOp.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/KeyRange.java b/src/main/java/org/lmdbjava/KeyRange.java
index 61d9e434..76fe558e 100644
--- a/src/main/java/org/lmdbjava/KeyRange.java
+++ b/src/main/java/org/lmdbjava/KeyRange.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/KeyRangeType.java b/src/main/java/org/lmdbjava/KeyRangeType.java
index d92ec054..77a55529 100644
--- a/src/main/java/org/lmdbjava/KeyRangeType.java
+++ b/src/main/java/org/lmdbjava/KeyRangeType.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/KeyVal.java b/src/main/java/org/lmdbjava/KeyVal.java
index 0da61a8e..f438597b 100644
--- a/src/main/java/org/lmdbjava/KeyVal.java
+++ b/src/main/java/org/lmdbjava/KeyVal.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/Library.java b/src/main/java/org/lmdbjava/Library.java
index fc54dda0..7de85033 100644
--- a/src/main/java/org/lmdbjava/Library.java
+++ b/src/main/java/org/lmdbjava/Library.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/LmdbException.java b/src/main/java/org/lmdbjava/LmdbException.java
index 92ff72e4..8dd52ea6 100644
--- a/src/main/java/org/lmdbjava/LmdbException.java
+++ b/src/main/java/org/lmdbjava/LmdbException.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/LmdbNativeException.java b/src/main/java/org/lmdbjava/LmdbNativeException.java
index 1bef719d..4073cf59 100644
--- a/src/main/java/org/lmdbjava/LmdbNativeException.java
+++ b/src/main/java/org/lmdbjava/LmdbNativeException.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/MaskedFlag.java b/src/main/java/org/lmdbjava/MaskedFlag.java
index dfd6df16..e3419c13 100644
--- a/src/main/java/org/lmdbjava/MaskedFlag.java
+++ b/src/main/java/org/lmdbjava/MaskedFlag.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/Meta.java b/src/main/java/org/lmdbjava/Meta.java
index b157b950..bceb11a9 100644
--- a/src/main/java/org/lmdbjava/Meta.java
+++ b/src/main/java/org/lmdbjava/Meta.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/PutFlags.java b/src/main/java/org/lmdbjava/PutFlags.java
index 58589e68..ff397e54 100644
--- a/src/main/java/org/lmdbjava/PutFlags.java
+++ b/src/main/java/org/lmdbjava/PutFlags.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/ResultCodeMapper.java b/src/main/java/org/lmdbjava/ResultCodeMapper.java
index 0c076bc7..7566f0b1 100644
--- a/src/main/java/org/lmdbjava/ResultCodeMapper.java
+++ b/src/main/java/org/lmdbjava/ResultCodeMapper.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/SeekOp.java b/src/main/java/org/lmdbjava/SeekOp.java
index 829458a9..c86211a9 100644
--- a/src/main/java/org/lmdbjava/SeekOp.java
+++ b/src/main/java/org/lmdbjava/SeekOp.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/Stat.java b/src/main/java/org/lmdbjava/Stat.java
index 66480a08..605b5f4d 100644
--- a/src/main/java/org/lmdbjava/Stat.java
+++ b/src/main/java/org/lmdbjava/Stat.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/Txn.java b/src/main/java/org/lmdbjava/Txn.java
index 36f8eaf9..a6f5218a 100644
--- a/src/main/java/org/lmdbjava/Txn.java
+++ b/src/main/java/org/lmdbjava/Txn.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/TxnFlags.java b/src/main/java/org/lmdbjava/TxnFlags.java
index 906170ba..3753d6c2 100644
--- a/src/main/java/org/lmdbjava/TxnFlags.java
+++ b/src/main/java/org/lmdbjava/TxnFlags.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/UnsafeAccess.java b/src/main/java/org/lmdbjava/UnsafeAccess.java
index 8a853429..b5c06d88 100644
--- a/src/main/java/org/lmdbjava/UnsafeAccess.java
+++ b/src/main/java/org/lmdbjava/UnsafeAccess.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/Verifier.java b/src/main/java/org/lmdbjava/Verifier.java
index 05e5eb83..493eb17e 100644
--- a/src/main/java/org/lmdbjava/Verifier.java
+++ b/src/main/java/org/lmdbjava/Verifier.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/package-info.java b/src/main/java/org/lmdbjava/package-info.java
index aa1b4570..c60e2e1a 100644
--- a/src/main/java/org/lmdbjava/package-info.java
+++ b/src/main/java/org/lmdbjava/package-info.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
index 19b6aba5..2469ae7c 100644
--- a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
+++ b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/ComparatorTest.java b/src/test/java/org/lmdbjava/ComparatorTest.java
index a9aa920e..2faa224a 100644
--- a/src/test/java/org/lmdbjava/ComparatorTest.java
+++ b/src/test/java/org/lmdbjava/ComparatorTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index 05819835..036f3bf8 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/CursorParamTest.java b/src/test/java/org/lmdbjava/CursorParamTest.java
index 6cac2be5..0ae70dd8 100644
--- a/src/test/java/org/lmdbjava/CursorParamTest.java
+++ b/src/test/java/org/lmdbjava/CursorParamTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/CursorTest.java b/src/test/java/org/lmdbjava/CursorTest.java
index 373b68e9..1a685487 100644
--- a/src/test/java/org/lmdbjava/CursorTest.java
+++ b/src/test/java/org/lmdbjava/CursorTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 689eab58..640c2905 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index bf766ff7..6fc03021 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/KeyRangeTest.java b/src/test/java/org/lmdbjava/KeyRangeTest.java
index 8d0077ae..d1802072 100644
--- a/src/test/java/org/lmdbjava/KeyRangeTest.java
+++ b/src/test/java/org/lmdbjava/KeyRangeTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/LibraryTest.java b/src/test/java/org/lmdbjava/LibraryTest.java
index 9ac57fba..2c7ce1c6 100644
--- a/src/test/java/org/lmdbjava/LibraryTest.java
+++ b/src/test/java/org/lmdbjava/LibraryTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/MaskedFlagTest.java b/src/test/java/org/lmdbjava/MaskedFlagTest.java
index d28666ea..37202b76 100644
--- a/src/test/java/org/lmdbjava/MaskedFlagTest.java
+++ b/src/test/java/org/lmdbjava/MaskedFlagTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/MetaTest.java b/src/test/java/org/lmdbjava/MetaTest.java
index 3df23f41..4d7fd01d 100644
--- a/src/test/java/org/lmdbjava/MetaTest.java
+++ b/src/test/java/org/lmdbjava/MetaTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/ResultCodeMapperTest.java b/src/test/java/org/lmdbjava/ResultCodeMapperTest.java
index 37d6e166..b5699749 100644
--- a/src/test/java/org/lmdbjava/ResultCodeMapperTest.java
+++ b/src/test/java/org/lmdbjava/ResultCodeMapperTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/TestUtils.java b/src/test/java/org/lmdbjava/TestUtils.java
index 6ab21584..8ef16ec1 100644
--- a/src/test/java/org/lmdbjava/TestUtils.java
+++ b/src/test/java/org/lmdbjava/TestUtils.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/TutorialTest.java b/src/test/java/org/lmdbjava/TutorialTest.java
index b92582d0..09536382 100644
--- a/src/test/java/org/lmdbjava/TutorialTest.java
+++ b/src/test/java/org/lmdbjava/TutorialTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/TxnTest.java b/src/test/java/org/lmdbjava/TxnTest.java
index 69f0815f..87969e1f 100644
--- a/src/test/java/org/lmdbjava/TxnTest.java
+++ b/src/test/java/org/lmdbjava/TxnTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/VerifierTest.java b/src/test/java/org/lmdbjava/VerifierTest.java
index 4a4c487a..fd49ffec 100644
--- a/src/test/java/org/lmdbjava/VerifierTest.java
+++ b/src/test/java/org/lmdbjava/VerifierTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/package-info.java b/src/test/java/org/lmdbjava/package-info.java
index 042d4e65..c404b678 100644
--- a/src/test/java/org/lmdbjava/package-info.java
+++ b/src/test/java/org/lmdbjava/package-info.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2021 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

From 4b872d285441a6340a6810eddb6d683947722f00 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 15 Apr 2022 17:10:22 +1000
Subject: [PATCH 131/322] Update to JNR-FFI 2.2.12 (fixes #190)

Transitive dependency tree now includes JFFI 1.3.9:

+- com.github.jnr:jnr-ffi:jar:2.2.12:compile
|  +- com.github.jnr:jffi:jar:1.3.9:compile
|  +- com.github.jnr:jffi:jar:native:1.3.9:runtime
|  +- org.ow2.asm:asm:jar:9.2:compile
|  +- org.ow2.asm:asm-commons:jar:9.2:compile
|  +- org.ow2.asm:asm-analysis:jar:9.2:compile
|  +- org.ow2.asm:asm-tree:jar:9.2:compile
|  +- org.ow2.asm:asm-util:jar:9.2:compile
|  +- com.github.jnr:jnr-a64asm:jar:1.0.0:compile
|  \- com.github.jnr:jnr-x86asm:jar:1.0.2:compile
---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 2ed6eb40..5d4c0d22 100644
--- a/pom.xml
+++ b/pom.xml
@@ -26,7 +26,7 @@
     <dependency>
       <groupId>com.github.jnr</groupId>
       <artifactId>jnr-ffi</artifactId>
-      <version>2.2.2</version>
+      <version>2.2.12</version>
     </dependency>
     <dependency>
       <groupId>com.google.code.findbugs</groupId>

From 301f8d132ee9a85bf331834dee23fe91ed73a67b Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 15 Apr 2022 17:12:25 +1000
Subject: [PATCH 132/322] Update to JNR Constants 0.10.3

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 5d4c0d22..5b765ea8 100644
--- a/pom.xml
+++ b/pom.xml
@@ -21,7 +21,7 @@
     <dependency>
       <groupId>com.github.jnr</groupId>
       <artifactId>jnr-constants</artifactId>
-      <version>0.9.15</version>
+      <version>0.10.3</version>
     </dependency>
     <dependency>
       <groupId>com.github.jnr</groupId>

From a406ef819b71ed26d9de9006edfc15de0b22aec2 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 15 Apr 2022 17:12:34 +1000
Subject: [PATCH 133/322] Update to Guava 31.1

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 5b765ea8..eb2412da 100644
--- a/pom.xml
+++ b/pom.xml
@@ -35,7 +35,7 @@
     <dependency>
       <groupId>com.google.guava</groupId>
       <artifactId>guava</artifactId>
-      <version>30.1.1-jre</version>
+      <version>31.1-jre</version>
       <scope>test</scope>
       <exclusions>
         <exclusion>

From 492c7767c7c47d17171fac80b89feb8d96ae69be Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 15 Apr 2022 17:12:45 +1000
Subject: [PATCH 134/322] Update to Netty 4.1.76.Final

---
 pom.xml | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/pom.xml b/pom.xml
index eb2412da..33cdcc43 100644
--- a/pom.xml
+++ b/pom.xml
@@ -52,8 +52,14 @@
     </dependency>
     <dependency>
       <groupId>io.netty</groupId>
-      <artifactId>netty-all</artifactId>
-      <version>4.1.66.Final</version>
+      <artifactId>netty-buffer</artifactId>
+      <version>4.1.76.Final</version>
+      <optional>true</optional>
+    </dependency>
+    <dependency>
+      <groupId>io.netty</groupId>
+      <artifactId>netty-buffer</artifactId>
+      <version>4.1.76.Final</version>
       <optional>true</optional>
     </dependency>
     <dependency>

From 9996c282fb886351577298e11441ff6338ffd99e Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 15 Apr 2022 17:13:03 +1000
Subject: [PATCH 135/322] Update to Agrona 1.15.1

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 33cdcc43..cb071033 100644
--- a/pom.xml
+++ b/pom.xml
@@ -69,7 +69,7 @@
     <dependency>
       <groupId>org.agrona</groupId>
       <artifactId>agrona</artifactId>
-      <version>1.11.0</version>
+      <version>1.15.1</version>
       <optional>true</optional>
     </dependency>
     <dependency>

From 6a6331669374189cc9e7cb0bd08a1910c42fef44 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 15 Apr 2022 17:13:21 +1000
Subject: [PATCH 136/322] Update to Acegi Standard Project 0.6.3

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index cb071033..182713e5 100644
--- a/pom.xml
+++ b/pom.xml
@@ -4,7 +4,7 @@
   <parent>
     <groupId>au.com.acegi</groupId>
     <artifactId>acegi-standard-project</artifactId>
-    <version>0.6.2</version>
+    <version>0.6.3</version>
   </parent>
   <groupId>org.lmdbjava</groupId>
   <artifactId>lmdbjava</artifactId>

From fae1fb6a5bb0500ad22f226932d97c41cd512ff4 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Sat, 16 Apr 2022 12:06:48 +1000
Subject: [PATCH 137/322] Checkstyle during OSSHR deploy due to JVM
 incompatibility

---
 pom.xml | 18 ++++++++++++++----
 1 file changed, 14 insertions(+), 4 deletions(-)

diff --git a/pom.xml b/pom.xml
index 182713e5..00525364 100644
--- a/pom.xml
+++ b/pom.xml
@@ -109,10 +109,6 @@
         <groupId>com.github.spotbugs</groupId>
         <artifactId>spotbugs-maven-plugin</artifactId>
       </plugin>
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-checkstyle-plugin</artifactId>
-      </plugin>
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-dependency-plugin</artifactId>
@@ -240,5 +236,19 @@
         </plugins>
       </build>
     </profile>
+    <profile>
+      <id>additional-plugins-on-java-11-and-above</id>
+      <activation>
+        <jdk>[1.11</jdk>
+      </activation>
+      <build>
+        <plugins>
+          <plugin>
+            <groupId>org.apache.maven.plugins</groupId>
+            <artifactId>maven-checkstyle-plugin</artifactId>
+          </plugin>
+        </plugins>
+      </build>
+    </profile>
   </profiles>
 </project>

From 610043c9f1e1b7f937bc89138eced6eae9c93333 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 2 Dec 2022 12:16:25 +1100
Subject: [PATCH 138/322] Update to Acegi Standard Project 0.6.4

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 00525364..ca07d4d7 100644
--- a/pom.xml
+++ b/pom.xml
@@ -4,7 +4,7 @@
   <parent>
     <groupId>au.com.acegi</groupId>
     <artifactId>acegi-standard-project</artifactId>
-    <version>0.6.3</version>
+    <version>0.6.4</version>
   </parent>
   <groupId>org.lmdbjava</groupId>
   <artifactId>lmdbjava</artifactId>

From e5d94cb4a87a8f32ac462ee83c5172fa3898e53b Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 2 Dec 2022 12:24:09 +1100
Subject: [PATCH 139/322] sortpom-maven-plugin to only run on Java 11+

---
 pom.xml | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/pom.xml b/pom.xml
index ca07d4d7..0ab2fb2c 100644
--- a/pom.xml
+++ b/pom.xml
@@ -101,10 +101,6 @@
         <groupId>au.com.acegi</groupId>
         <artifactId>xml-format-maven-plugin</artifactId>
       </plugin>
-      <plugin>
-        <groupId>com.github.ekryd.sortpom</groupId>
-        <artifactId>sortpom-maven-plugin</artifactId>
-      </plugin>
       <plugin>
         <groupId>com.github.spotbugs</groupId>
         <artifactId>spotbugs-maven-plugin</artifactId>
@@ -243,6 +239,10 @@
       </activation>
       <build>
         <plugins>
+          <plugin>
+            <groupId>com.github.ekryd.sortpom</groupId>
+            <artifactId>sortpom-maven-plugin</artifactId>
+          </plugin>
           <plugin>
             <groupId>org.apache.maven.plugins</groupId>
             <artifactId>maven-checkstyle-plugin</artifactId>

From a1162e10c24ec54186562e71603d0a3bc7579b88 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 9 Dec 2022 13:12:38 +1100
Subject: [PATCH 140/322] Update GitHub Actions Workflow to modern actions and
 versions

Support for dependencies in the Sonatype snapshot repository has been
removed because the maven-settings-action does not presently support
editing the settings.xml produced by the setup-java action. The only
historical reason to add the Sonatype snapshot repository was to test
with the Acegi Standard Project superpom snapshots. This is usually
undertaken on a developer machine and then an Acegi Standard Project
superpom is released to Maven Central. As such having GitHub Actions
able to perform this testing is largely unnecessary and has been
removed for maintenance practicality.
---
 .github/workflows/maven.yml | 77 +++++++++++++++----------------------
 1 file changed, 30 insertions(+), 47 deletions(-)

diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml
index a272d491..a551b802 100644
--- a/.github/workflows/maven.yml
+++ b/.github/workflows/maven.yml
@@ -13,29 +13,20 @@ jobs:
 
     steps:
     - name: Check out Git repository
-      uses: actions/checkout@v2
+      uses: actions/checkout@v3
 
     - name: Set up Java and Maven
-      uses: actions/setup-java@v1
+      uses: actions/setup-java@v3
       with:
+        distribution: zulu
         java-version: 11
-
-    - name: Add OSSRH to the snapshot repositories list
-      uses: s4u/maven-settings-action@v2.1.0
-      with:
-        sonatypeSnapshots: true
-
-    - name: Cache Maven packages
-      uses: actions/cache@v1
-      with:
-        path: ~/.m2
-        key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.xml') }}
+        cache: maven
 
     - name: Build with Maven
       run: mvn -B verify
 
     - name: Upload code coverage to Codecov
-      uses: codecov/codecov-action@v1
+      uses: codecov/codecov-action@v3
 
   compatibility-checks:
     name: Java ${{ matrix.java }} on ${{ matrix.os }} Compatibility
@@ -48,29 +39,20 @@ jobs:
 
     steps:
       - name: Check out Git repository
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
 
       - name: Set up Java and Maven
-        uses: actions/setup-java@v1
+        uses: actions/setup-java@v3
         with:
+          distribution: zulu
           java-version: ${{ matrix.java }}
-
-      - name: Add OSSRH to the snapshot repositories list
-        uses: s4u/maven-settings-action@v2.1.0
-        with:
-          sonatypeSnapshots: true
-
-      - name: Cache Maven packages
-        uses: actions/cache@v1
-        with:
-          path: ~/.m2
-          key: ${{ runner.os }}-${{ matrix.java }}-m2-${{ hashFiles('**/pom.xml') }}
+          cache: maven
 
       - name: Test with Maven
         run: mvn -B test
 
       - name: Upload Surefire reports on test failure
-        uses: actions/upload-artifact@v1
+        uses: actions/upload-artifact@v3
         if: failure()
         with:
           name: surefire-test-log
@@ -84,30 +66,31 @@ jobs:
 
     steps:
     - name: Check out Git repository
-      uses: actions/checkout@v2
+      uses: actions/checkout@v3
 
     - name: Set up Java and Maven
-      uses: actions/setup-java@v1
+      uses: actions/setup-java@v3
       with:
+        distribution: zulu
         # Java version 8 required due to https://github.com/lmdbjava/lmdbjava/issues/116
         java-version: 8
-
-    - name: Add OSSRH to the snapshot repositories list
-      uses: s4u/maven-settings-action@v2.1.0
-      with:
-        sonatypeSnapshots: true
-
-    - name: Cache Maven packages
-      uses: actions/cache@v1
-      with:
-        path: ~/.m2
-        key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.xml') }}
+        cache: maven
+        server-id: ossrh
+        server-username: MAVEN_USERNAME
+        server-password: MAVEN_CENTRAL_TOKEN
+        gpg-private-key: ${{ secrets.gpg_private_key }}
+        gpg-passphrase: MAVEN_GPG_PASSPHRASE
 
     - name: Publish Maven package
-      uses: samuelmeuli/action-maven-publish@v1
+      run: mvn -Possrh-deploy deploy
+      env:
+        MAVEN_GPG_PASSPHRASE: ${{ secrets.gpg_passphrase }}
+        MAVEN_USERNAME: ${{ secrets.nexus_username }}
+        MAVEN_CENTRAL_TOKEN: ${{ secrets.nexus_password }}
+
+    - name: Debug settings.xml
+      uses: actions/upload-artifact@v3
+      if: failure()
       with:
-        gpg_private_key: ${{ secrets.gpg_private_key }}
-        gpg_passphrase: ${{ secrets.gpg_passphrase }}
-        nexus_username: ${{ secrets.nexus_username }}
-        nexus_password: ${{ secrets.nexus_password }}
-        maven_profiles: ossrh-deploy
+        name: settings.xml
+        path: $HOME/.m2/settings.xml

From bf9e32a5781eed7020c534772c2c2460f5923b16 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Thu, 2 Feb 2023 12:01:57 +1100
Subject: [PATCH 141/322] Copyright year only

---
 src/main/java/org/lmdbjava/BufferProxy.java          | 2 +-
 src/main/java/org/lmdbjava/ByteArrayProxy.java       | 2 +-
 src/main/java/org/lmdbjava/ByteBufProxy.java         | 2 +-
 src/main/java/org/lmdbjava/ByteBufferProxy.java      | 2 +-
 src/main/java/org/lmdbjava/CopyFlags.java            | 2 +-
 src/main/java/org/lmdbjava/Cursor.java               | 2 +-
 src/main/java/org/lmdbjava/CursorIterable.java       | 2 +-
 src/main/java/org/lmdbjava/Dbi.java                  | 2 +-
 src/main/java/org/lmdbjava/DbiFlags.java             | 2 +-
 src/main/java/org/lmdbjava/DirectBufferProxy.java    | 2 +-
 src/main/java/org/lmdbjava/Env.java                  | 2 +-
 src/main/java/org/lmdbjava/EnvFlags.java             | 2 +-
 src/main/java/org/lmdbjava/EnvInfo.java              | 2 +-
 src/main/java/org/lmdbjava/GetOp.java                | 2 +-
 src/main/java/org/lmdbjava/KeyRange.java             | 2 +-
 src/main/java/org/lmdbjava/KeyRangeType.java         | 2 +-
 src/main/java/org/lmdbjava/KeyVal.java               | 2 +-
 src/main/java/org/lmdbjava/Library.java              | 2 +-
 src/main/java/org/lmdbjava/LmdbException.java        | 2 +-
 src/main/java/org/lmdbjava/LmdbNativeException.java  | 2 +-
 src/main/java/org/lmdbjava/MaskedFlag.java           | 2 +-
 src/main/java/org/lmdbjava/Meta.java                 | 2 +-
 src/main/java/org/lmdbjava/PutFlags.java             | 2 +-
 src/main/java/org/lmdbjava/ResultCodeMapper.java     | 2 +-
 src/main/java/org/lmdbjava/SeekOp.java               | 2 +-
 src/main/java/org/lmdbjava/Stat.java                 | 2 +-
 src/main/java/org/lmdbjava/Txn.java                  | 2 +-
 src/main/java/org/lmdbjava/TxnFlags.java             | 2 +-
 src/main/java/org/lmdbjava/UnsafeAccess.java         | 2 +-
 src/main/java/org/lmdbjava/Verifier.java             | 2 +-
 src/main/java/org/lmdbjava/package-info.java         | 2 +-
 src/test/java/org/lmdbjava/ByteBufferProxyTest.java  | 2 +-
 src/test/java/org/lmdbjava/ComparatorTest.java       | 2 +-
 src/test/java/org/lmdbjava/CursorIterableTest.java   | 2 +-
 src/test/java/org/lmdbjava/CursorParamTest.java      | 2 +-
 src/test/java/org/lmdbjava/CursorTest.java           | 2 +-
 src/test/java/org/lmdbjava/DbiTest.java              | 2 +-
 src/test/java/org/lmdbjava/EnvTest.java              | 2 +-
 src/test/java/org/lmdbjava/KeyRangeTest.java         | 2 +-
 src/test/java/org/lmdbjava/LibraryTest.java          | 2 +-
 src/test/java/org/lmdbjava/MaskedFlagTest.java       | 2 +-
 src/test/java/org/lmdbjava/MetaTest.java             | 2 +-
 src/test/java/org/lmdbjava/ResultCodeMapperTest.java | 2 +-
 src/test/java/org/lmdbjava/TestUtils.java            | 2 +-
 src/test/java/org/lmdbjava/TutorialTest.java         | 2 +-
 src/test/java/org/lmdbjava/TxnTest.java              | 2 +-
 src/test/java/org/lmdbjava/VerifierTest.java         | 2 +-
 src/test/java/org/lmdbjava/package-info.java         | 2 +-
 48 files changed, 48 insertions(+), 48 deletions(-)

diff --git a/src/main/java/org/lmdbjava/BufferProxy.java b/src/main/java/org/lmdbjava/BufferProxy.java
index 01ff0608..bd58d7b6 100644
--- a/src/main/java/org/lmdbjava/BufferProxy.java
+++ b/src/main/java/org/lmdbjava/BufferProxy.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/ByteArrayProxy.java b/src/main/java/org/lmdbjava/ByteArrayProxy.java
index 4afa20ae..f6ddbef2 100644
--- a/src/main/java/org/lmdbjava/ByteArrayProxy.java
+++ b/src/main/java/org/lmdbjava/ByteArrayProxy.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/ByteBufProxy.java b/src/main/java/org/lmdbjava/ByteBufProxy.java
index 1029cdf3..d8bbc452 100644
--- a/src/main/java/org/lmdbjava/ByteBufProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufProxy.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
index 1292e2bd..0d1781b3 100644
--- a/src/main/java/org/lmdbjava/ByteBufferProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/CopyFlags.java b/src/main/java/org/lmdbjava/CopyFlags.java
index 52cbb234..88649a04 100644
--- a/src/main/java/org/lmdbjava/CopyFlags.java
+++ b/src/main/java/org/lmdbjava/CopyFlags.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/Cursor.java b/src/main/java/org/lmdbjava/Cursor.java
index ad6aaf8b..bc6b36e4 100644
--- a/src/main/java/org/lmdbjava/Cursor.java
+++ b/src/main/java/org/lmdbjava/Cursor.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/CursorIterable.java b/src/main/java/org/lmdbjava/CursorIterable.java
index 37edad1b..681f805b 100644
--- a/src/main/java/org/lmdbjava/CursorIterable.java
+++ b/src/main/java/org/lmdbjava/CursorIterable.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index 426e461e..96339873 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/DbiFlags.java b/src/main/java/org/lmdbjava/DbiFlags.java
index da263868..081fb80e 100644
--- a/src/main/java/org/lmdbjava/DbiFlags.java
+++ b/src/main/java/org/lmdbjava/DbiFlags.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/DirectBufferProxy.java b/src/main/java/org/lmdbjava/DirectBufferProxy.java
index 3073fd64..2a6b67c3 100644
--- a/src/main/java/org/lmdbjava/DirectBufferProxy.java
+++ b/src/main/java/org/lmdbjava/DirectBufferProxy.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index ea54b7a3..9a67c997 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/EnvFlags.java b/src/main/java/org/lmdbjava/EnvFlags.java
index fe942f58..ab54917a 100644
--- a/src/main/java/org/lmdbjava/EnvFlags.java
+++ b/src/main/java/org/lmdbjava/EnvFlags.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/EnvInfo.java b/src/main/java/org/lmdbjava/EnvInfo.java
index 274b341c..a1ae62ba 100644
--- a/src/main/java/org/lmdbjava/EnvInfo.java
+++ b/src/main/java/org/lmdbjava/EnvInfo.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/GetOp.java b/src/main/java/org/lmdbjava/GetOp.java
index 7fe2697f..9d36c204 100644
--- a/src/main/java/org/lmdbjava/GetOp.java
+++ b/src/main/java/org/lmdbjava/GetOp.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/KeyRange.java b/src/main/java/org/lmdbjava/KeyRange.java
index 76fe558e..d47c444c 100644
--- a/src/main/java/org/lmdbjava/KeyRange.java
+++ b/src/main/java/org/lmdbjava/KeyRange.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/KeyRangeType.java b/src/main/java/org/lmdbjava/KeyRangeType.java
index 77a55529..267e45c8 100644
--- a/src/main/java/org/lmdbjava/KeyRangeType.java
+++ b/src/main/java/org/lmdbjava/KeyRangeType.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/KeyVal.java b/src/main/java/org/lmdbjava/KeyVal.java
index f438597b..12b9f9af 100644
--- a/src/main/java/org/lmdbjava/KeyVal.java
+++ b/src/main/java/org/lmdbjava/KeyVal.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/Library.java b/src/main/java/org/lmdbjava/Library.java
index 7de85033..44b17492 100644
--- a/src/main/java/org/lmdbjava/Library.java
+++ b/src/main/java/org/lmdbjava/Library.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/LmdbException.java b/src/main/java/org/lmdbjava/LmdbException.java
index 8dd52ea6..b3aea56e 100644
--- a/src/main/java/org/lmdbjava/LmdbException.java
+++ b/src/main/java/org/lmdbjava/LmdbException.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/LmdbNativeException.java b/src/main/java/org/lmdbjava/LmdbNativeException.java
index 4073cf59..3f559806 100644
--- a/src/main/java/org/lmdbjava/LmdbNativeException.java
+++ b/src/main/java/org/lmdbjava/LmdbNativeException.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/MaskedFlag.java b/src/main/java/org/lmdbjava/MaskedFlag.java
index e3419c13..9bdef636 100644
--- a/src/main/java/org/lmdbjava/MaskedFlag.java
+++ b/src/main/java/org/lmdbjava/MaskedFlag.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/Meta.java b/src/main/java/org/lmdbjava/Meta.java
index bceb11a9..6f392701 100644
--- a/src/main/java/org/lmdbjava/Meta.java
+++ b/src/main/java/org/lmdbjava/Meta.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/PutFlags.java b/src/main/java/org/lmdbjava/PutFlags.java
index ff397e54..48bc243b 100644
--- a/src/main/java/org/lmdbjava/PutFlags.java
+++ b/src/main/java/org/lmdbjava/PutFlags.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/ResultCodeMapper.java b/src/main/java/org/lmdbjava/ResultCodeMapper.java
index 7566f0b1..809628ac 100644
--- a/src/main/java/org/lmdbjava/ResultCodeMapper.java
+++ b/src/main/java/org/lmdbjava/ResultCodeMapper.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/SeekOp.java b/src/main/java/org/lmdbjava/SeekOp.java
index c86211a9..ed5fb47c 100644
--- a/src/main/java/org/lmdbjava/SeekOp.java
+++ b/src/main/java/org/lmdbjava/SeekOp.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/Stat.java b/src/main/java/org/lmdbjava/Stat.java
index 605b5f4d..42b344fb 100644
--- a/src/main/java/org/lmdbjava/Stat.java
+++ b/src/main/java/org/lmdbjava/Stat.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/Txn.java b/src/main/java/org/lmdbjava/Txn.java
index a6f5218a..f21552e7 100644
--- a/src/main/java/org/lmdbjava/Txn.java
+++ b/src/main/java/org/lmdbjava/Txn.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/TxnFlags.java b/src/main/java/org/lmdbjava/TxnFlags.java
index 3753d6c2..0379bfa7 100644
--- a/src/main/java/org/lmdbjava/TxnFlags.java
+++ b/src/main/java/org/lmdbjava/TxnFlags.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/UnsafeAccess.java b/src/main/java/org/lmdbjava/UnsafeAccess.java
index b5c06d88..836cda75 100644
--- a/src/main/java/org/lmdbjava/UnsafeAccess.java
+++ b/src/main/java/org/lmdbjava/UnsafeAccess.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/Verifier.java b/src/main/java/org/lmdbjava/Verifier.java
index 493eb17e..9807d0b8 100644
--- a/src/main/java/org/lmdbjava/Verifier.java
+++ b/src/main/java/org/lmdbjava/Verifier.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/main/java/org/lmdbjava/package-info.java b/src/main/java/org/lmdbjava/package-info.java
index c60e2e1a..52c8551a 100644
--- a/src/main/java/org/lmdbjava/package-info.java
+++ b/src/main/java/org/lmdbjava/package-info.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
index 2469ae7c..3daaea5f 100644
--- a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
+++ b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/ComparatorTest.java b/src/test/java/org/lmdbjava/ComparatorTest.java
index 2faa224a..77c5ca37 100644
--- a/src/test/java/org/lmdbjava/ComparatorTest.java
+++ b/src/test/java/org/lmdbjava/ComparatorTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index 036f3bf8..247ef791 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/CursorParamTest.java b/src/test/java/org/lmdbjava/CursorParamTest.java
index 0ae70dd8..b9fd60e3 100644
--- a/src/test/java/org/lmdbjava/CursorParamTest.java
+++ b/src/test/java/org/lmdbjava/CursorParamTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/CursorTest.java b/src/test/java/org/lmdbjava/CursorTest.java
index 1a685487..51b78806 100644
--- a/src/test/java/org/lmdbjava/CursorTest.java
+++ b/src/test/java/org/lmdbjava/CursorTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 640c2905..e52bd28d 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index 6fc03021..f26d42f3 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/KeyRangeTest.java b/src/test/java/org/lmdbjava/KeyRangeTest.java
index d1802072..1b4384f9 100644
--- a/src/test/java/org/lmdbjava/KeyRangeTest.java
+++ b/src/test/java/org/lmdbjava/KeyRangeTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/LibraryTest.java b/src/test/java/org/lmdbjava/LibraryTest.java
index 2c7ce1c6..df5ae89d 100644
--- a/src/test/java/org/lmdbjava/LibraryTest.java
+++ b/src/test/java/org/lmdbjava/LibraryTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/MaskedFlagTest.java b/src/test/java/org/lmdbjava/MaskedFlagTest.java
index 37202b76..0dbc8b62 100644
--- a/src/test/java/org/lmdbjava/MaskedFlagTest.java
+++ b/src/test/java/org/lmdbjava/MaskedFlagTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/MetaTest.java b/src/test/java/org/lmdbjava/MetaTest.java
index 4d7fd01d..922c4368 100644
--- a/src/test/java/org/lmdbjava/MetaTest.java
+++ b/src/test/java/org/lmdbjava/MetaTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/ResultCodeMapperTest.java b/src/test/java/org/lmdbjava/ResultCodeMapperTest.java
index b5699749..723c22ca 100644
--- a/src/test/java/org/lmdbjava/ResultCodeMapperTest.java
+++ b/src/test/java/org/lmdbjava/ResultCodeMapperTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/TestUtils.java b/src/test/java/org/lmdbjava/TestUtils.java
index 8ef16ec1..05dfb0cc 100644
--- a/src/test/java/org/lmdbjava/TestUtils.java
+++ b/src/test/java/org/lmdbjava/TestUtils.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/TutorialTest.java b/src/test/java/org/lmdbjava/TutorialTest.java
index 09536382..92f69bb8 100644
--- a/src/test/java/org/lmdbjava/TutorialTest.java
+++ b/src/test/java/org/lmdbjava/TutorialTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/TxnTest.java b/src/test/java/org/lmdbjava/TxnTest.java
index 87969e1f..f8a0b5d3 100644
--- a/src/test/java/org/lmdbjava/TxnTest.java
+++ b/src/test/java/org/lmdbjava/TxnTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/VerifierTest.java b/src/test/java/org/lmdbjava/VerifierTest.java
index fd49ffec..27bb598b 100644
--- a/src/test/java/org/lmdbjava/VerifierTest.java
+++ b/src/test/java/org/lmdbjava/VerifierTest.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/src/test/java/org/lmdbjava/package-info.java b/src/test/java/org/lmdbjava/package-info.java
index c404b678..baaacbe8 100644
--- a/src/test/java/org/lmdbjava/package-info.java
+++ b/src/test/java/org/lmdbjava/package-info.java
@@ -2,7 +2,7 @@
  * #%L
  * LmdbJava
  * %%
- * Copyright (C) 2016 - 2022 The LmdbJava Open Source Project
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
  * %%
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

From 0d9ca495c7d5b330994dded7f7c28f4f928afdcf Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Thu, 2 Feb 2023 13:10:23 +1100
Subject: [PATCH 142/322] Remove duplicate Netty dependency declaration

---
 pom.xml | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/pom.xml b/pom.xml
index 0ab2fb2c..379471ba 100644
--- a/pom.xml
+++ b/pom.xml
@@ -56,12 +56,6 @@
       <version>4.1.76.Final</version>
       <optional>true</optional>
     </dependency>
-    <dependency>
-      <groupId>io.netty</groupId>
-      <artifactId>netty-buffer</artifactId>
-      <version>4.1.76.Final</version>
-      <optional>true</optional>
-    </dependency>
     <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>

From 5b386c21c26a262e46c34767a08f446c411114e2 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 3 Feb 2023 09:05:52 +1100
Subject: [PATCH 143/322] Update to Acegi Standard Project 0.6.7

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 379471ba..cd5291c0 100644
--- a/pom.xml
+++ b/pom.xml
@@ -4,7 +4,7 @@
   <parent>
     <groupId>au.com.acegi</groupId>
     <artifactId>acegi-standard-project</artifactId>
-    <version>0.6.4</version>
+    <version>0.6.7</version>
   </parent>
   <groupId>org.lmdbjava</groupId>
   <artifactId>lmdbjava</artifactId>

From cc0a1739ff9d8613f4aaf1d3e730b35de8cf51c1 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 3 Feb 2023 09:06:00 +1100
Subject: [PATCH 144/322] Remove LGTM badges as service has been discontinued

---
 README.md | 2 --
 1 file changed, 2 deletions(-)

diff --git a/README.md b/README.md
index 4547b786..3b8f4753 100644
--- a/README.md
+++ b/README.md
@@ -2,8 +2,6 @@
 [![codecov](https://codecov.io/gh/lmdbjava/lmdbjava/branch/master/graph/badge.svg)](https://codecov.io/gh/lmdbjava/lmdbjava)
 [![Javadocs](http://www.javadoc.io/badge/org.lmdbjava/lmdbjava.svg?color=blue)](http://www.javadoc.io/doc/org.lmdbjava/lmdbjava)
 [![Maven Central](https://img.shields.io/maven-central/v/org.lmdbjava/lmdbjava.svg?maxAge=3600)](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22org.lmdbjava%22%20AND%20a%3A%22lmdbjava%22)
-[![Total alerts](https://img.shields.io/lgtm/alerts/g/lmdbjava/lmdbjava.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/lmdbjava/lmdbjava/alerts/)
-[![Language grade: Java](https://img.shields.io/lgtm/grade/java/g/lmdbjava/lmdbjava.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/lmdbjava/lmdbjava/context:java)
 
 # LMDB for Java
 

From 39a1c230bb72a668656f57b74a3f152fa4b48f8f Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 3 Feb 2023 09:12:55 +1100
Subject: [PATCH 145/322] Refer to JVM startup options (resolves #205)

---
 src/test/java/org/lmdbjava/TutorialTest.java | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/test/java/org/lmdbjava/TutorialTest.java b/src/test/java/org/lmdbjava/TutorialTest.java
index 92f69bb8..0385d952 100644
--- a/src/test/java/org/lmdbjava/TutorialTest.java
+++ b/src/test/java/org/lmdbjava/TutorialTest.java
@@ -65,6 +65,10 @@
  * required system libraries. If you are using another 64-bit platform, you'll
  * need to install the LMDB system library yourself. 32-bit platforms are not
  * supported.
+ *
+ * <p>
+ * Start the JVM with arguments <code>--add-opens java.base/java.nio=ALL-UNNAMED
+ * --add-opens java.base/sun.nio.ch=ALL-UNNAMED</code> to suppress JVM warnings.
  */
 public final class TutorialTest {
 

From 4b141bc80ce41b30ac39869ef87fba1b45162acc Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 3 Feb 2023 09:18:27 +1100
Subject: [PATCH 146/322] Update to JNR Constants 0.10.4

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index cd5291c0..d9979693 100644
--- a/pom.xml
+++ b/pom.xml
@@ -21,7 +21,7 @@
     <dependency>
       <groupId>com.github.jnr</groupId>
       <artifactId>jnr-constants</artifactId>
-      <version>0.10.3</version>
+      <version>0.10.4</version>
     </dependency>
     <dependency>
       <groupId>com.github.jnr</groupId>

From 9c19c154d7490d8634143478710c8b414fe4d992 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 3 Feb 2023 09:18:40 +1100
Subject: [PATCH 147/322] Update to JNR FFI 2.2.13

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index d9979693..68a88d37 100644
--- a/pom.xml
+++ b/pom.xml
@@ -26,7 +26,7 @@
     <dependency>
       <groupId>com.github.jnr</groupId>
       <artifactId>jnr-ffi</artifactId>
-      <version>2.2.12</version>
+      <version>2.2.13</version>
     </dependency>
     <dependency>
       <groupId>com.google.code.findbugs</groupId>

From 9e25aa95b5b7262bc735f881399bdd83f133f5f3 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 3 Feb 2023 09:18:49 +1100
Subject: [PATCH 148/322] Update to Netty 4.1.87.Final

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 68a88d37..536aed04 100644
--- a/pom.xml
+++ b/pom.xml
@@ -53,7 +53,7 @@
     <dependency>
       <groupId>io.netty</groupId>
       <artifactId>netty-buffer</artifactId>
-      <version>4.1.76.Final</version>
+      <version>4.1.87.Final</version>
       <optional>true</optional>
     </dependency>
     <dependency>

From bbee8495132ead6d6c6a69514e18a603191eaad6 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 3 Feb 2023 09:18:59 +1100
Subject: [PATCH 149/322] Update to Agrona 1.17.1

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 536aed04..9067cb38 100644
--- a/pom.xml
+++ b/pom.xml
@@ -63,7 +63,7 @@
     <dependency>
       <groupId>org.agrona</groupId>
       <artifactId>agrona</artifactId>
-      <version>1.15.1</version>
+      <version>1.17.1</version>
       <optional>true</optional>
     </dependency>
     <dependency>

From bb26a83bc1a92f20f6a6ccabba5e44afcf77ae28 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 3 Feb 2023 10:51:07 +1100
Subject: [PATCH 150/322] Cursor.close() must release KeyVal even if write Txn
 closed (fixes #197)

---
 src/main/java/org/lmdbjava/Cursor.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/org/lmdbjava/Cursor.java b/src/main/java/org/lmdbjava/Cursor.java
index bc6b36e4..bcbbb61c 100644
--- a/src/main/java/org/lmdbjava/Cursor.java
+++ b/src/main/java/org/lmdbjava/Cursor.java
@@ -72,11 +72,11 @@ public void close() {
     if (closed) {
       return;
     }
+    kv.close();
     if (SHOULD_CHECK && !txn.isReadOnly()) {
       txn.checkReady();
     }
     LIB.mdb_cursor_close(ptrCursor);
-    kv.close();
     closed = true;
   }
 

From 87dab318fe4d1898e99b3fac779c695083f2e0ba Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 3 Feb 2023 11:21:01 +1100
Subject: [PATCH 151/322] Clarify concurrent requirements for Env methods
 (fixes #195)

---
 src/main/java/org/lmdbjava/Env.java | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 9a67c997..1ca90367 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -170,6 +170,9 @@ public void copy(final File path, final CopyFlags... flags) {
    * If an unnamed {@link Dbi} is being used to store data, this method will
    * attempt to return all such keys from the unnamed database.
    *
+   * <p>
+   * This method must not be called from concurrent threads.
+   *
    * @return a list of DBI names (never null)
    */
   public List<byte[]> getDbiNames() {
@@ -284,6 +287,9 @@ public Dbi<T> openDbi(final String name, final Comparator<T> comparator,
   /**
    * Open the {@link Dbi}.
    *
+   * <p>
+   * This method must not be called from concurrent threads.
+   *
    * @param name  name of the database (or null if no name is required)
    * @param flags to open the database with
    * @return a database that is ready to use

From 9f821c0eaa33ec12f226c9396c1a1d6e005c0e33 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 3 Feb 2023 11:50:50 +1100
Subject: [PATCH 152/322] Additional JavaDocs related to #195

---
 src/main/java/org/lmdbjava/Env.java | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 1ca90367..a9611339 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -285,10 +285,7 @@ public Dbi<T> openDbi(final String name, final Comparator<T> comparator,
   }
 
   /**
-   * Open the {@link Dbi}.
-   *
-   * <p>
-   * This method must not be called from concurrent threads.
+   * Convenience method that opens a {@link Dbi} with a UTF-8 database name.
    *
    * @param name  name of the database (or null if no name is required)
    * @param flags to open the database with
@@ -315,6 +312,10 @@ public Dbi<T> openDbi(final byte[] name, final DbiFlags... flags) {
    * comparator is typically more efficient (as there is no need for the native
    * library to call back into Java for the comparator result).
    *
+   * <p>
+   * This method (and its overloaded convenience variants) must not be called
+   * from concurrent threads.
+   *
    * @param name       name of the database (or null if no name is required)
    * @param comparator custom comparator callback (or null to use LMDB default)
    * @param flags      to open the database with

From 4182ad1b6b9912708ca2dfc8e054941c2aad83d2 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 3 Feb 2023 12:11:31 +1100
Subject: [PATCH 153/322] Dbi.openDbi(..) to support user-provided Txn (fixes
 #192)

---
 src/main/java/org/lmdbjava/Env.java | 46 +++++++++++++++++++++--------
 1 file changed, 34 insertions(+), 12 deletions(-)

diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index a9611339..5de8bd5a 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -265,13 +265,11 @@ public boolean isReadOnly() {
    * @return a database that is ready to use
    */
   public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
-    final byte[] nameBytes = name == null ? null : name.getBytes(UTF_8);
-    return openDbi(nameBytes, flags);
+    return openDbi(name, null, flags);
   }
 
   /**
-   * Convenience method that opens a {@link Dbi} with a UTF-8 database name
-   * and custom comparator.
+   * Convenience method that opens a {@link Dbi} with a UTF-8 database name.
    *
    * @param name       name of the database (or null if no name is required)
    * @param comparator custom comparator callback (or null to use LMDB default)
@@ -285,22 +283,44 @@ public Dbi<T> openDbi(final String name, final Comparator<T> comparator,
   }
 
   /**
-   * Convenience method that opens a {@link Dbi} with a UTF-8 database name.
+   * Convenience method that opens a {@link Dbi}.
    *
    * @param name  name of the database (or null if no name is required)
    * @param flags to open the database with
    * @return a database that is ready to use
    */
   public Dbi<T> openDbi(final byte[] name, final DbiFlags... flags) {
+    return openDbi(name, null, flags);
+  }
+
+  /**
+   * Convenience method that opens a {@link Dbi} inside a private transaction.
+   *
+   * <p>
+   * This method will automatically commit the private transaction before
+   * returning. This ensures the <code>Dbi</code> is available in the
+   * <code>Env</code>.
+   *
+   * @param name       name of the database (or null if no name is required)
+   * @param comparator custom comparator callback (or null to use LMDB default)
+   * @param flags      to open the database with
+   * @return a database that is ready to use
+   */
+  public Dbi<T> openDbi(final byte[] name, final Comparator<T> comparator,
+                        final DbiFlags... flags) {
     try (Txn<T> txn = readOnly ? txnRead() : txnWrite()) {
-      final Dbi<T> dbi = new Dbi<>(this, txn, name, null, flags);
+      final Dbi<T> dbi = openDbi(txn, name, comparator, flags);
       txn.commit(); // even RO Txns require a commit to retain Dbi in Env
       return dbi;
     }
   }
 
   /**
-   * Open the {@link Dbi}.
+   * Open the {@link Dbi} using the passed {@link Txn}.
+   *
+   * <p>
+   * The caller must commit the transaction after this method returns in order
+   * to retain the <code>Dbi</code> in the <code>Env</code>.
    *
    * <p>
    * If a custom comparator is specified, this comparator is called from LMDB
@@ -316,18 +336,20 @@ public Dbi<T> openDbi(final byte[] name, final DbiFlags... flags) {
    * This method (and its overloaded convenience variants) must not be called
    * from concurrent threads.
    *
+   * @param txn        transaction to use (required; not closed)
    * @param name       name of the database (or null if no name is required)
    * @param comparator custom comparator callback (or null to use LMDB default)
    * @param flags      to open the database with
    * @return a database that is ready to use
    */
-  public Dbi<T> openDbi(final byte[] name, final Comparator<T> comparator,
+  public Dbi<T> openDbi(final Txn<T> txn, final byte[] name,
+                        final Comparator<T> comparator,
                         final DbiFlags... flags) {
-    try (Txn<T> txn = readOnly ? txnRead() : txnWrite()) {
-      final Dbi<T> dbi = new Dbi<>(this, txn, name, comparator, flags);
-      txn.commit(); // even RO Txns require a commit to retain Dbi in Env
-      return dbi;
+    if (SHOULD_CHECK) {
+      requireNonNull(txn);
+      txn.checkReady();
     }
+    return new Dbi<>(this, txn, name, comparator, flags);
   }
 
   /**

From 7a007fa3660d560c8a8b18daca2e45f0b4eab9ac Mon Sep 17 00:00:00 2001
From: "lgtm-com[bot]" <43144390+lgtm-com[bot]@users.noreply.github.com>
Date: Fri, 3 Feb 2023 12:26:24 +1100
Subject: [PATCH 154/322] Add CodeQL workflow for GitHub code scanning (#204)

Co-authored-by: LGTM Migrator <lgtm-migrator@users.noreply.github.com>
---
 .github/workflows/codeql.yml | 41 ++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 .github/workflows/codeql.yml

diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml
new file mode 100644
index 00000000..dd93488f
--- /dev/null
+++ b/.github/workflows/codeql.yml
@@ -0,0 +1,41 @@
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+  schedule:
+    - cron: "12 1 * * 0"
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ java ]
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@v2
+        with:
+          languages: ${{ matrix.language }}
+          queries: +security-and-quality
+
+      - name: Autobuild
+        uses: github/codeql-action/autobuild@v2
+
+      - name: Perform CodeQL Analysis
+        uses: github/codeql-action/analyze@v2
+        with:
+          category: "/language:${{ matrix.language }}"

From 66d9f7abc83a50f73d5d149b733a3edf6ebc524a Mon Sep 17 00:00:00 2001
From: danielcranford <ibelievekip@gmail.com>
Date: Fri, 3 Feb 2023 16:17:48 -0500
Subject: [PATCH 155/322] Replacing OneToOneConcurrentArrayQueue with
 ArrayDeque since it is thread local (#201)

Co-authored-by: dcranford <daniel.cranford@red-alpha.com>
---
 src/main/java/org/lmdbjava/DirectBufferProxy.java | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/main/java/org/lmdbjava/DirectBufferProxy.java b/src/main/java/org/lmdbjava/DirectBufferProxy.java
index 2a6b67c3..ac46dec5 100644
--- a/src/main/java/org/lmdbjava/DirectBufferProxy.java
+++ b/src/main/java/org/lmdbjava/DirectBufferProxy.java
@@ -27,11 +27,11 @@
 import static org.lmdbjava.UnsafeAccess.UNSAFE;
 
 import java.nio.ByteBuffer;
+import java.util.ArrayDeque;
 
 import jnr.ffi.Pointer;
 import org.agrona.DirectBuffer;
 import org.agrona.MutableDirectBuffer;
-import org.agrona.concurrent.OneToOneConcurrentArrayQueue;
 import org.agrona.concurrent.UnsafeBuffer;
 
 /**
@@ -55,8 +55,8 @@ public final class DirectBufferProxy extends BufferProxy<DirectBuffer> {
    * of a negative length) then that buffer is used. If no valid buffer is
    * found, a new buffer is created.
    */
-  private static final ThreadLocal<OneToOneConcurrentArrayQueue<DirectBuffer>> BUFFERS
-      = withInitial(() -> new OneToOneConcurrentArrayQueue<>(16));
+  private static final ThreadLocal<ArrayDeque<DirectBuffer>> BUFFERS
+      = withInitial(() -> new ArrayDeque<>(16));
 
   private DirectBufferProxy() {
   }
@@ -100,7 +100,7 @@ public static int compareBuff(final DirectBuffer o1, final DirectBuffer o2) {
 
   @Override
   protected DirectBuffer allocate() {
-    final OneToOneConcurrentArrayQueue<DirectBuffer> q = BUFFERS.get();
+    final ArrayDeque<DirectBuffer> q = BUFFERS.get();
     final DirectBuffer buffer = q.poll();
 
     if (buffer != null && buffer.capacity() >= 0) {
@@ -118,7 +118,7 @@ protected int compare(final DirectBuffer o1, final DirectBuffer o2) {
 
   @Override
   protected void deallocate(final DirectBuffer buff) {
-    final OneToOneConcurrentArrayQueue<DirectBuffer> q = BUFFERS.get();
+    final ArrayDeque<DirectBuffer> q = BUFFERS.get();
     q.offer(buff);
   }
 

From 3db0defb700e4ca337ae9824358d5589057b209e Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Sat, 4 Feb 2023 10:06:32 +1100
Subject: [PATCH 156/322] Add protection for closed env (#186)

---
 pom.xml                                       |   8 ++
 src/main/java/org/lmdbjava/Cursor.java        |  20 +++-
 src/main/java/org/lmdbjava/Dbi.java           |  15 ++-
 src/main/java/org/lmdbjava/Env.java           |   6 +
 src/main/java/org/lmdbjava/Txn.java           |  21 ++++
 .../java/org/lmdbjava/CursorIterableTest.java |  54 +++++++++
 src/test/java/org/lmdbjava/CursorTest.java    |  81 ++++++++++++++
 src/test/java/org/lmdbjava/DbiTest.java       | 103 ++++++++++++++++++
 src/test/java/org/lmdbjava/TxnTest.java       |  45 ++++++++
 9 files changed, 349 insertions(+), 4 deletions(-)

diff --git a/pom.xml b/pom.xml
index 9067cb38..b1a87cdd 100644
--- a/pom.xml
+++ b/pom.xml
@@ -143,6 +143,14 @@
           </execution>
         </executions>
       </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-surefire-plugin</artifactId>
+        <configuration>
+          <forkCount>1</forkCount>
+          <reuseForks>false</reuseForks>
+        </configuration>
+      </plugin>
       <plugin>
         <groupId>org.basepom.maven</groupId>
         <artifactId>duplicate-finder-maven-plugin</artifactId>
diff --git a/src/main/java/org/lmdbjava/Cursor.java b/src/main/java/org/lmdbjava/Cursor.java
index bcbbb61c..aa98a9ea 100644
--- a/src/main/java/org/lmdbjava/Cursor.java
+++ b/src/main/java/org/lmdbjava/Cursor.java
@@ -51,13 +51,15 @@ public final class Cursor<T> implements AutoCloseable {
   private final KeyVal<T> kv;
   private final Pointer ptrCursor;
   private Txn<T> txn;
+  private final Env<T> env;
 
-  Cursor(final Pointer ptr, final Txn<T> txn) {
+  Cursor(final Pointer ptr, final Txn<T> txn, final Env<T> env) {
     requireNonNull(ptr);
     requireNonNull(txn);
     this.ptrCursor = ptr;
     this.txn = txn;
     this.kv = txn.newKeyVal();
+    this.env = env;
   }
 
   /**
@@ -73,8 +75,11 @@ public void close() {
       return;
     }
     kv.close();
-    if (SHOULD_CHECK && !txn.isReadOnly()) {
-      txn.checkReady();
+    if (SHOULD_CHECK) {
+      env.checkNotClosed();
+      if (!txn.isReadOnly()) {
+        txn.checkReady();
+      }
     }
     LIB.mdb_cursor_close(ptrCursor);
     closed = true;
@@ -91,6 +96,7 @@ public void close() {
    */
   public long count() {
     if (SHOULD_CHECK) {
+      env.checkNotClosed();
       checkNotClosed();
       txn.checkReady();
     }
@@ -109,6 +115,7 @@ public long count() {
    */
   public void delete(final PutFlags... f) {
     if (SHOULD_CHECK) {
+      env.checkNotClosed();
       checkNotClosed();
       txn.checkReady();
       txn.checkWritesAllowed();
@@ -138,6 +145,7 @@ public boolean get(final T key, final T data, final SeekOp op) {
     if (SHOULD_CHECK) {
       requireNonNull(key);
       requireNonNull(op);
+      env.checkNotClosed();
       checkNotClosed();
       txn.checkReady();
     }
@@ -168,6 +176,7 @@ public boolean get(final T key, final GetOp op) {
     if (SHOULD_CHECK) {
       requireNonNull(key);
       requireNonNull(op);
+      env.checkNotClosed();
       checkNotClosed();
       txn.checkReady();
     }
@@ -238,6 +247,7 @@ public boolean put(final T key, final T val, final PutFlags... op) {
     if (SHOULD_CHECK) {
       requireNonNull(key);
       requireNonNull(val);
+      env.checkNotClosed();
       checkNotClosed();
       txn.checkReady();
       txn.checkWritesAllowed();
@@ -281,6 +291,7 @@ public void putMultiple(final T key, final T val, final int elements,
       requireNonNull(txn);
       requireNonNull(key);
       requireNonNull(val);
+      env.checkNotClosed();
       txn.checkReady();
       txn.checkWritesAllowed();
     }
@@ -311,6 +322,7 @@ public void putMultiple(final T key, final T val, final int elements,
   public void renew(final Txn<T> newTxn) {
     if (SHOULD_CHECK) {
       requireNonNull(newTxn);
+      env.checkNotClosed();
       checkNotClosed();
       this.txn.checkReadOnly(); // existing
       newTxn.checkReadOnly();
@@ -339,6 +351,7 @@ public void renew(final Txn<T> newTxn) {
   public T reserve(final T key, final int size, final PutFlags... op) {
     if (SHOULD_CHECK) {
       requireNonNull(key);
+      env.checkNotClosed();
       checkNotClosed();
       txn.checkReady();
       txn.checkWritesAllowed();
@@ -361,6 +374,7 @@ public T reserve(final T key, final int size, final PutFlags... op) {
   public boolean seek(final SeekOp op) {
     if (SHOULD_CHECK) {
       requireNonNull(op);
+      env.checkNotClosed();
       checkNotClosed();
       txn.checkReady();
     }
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index 96339873..3f36bbeb 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -104,6 +104,9 @@ public final class Dbi<T> {
    */
   public void close() {
     clean();
+    if (SHOULD_CHECK) {
+      env.checkNotClosed();
+    }
     LIB.mdb_dbi_close(env.pointer(), ptr);
   }
 
@@ -199,6 +202,7 @@ public void drop(final Txn<T> txn) {
   public void drop(final Txn<T> txn, final boolean delete) {
     if (SHOULD_CHECK) {
       requireNonNull(txn);
+      env.checkNotClosed();
       txn.checkReady();
       txn.checkWritesAllowed();
     }
@@ -228,6 +232,7 @@ public T get(final Txn<T> txn, final T key) {
     if (SHOULD_CHECK) {
       requireNonNull(txn);
       requireNonNull(key);
+      env.checkNotClosed();
       txn.checkReady();
     }
     txn.kv().keyIn(key);
@@ -295,6 +300,7 @@ public CursorIterable<T> iterate(final Txn<T> txn, final KeyRange<T> range,
     if (SHOULD_CHECK) {
       requireNonNull(txn);
       requireNonNull(range);
+      env.checkNotClosed();
       txn.checkReady();
     }
     final Comparator<T> useComp;
@@ -313,6 +319,9 @@ public CursorIterable<T> iterate(final Txn<T> txn, final KeyRange<T> range,
   * @return the list of flags this Dbi was created with
    */
   public List<DbiFlags> listFlags(final Txn<T> txn) {
+    if (SHOULD_CHECK) {
+      env.checkNotClosed();
+    }
     final IntByReference resultPtr = new IntByReference();
     checkRc(LIB.mdb_dbi_flags(txn.pointer(), ptr, resultPtr));
 
@@ -348,11 +357,12 @@ public List<DbiFlags> listFlags(final Txn<T> txn) {
   public Cursor<T> openCursor(final Txn<T> txn) {
     if (SHOULD_CHECK) {
       requireNonNull(txn);
+      env.checkNotClosed();
       txn.checkReady();
     }
     final PointerByReference cursorPtr = new PointerByReference();
     checkRc(LIB.mdb_cursor_open(txn.pointer(), ptr, cursorPtr));
-    return new Cursor<>(cursorPtr.getValue(), txn);
+    return new Cursor<>(cursorPtr.getValue(), txn, env);
   }
 
   /**
@@ -392,6 +402,7 @@ public boolean put(final Txn<T> txn, final T key, final T val,
       requireNonNull(txn);
       requireNonNull(key);
       requireNonNull(val);
+      env.checkNotClosed();
       txn.checkReady();
       txn.checkWritesAllowed();
     }
@@ -434,6 +445,7 @@ public T reserve(final Txn<T> txn, final T key, final int size,
     if (SHOULD_CHECK) {
       requireNonNull(txn);
       requireNonNull(key);
+      env.checkNotClosed();
       txn.checkReady();
       txn.checkWritesAllowed();
     }
@@ -455,6 +467,7 @@ public T reserve(final Txn<T> txn, final T key, final int size,
   public Stat stat(final Txn<T> txn) {
     if (SHOULD_CHECK) {
       requireNonNull(txn);
+      env.checkNotClosed();
       txn.checkReady();
     }
     final MDB_stat stat = new MDB_stat(RUNTIME);
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 5de8bd5a..45db5064 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -423,6 +423,12 @@ Pointer pointer() {
     return ptr;
   }
 
+  void checkNotClosed() {
+    if (closed) {
+      throw new AlreadyClosedException();
+    }
+  }
+
   private void validateDirectoryEmpty(final File path) {
     if (!path.exists()) {
       throw new InvalidCopyDestination("Path does not exist");
diff --git a/src/main/java/org/lmdbjava/Txn.java b/src/main/java/org/lmdbjava/Txn.java
index f21552e7..f3071152 100644
--- a/src/main/java/org/lmdbjava/Txn.java
+++ b/src/main/java/org/lmdbjava/Txn.java
@@ -22,6 +22,7 @@
 
 import static jnr.ffi.Memory.allocateDirect;
 import static jnr.ffi.NativeType.ADDRESS;
+import static org.lmdbjava.Env.SHOULD_CHECK;
 import static org.lmdbjava.Library.LIB;
 import static org.lmdbjava.Library.RUNTIME;
 import static org.lmdbjava.MaskedFlag.isSet;
@@ -49,6 +50,7 @@ public final class Txn<T> implements AutoCloseable {
   private final BufferProxy<T> proxy;
   private final Pointer ptr;
   private final boolean readOnly;
+  private final Env<T> env;
   private State state;
 
   Txn(final Env<T> env, final Txn<T> parent, final BufferProxy<T> proxy,
@@ -60,6 +62,7 @@ public final class Txn<T> implements AutoCloseable {
     if (env.isReadOnly() && !this.readOnly) {
       throw new EnvIsReadOnly();
     }
+    this.env = env;
     this.parent = parent;
     if (parent != null && parent.isReadOnly() != this.readOnly) {
       throw new IncompatibleParent();
@@ -76,6 +79,9 @@ public final class Txn<T> implements AutoCloseable {
    * Aborts this transaction.
    */
   public void abort() {
+    if (SHOULD_CHECK) {
+      env.checkNotClosed();
+    }
     checkReady();
     state = DONE;
     LIB.mdb_txn_abort(ptr);
@@ -91,6 +97,9 @@ public void abort() {
    */
   @Override
   public void close() {
+    if (SHOULD_CHECK) {
+      env.checkNotClosed();
+    }
     if (state == RELEASED) {
       return;
     }
@@ -105,6 +114,9 @@ public void close() {
    * Commits this transaction.
    */
   public void commit() {
+    if (SHOULD_CHECK) {
+      env.checkNotClosed();
+    }
     checkReady();
     state = DONE;
     checkRc(LIB.mdb_txn_commit(ptr));
@@ -116,6 +128,9 @@ public void commit() {
    * @return A transaction ID, valid if input is an active transaction
    */
   public long getId() {
+    if (SHOULD_CHECK) {
+      env.checkNotClosed();
+    }
     return LIB.mdb_txn_id(ptr);
   }
 
@@ -153,6 +168,9 @@ public T key() {
    * Renews a read-only transaction previously released by {@link #reset()}.
    */
   public void renew() {
+    if (SHOULD_CHECK) {
+      env.checkNotClosed();
+    }
     if (state != RESET) {
       throw new NotResetException();
     }
@@ -166,6 +184,9 @@ public void renew() {
    * can be reused upon calling {@link #renew()}.
    */
   public void reset() {
+    if (SHOULD_CHECK) {
+      env.checkNotClosed();
+    }
     checkReadOnly();
     if (state != READY && state != DONE) {
       throw new ResetException();
diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index 247ef791..af7ca27f 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -63,6 +63,7 @@
 import java.util.NoSuchElementException;
 
 import com.google.common.primitives.UnsignedBytes;
+import org.hamcrest.Matchers;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Rule;
@@ -302,6 +303,59 @@ public void removeOddElements() {
     verify(all(), 4, 8);
   }
 
+  @Test(expected = Env.AlreadyClosedException.class)
+  public void nextWithClosedEnvTest() {
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+        env.close();
+        c.next();
+      }
+    }
+  }
+
+  @Test(expected = Env.AlreadyClosedException.class)
+  public void removeWithClosedEnvTest() {
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+        final KeyVal<ByteBuffer> keyVal = c.next();
+        assertThat(keyVal, Matchers.notNullValue());
+
+        env.close();
+        c.remove();
+      }
+    }
+  }
+
+  @Test(expected = Env.AlreadyClosedException.class)
+  public void hasNextWithClosedEnvTest() {
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+        env.close();
+        c.hasNext();
+      }
+    }
+  }
+
+  @Test(expected = Env.AlreadyClosedException.class)
+  public void forEachRemainingWithClosedEnvTest() {
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+        env.close();
+        c.forEachRemaining(keyVal -> {
+
+        });
+      }
+    }
+  }
+
   private void verify(final KeyRange<ByteBuffer> range, final int... expected) {
     verify(range, null, expected);
   }
diff --git a/src/test/java/org/lmdbjava/CursorTest.java b/src/test/java/org/lmdbjava/CursorTest.java
index 51b78806..17fbacc7 100644
--- a/src/test/java/org/lmdbjava/CursorTest.java
+++ b/src/test/java/org/lmdbjava/CursorTest.java
@@ -40,6 +40,8 @@
 import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
 import static org.lmdbjava.SeekOp.MDB_FIRST;
 import static org.lmdbjava.SeekOp.MDB_GET_BOTH;
+import static org.lmdbjava.SeekOp.MDB_LAST;
+import static org.lmdbjava.SeekOp.MDB_NEXT;
 import static org.lmdbjava.TestUtils.DB_1;
 import static org.lmdbjava.TestUtils.POSIX_MODE;
 import static org.lmdbjava.TestUtils.bb;
@@ -47,6 +49,7 @@
 import java.io.File;
 import java.io.IOException;
 import java.nio.ByteBuffer;
+import java.util.function.Consumer;
 
 import org.junit.After;
 import org.junit.Before;
@@ -96,6 +99,59 @@ public void closedCursorRejectsSubsequentGets() {
     }
   }
 
+  @Test(expected = Env.AlreadyClosedException.class)
+  public void closedEnvRejectsSeekFirstCall() {
+    doEnvClosedTest(null, c -> c.seek(MDB_FIRST));
+  }
+
+  @Test(expected = Env.AlreadyClosedException.class)
+  public void closedEnvRejectsSeekLastCall() {
+    doEnvClosedTest(null, c -> c.seek(MDB_LAST));
+  }
+
+  @Test(expected = Env.AlreadyClosedException.class)
+  public void closedEnvRejectsSeekNextCall() {
+    doEnvClosedTest(null, c -> c.seek(MDB_NEXT));
+  }
+
+  @Test(expected = Env.AlreadyClosedException.class)
+  public void closedEnvRejectsCloseCall() {
+    doEnvClosedTest(null, Cursor::close);
+  }
+
+  @Test(expected = Env.AlreadyClosedException.class)
+  public void closedEnvRejectsFirstCall() {
+    doEnvClosedTest(null, Cursor::first);
+  }
+
+  @Test(expected = Env.AlreadyClosedException.class)
+  public void closedEnvRejectsLastCall() {
+    doEnvClosedTest(null, Cursor::last);
+  }
+
+  @Test(expected = Env.AlreadyClosedException.class)
+  public void closedEnvRejectsPrevCall() {
+    doEnvClosedTest(
+            c -> {
+              c.first();
+              assertThat(c.key().getInt(), is(1));
+              assertThat(c.val().getInt(), is(10));
+              c.next();
+            },
+            Cursor::prev);
+  }
+
+  @Test(expected = Env.AlreadyClosedException.class)
+  public void closedEnvRejectsDeleteCall() {
+    doEnvClosedTest(
+            c -> {
+              c.first();
+              assertThat(c.key().getInt(), is(1));
+              assertThat(c.val().getInt(), is(10));
+            },
+            Cursor::delete);
+  }
+
   @Test
   public void count() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
@@ -338,4 +394,29 @@ public void testCursorByteBufferDuplicate() {
       }
     }
   }
+
+  private void doEnvClosedTest(final Consumer<Cursor<ByteBuffer>> workBeforeEnvClosed,
+                               final Consumer<Cursor<ByteBuffer>> workAfterEnvClose) {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+
+    db.put(bb(1), bb(10));
+    db.put(bb(2), bb(20));
+    db.put(bb(2), bb(30));
+    db.put(bb(4), bb(40));
+
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      try (Cursor<ByteBuffer> c = db.openCursor(txn)) {
+
+        if (workBeforeEnvClosed != null) {
+          workBeforeEnvClosed.accept(c);
+        }
+
+        env.close();
+
+        if (workAfterEnvClose != null) {
+          workAfterEnvClose.accept(c);
+        }
+      }
+    }
+  }
 }
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index e52bd28d..6db5a9b8 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -67,6 +67,7 @@
 import java.util.concurrent.Future;
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.BiConsumer;
 
 import org.agrona.concurrent.UnsafeBuffer;
 import org.hamcrest.Matchers;
@@ -77,6 +78,7 @@
 import org.junit.rules.TemporaryFolder;
 import org.lmdbjava.CursorIterable.KeyVal;
 import org.lmdbjava.Dbi.DbFullException;
+import org.lmdbjava.Env.AlreadyClosedException;
 import org.lmdbjava.Env.MapFullException;
 import org.lmdbjava.LmdbNativeException.ConstantDerivedException;
 
@@ -492,4 +494,105 @@ public void testParallelWritesStress() {
         });
   }
 
+  @Test(expected = AlreadyClosedException.class)
+  public void closedEnvRejectsOpenCall() {
+    env.close();
+    env.openDbi(DB_1, MDB_CREATE);
+  }
+
+  @Test(expected = AlreadyClosedException.class)
+  public void closedEnvRejectsCloseCall() {
+    doEnvClosedTest(
+        null,
+        (db, txn) -> db.close());
+  }
+
+  @Test(expected = AlreadyClosedException.class)
+  public void closedEnvRejectsGetCall() {
+    doEnvClosedTest(
+        (db, txn) -> {
+        final ByteBuffer valBuf = db.get(txn, bb(1));
+        assertThat(valBuf.getInt(), is(10));
+      },
+        (db, txn) -> db.get(txn, bb(2)));
+  }
+
+  @Test(expected = AlreadyClosedException.class)
+  public void closedEnvRejectsPutCall() {
+    doEnvClosedTest(
+        null,
+        (db, txn) -> db.put(bb(5), bb(50)));
+  }
+
+  @Test(expected = AlreadyClosedException.class)
+  public void closedEnvRejectsPutWithTxnCall() {
+    doEnvClosedTest(
+        null,
+        (db, txn) -> {
+        db.put(txn, bb(5), bb(50));
+      });
+  }
+
+  @Test(expected = AlreadyClosedException.class)
+  public void closedEnvRejectsIterateCall() {
+    doEnvClosedTest(null, Dbi::iterate);
+  }
+
+  @Test(expected = AlreadyClosedException.class)
+  public void closedEnvRejectsDropCall() {
+    doEnvClosedTest(
+        null,
+        Dbi::drop);
+  }
+
+  @Test(expected = AlreadyClosedException.class)
+  public void closedEnvRejectsDropAndDeleteCall() {
+    doEnvClosedTest(
+        null,
+        (db, txn) -> db.drop(txn, true));
+  }
+
+  @Test(expected = AlreadyClosedException.class)
+  public void closedEnvRejectsOpenCursorCall() {
+    doEnvClosedTest(
+        null,
+        Dbi::openCursor);
+  }
+
+  @Test(expected = AlreadyClosedException.class)
+  public void closedEnvRejectsReserveCall() {
+    doEnvClosedTest(
+        null,
+        (db, txn) -> db.reserve(txn, bb(1), 32, MDB_NOOVERWRITE));
+  }
+
+  @Test(expected = AlreadyClosedException.class)
+  public void closedEnvRejectsStatCall() {
+    doEnvClosedTest(null, Dbi::stat);
+  }
+
+  private void doEnvClosedTest(
+      final BiConsumer<Dbi<ByteBuffer>, Txn<ByteBuffer>> workBeforeEnvClosed,
+      final BiConsumer<Dbi<ByteBuffer>, Txn<ByteBuffer>> workAfterEnvClose) {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+
+    db.put(bb(1), bb(10));
+    db.put(bb(2), bb(20));
+    db.put(bb(2), bb(30));
+    db.put(bb(4), bb(40));
+
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+
+      if (workBeforeEnvClosed != null) {
+        workBeforeEnvClosed.accept(db, txn);
+      }
+
+      env.close();
+
+      if (workAfterEnvClose != null) {
+        workAfterEnvClose.accept(db, txn);
+      }
+    }
+  }
+
 }
diff --git a/src/test/java/org/lmdbjava/TxnTest.java b/src/test/java/org/lmdbjava/TxnTest.java
index f8a0b5d3..c115be0b 100644
--- a/src/test/java/org/lmdbjava/TxnTest.java
+++ b/src/test/java/org/lmdbjava/TxnTest.java
@@ -230,6 +230,42 @@ public void txConstructionDeniedIfEnvClosed() {
     env.txnRead();
   }
 
+  @Test(expected = AlreadyClosedException.class)
+  public void txRenewDeniedIfEnvClosed() {
+    final Txn<ByteBuffer> txnRead = env.txnRead();
+    txnRead.close();
+    env.close();
+    txnRead.renew();
+  }
+
+  @Test(expected = AlreadyClosedException.class)
+  public void txCloseDeniedIfEnvClosed() {
+    final Txn<ByteBuffer> txnRead = env.txnRead();
+    env.close();
+    txnRead.close();
+  }
+
+  @Test(expected = AlreadyClosedException.class)
+  public void txCommitDeniedIfEnvClosed() {
+    final Txn<ByteBuffer> txnRead = env.txnRead();
+    env.close();
+    txnRead.commit();
+  }
+
+  @Test(expected = AlreadyClosedException.class)
+  public void txAbortDeniedIfEnvClosed() {
+    final Txn<ByteBuffer> txnRead = env.txnRead();
+    env.close();
+    txnRead.abort();
+  }
+
+  @Test(expected = AlreadyClosedException.class)
+  public void txResetDeniedIfEnvClosed() {
+    final Txn<ByteBuffer> txnRead = env.txnRead();
+    env.close();
+    txnRead.reset();
+  }
+
   @Test
   public void txParent() {
     try (Txn<ByteBuffer> txRoot = env.txnWrite();
@@ -239,6 +275,15 @@ public void txParent() {
     }
   }
 
+  @Test(expected = AlreadyClosedException.class)
+  public void txParentDeniedIfEnvClosed() {
+    try (Txn<ByteBuffer> txRoot = env.txnWrite();
+         Txn<ByteBuffer> txChild = env.txn(txRoot)) {
+      env.close();
+      assertThat(txChild.getParent(), is(txRoot));
+    }
+  }
+
   @Test(expected = IncompatibleParent.class)
   public void txParentROChildRWIncompatible() {
     try (Txn<ByteBuffer> txRoot = env.txnRead()) {

From d7711ac930860d39c780e20bcde1a3d45641debc Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Sat, 4 Feb 2023 10:21:29 +1100
Subject: [PATCH 157/322] GitHub Actions should not use forks

---
 .github/workflows/maven.yml | 2 +-
 pom.xml                     | 2 ++
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml
index a551b802..56d8b1f0 100644
--- a/.github/workflows/maven.yml
+++ b/.github/workflows/maven.yml
@@ -82,7 +82,7 @@ jobs:
         gpg-passphrase: MAVEN_GPG_PASSPHRASE
 
     - name: Publish Maven package
-      run: mvn -Possrh-deploy deploy
+      run: mvn -B -Possrh-deploy deploy -DskipTests
       env:
         MAVEN_GPG_PASSPHRASE: ${{ secrets.gpg_passphrase }}
         MAVEN_USERNAME: ${{ secrets.nexus_username }}
diff --git a/pom.xml b/pom.xml
index b1a87cdd..4ce1dab1 100644
--- a/pom.xml
+++ b/pom.xml
@@ -229,6 +229,8 @@
             <artifactId>maven-surefire-plugin</artifactId>
             <configuration>
               <argLine>--add-opens java.base/java.nio=ALL-UNNAMED --add-opens java.base/sun.nio.ch=ALL-UNNAMED</argLine>
+             <forkCount>1</forkCount>
+             <reuseForks>false</reuseForks>
             </configuration>
           </plugin>
         </plugins>

From 0621fd4c8cf6f9e7ca2d65083e19b82b78e7c112 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Sat, 4 Feb 2023 10:39:02 +1100
Subject: [PATCH 158/322] GitHub Actions Java version tests

---
 .github/workflows/maven.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml
index 56d8b1f0..011938b1 100644
--- a/.github/workflows/maven.yml
+++ b/.github/workflows/maven.yml
@@ -19,7 +19,7 @@ jobs:
       uses: actions/setup-java@v3
       with:
         distribution: zulu
-        java-version: 11
+        java-version: 17
         cache: maven
 
     - name: Build with Maven
@@ -35,7 +35,7 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest]
-        java: [8, 11, 16]
+        java: [8, 11, 17, 19]
 
     steps:
       - name: Check out Git repository

From be7359ac9d0f32284e720a1ed05460582e143f62 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Sat, 4 Feb 2023 10:45:08 +1100
Subject: [PATCH 159/322] Reflect current Java versions tested by CI

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 3b8f4753..450f814f 100644
--- a/README.md
+++ b/README.md
@@ -32,7 +32,7 @@
 * Mature code (commenced in 2016) and used for heavy production workloads (eg > 500 TB of HFT data)
 * Actively maintained and with a "Zero Bug Policy" before every release (see [issues](https://github.com/lmdbjava/lmdbjava/issues))
 * Available from [Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22org.lmdbjava%22%20AND%20a%3A%22lmdbjava%22) and [OSS Sonatype Snapshots](https://oss.sonatype.org/content/repositories/snapshots/org/lmdbjava/lmdbjava)
-* [Continuous integration](https://github.com/lmdbjava/lmdbjava/actions) testing on Linux, Windows and macOS with Java 8, 11 and 16
+* [Continuous integration](https://github.com/lmdbjava/lmdbjava/actions) testing on Linux, Windows and macOS with Java 8, 11, 17 and 19
 
 ### Performance
 

From 9f7435266877eb2441baddc84e31e39ae218be4f Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Sat, 4 Feb 2023 11:15:44 +1100
Subject: [PATCH 160/322] GitHub Actions to use Verifier for OS/JVM test matrix

The Verifier is designed to test the accuracy of LMDB storage and is
therefore a useful test to perform on each target platform. It is
noted that other GitHub Actions execute a full Maven verification.
---
 .github/workflows/maven.yml                  | 6 +++---
 pom.xml                                      | 4 ++--
 src/test/java/org/lmdbjava/VerifierTest.java | 3 ++-
 3 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml
index 011938b1..85d4385f 100644
--- a/.github/workflows/maven.yml
+++ b/.github/workflows/maven.yml
@@ -8,7 +8,7 @@ on:
 
 jobs:
   build:
-    name: Java 11 Build and Verify
+    name: Latest Java LTS Build and Verify
     runs-on: ubuntu-latest
 
     steps:
@@ -48,8 +48,8 @@ jobs:
           java-version: ${{ matrix.java }}
           cache: maven
 
-      - name: Test with Maven
-        run: mvn -B test
+      - name: Execute verifier
+        run: mvn -B test -Dtest=VerifierTest -DverificationSeconds=10
 
       - name: Upload Surefire reports on test failure
         uses: actions/upload-artifact@v3
diff --git a/pom.xml b/pom.xml
index 4ce1dab1..c1559219 100644
--- a/pom.xml
+++ b/pom.xml
@@ -229,8 +229,8 @@
             <artifactId>maven-surefire-plugin</artifactId>
             <configuration>
               <argLine>--add-opens java.base/java.nio=ALL-UNNAMED --add-opens java.base/sun.nio.ch=ALL-UNNAMED</argLine>
-             <forkCount>1</forkCount>
-             <reuseForks>false</reuseForks>
+              <forkCount>1</forkCount>
+              <reuseForks>false</reuseForks>
             </configuration>
           </plugin>
         </plugins>
diff --git a/src/test/java/org/lmdbjava/VerifierTest.java b/src/test/java/org/lmdbjava/VerifierTest.java
index 27bb598b..41f4e774 100644
--- a/src/test/java/org/lmdbjava/VerifierTest.java
+++ b/src/test/java/org/lmdbjava/VerifierTest.java
@@ -52,7 +52,8 @@ public void verification() throws IOException {
         .setMapSize(MEBIBYTES.toBytes(10))
         .open(path, MDB_NOSUBDIR)) {
       final Verifier v = new Verifier(env);
-      assertThat(v.runFor(2, TimeUnit.SECONDS), greaterThan(1L));
+      final int seconds = Integer.getInteger("verificationSeconds", 2);
+      assertThat(v.runFor(seconds, TimeUnit.SECONDS), greaterThan(1L));
     }
   }
 

From be2a15b348668ca5c97ab58a4ac9b396d21256da Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Sat, 4 Feb 2023 11:28:16 +1100
Subject: [PATCH 161/322] [maven-release-plugin] prepare release lmdbjava-0.8.3

---
 pom.xml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pom.xml b/pom.xml
index c1559219..8830cb89 100644
--- a/pom.xml
+++ b/pom.xml
@@ -8,7 +8,7 @@
   </parent>
   <groupId>org.lmdbjava</groupId>
   <artifactId>lmdbjava</artifactId>
-  <version>0.8.3-SNAPSHOT</version>
+  <version>0.8.3</version>
   <packaging>jar</packaging>
   <name>LmdbJava</name>
   <description>Low latency Java API for the ultra-fast, embedded Symas Lightning Database (LMDB)</description>
@@ -206,7 +206,7 @@
     <connection>scm:git:git@github.com:${github.org}/${github.repo}.git</connection>
     <developerConnection>scm:git:git@github.com:${github.org}/${github.repo}.git</developerConnection>
     <url>git@github.com:${github.org}/${github.repo}.git</url>
-    <tag>HEAD</tag>
+    <tag>lmdbjava-0.8.3</tag>
   </scm>
   <issueManagement>
     <system>GitHub Issues</system>

From e4cf6e98e52b570baf77af52f253b8a97ae70f4d Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Sat, 4 Feb 2023 11:28:23 +1100
Subject: [PATCH 162/322] [maven-release-plugin] prepare for next development
 iteration

---
 pom.xml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pom.xml b/pom.xml
index 8830cb89..20b02b04 100644
--- a/pom.xml
+++ b/pom.xml
@@ -8,7 +8,7 @@
   </parent>
   <groupId>org.lmdbjava</groupId>
   <artifactId>lmdbjava</artifactId>
-  <version>0.8.3</version>
+  <version>0.9.0-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>LmdbJava</name>
   <description>Low latency Java API for the ultra-fast, embedded Symas Lightning Database (LMDB)</description>
@@ -206,7 +206,7 @@
     <connection>scm:git:git@github.com:${github.org}/${github.repo}.git</connection>
     <developerConnection>scm:git:git@github.com:${github.org}/${github.repo}.git</developerConnection>
     <url>git@github.com:${github.org}/${github.repo}.git</url>
-    <tag>lmdbjava-0.8.3</tag>
+    <tag>HEAD</tag>
   </scm>
   <issueManagement>
     <system>GitHub Issues</system>

From 3524995b97c86e0cd66c64ce648693cad9feaa0c Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Sat, 4 Feb 2023 15:23:49 +1100
Subject: [PATCH 163/322] Refactor Comparator handling (fixes #199)

---
 src/main/java/org/lmdbjava/BufferProxy.java   | 15 ++--
 .../java/org/lmdbjava/ByteArrayProxy.java     |  7 +-
 src/main/java/org/lmdbjava/ByteBufProxy.java  |  7 +-
 .../java/org/lmdbjava/ByteBufferProxy.java    | 20 ++++-
 src/main/java/org/lmdbjava/Dbi.java           | 54 +++---------
 .../java/org/lmdbjava/DirectBufferProxy.java  |  7 +-
 src/main/java/org/lmdbjava/Env.java           | 88 ++++++++++++++-----
 src/main/java/org/lmdbjava/Txn.java           | 15 ----
 .../java/org/lmdbjava/ComparatorTest.java     | 18 ++--
 .../java/org/lmdbjava/CursorIterableTest.java | 22 +++--
 src/test/java/org/lmdbjava/DbiTest.java       | 14 +--
 11 files changed, 157 insertions(+), 110 deletions(-)

diff --git a/src/main/java/org/lmdbjava/BufferProxy.java b/src/main/java/org/lmdbjava/BufferProxy.java
index bd58d7b6..aff732bc 100644
--- a/src/main/java/org/lmdbjava/BufferProxy.java
+++ b/src/main/java/org/lmdbjava/BufferProxy.java
@@ -22,6 +22,8 @@
 
 import static java.lang.Long.BYTES;
 
+import java.util.Comparator;
+
 import jnr.ffi.Pointer;
 
 /**
@@ -61,17 +63,16 @@ public abstract class BufferProxy<T> {
   protected abstract T allocate();
 
   /**
-   * Compare the two buffers.
+   * Get a suitable default {@link Comparator} given the provided flags.
    *
    * <p>
-   * Implemented as a protected method to discourage use of the buffer proxy
-   * in collections etc (given by design it wraps a temporary value only).
+   * The provided comparator must strictly match the lexicographical order of
+   * keys in the native LMDB database.
    *
-   * @param o1 left operand
-   * @param o2 right operand
-   * @return as per {@link Comparable}
+   * @param flags for the database
+   * @return a comparator that can be used (never null)
    */
-  protected abstract int compare(T o1, T o2);
+  protected abstract Comparator<T> getComparator(DbiFlags... flags);
 
   /**
    * Deallocate a buffer that was previously provided by {@link #allocate()}.
diff --git a/src/main/java/org/lmdbjava/ByteArrayProxy.java b/src/main/java/org/lmdbjava/ByteArrayProxy.java
index f6ddbef2..3fe8184a 100644
--- a/src/main/java/org/lmdbjava/ByteArrayProxy.java
+++ b/src/main/java/org/lmdbjava/ByteArrayProxy.java
@@ -24,6 +24,7 @@
 import static org.lmdbjava.Library.RUNTIME;
 
 import java.util.Arrays;
+import java.util.Comparator;
 
 import jnr.ffi.Pointer;
 import jnr.ffi.provider.MemoryManager;
@@ -78,7 +79,6 @@ protected byte[] allocate() {
     return new byte[0];
   }
 
-  @Override
   protected int compare(final byte[] o1, final byte[] o2) {
     return compareArrays(o1, o2);
   }
@@ -93,6 +93,11 @@ protected byte[] getBytes(final byte[] buffer) {
     return Arrays.copyOf(buffer, buffer.length);
   }
 
+  @Override
+  protected Comparator<byte[]> getComparator(final DbiFlags... flags) {
+    return this::compare;
+  }
+
   @Override
   protected void in(final byte[] buffer, final Pointer ptr,
                     final long ptrAddr) {
diff --git a/src/main/java/org/lmdbjava/ByteBufProxy.java b/src/main/java/org/lmdbjava/ByteBufProxy.java
index d8bbc452..26351676 100644
--- a/src/main/java/org/lmdbjava/ByteBufProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufProxy.java
@@ -25,6 +25,7 @@
 import static org.lmdbjava.UnsafeAccess.UNSAFE;
 
 import java.lang.reflect.Field;
+import java.util.Comparator;
 
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.PooledByteBufAllocator;
@@ -106,11 +107,15 @@ protected ByteBuf allocate() {
     throw new IllegalStateException("Netty buffer must be " + NAME);
   }
 
-  @Override
   protected int compare(final ByteBuf o1, final ByteBuf o2) {
     return o1.compareTo(o2);
   }
 
+  @Override
+  protected Comparator<ByteBuf> getComparator(final DbiFlags... flags) {
+    return this::compare;
+  }
+
   @Override
   protected void deallocate(final ByteBuf buff) {
     buff.release();
diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
index 0d1781b3..8eb95da8 100644
--- a/src/main/java/org/lmdbjava/ByteBufferProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -26,13 +26,17 @@
 import static java.nio.ByteOrder.BIG_ENDIAN;
 import static java.nio.ByteOrder.LITTLE_ENDIAN;
 import static java.util.Objects.requireNonNull;
+import static org.lmdbjava.DbiFlags.MDB_INTEGERKEY;
 import static org.lmdbjava.Env.SHOULD_CHECK;
+import static org.lmdbjava.MaskedFlag.isSet;
+import static org.lmdbjava.MaskedFlag.mask;
 import static org.lmdbjava.UnsafeAccess.UNSAFE;
 
 import java.lang.reflect.Field;
 import java.nio.Buffer;
 import java.nio.ByteBuffer;
 import java.util.ArrayDeque;
+import java.util.Comparator;
 
 import jnr.ffi.Pointer;
 
@@ -189,7 +193,21 @@ protected final ByteBuffer allocate() {
     }
 
     @Override
-    protected final int compare(final ByteBuffer o1, final ByteBuffer o2) {
+    protected Comparator<ByteBuffer> getComparator(final DbiFlags... flags) {
+      final int flagInt = mask(flags);
+      if (isSet(flagInt, MDB_INTEGERKEY)) {
+        return this::compareCustom;
+      }
+      return this::compareDefault;
+    }
+
+    protected final int compareDefault(final ByteBuffer o1,
+                                       final ByteBuffer o2) {
+      return o1.compareTo(o2);
+    }
+
+    protected final int compareCustom(final ByteBuffer o1,
+                                      final ByteBuffer o2) {
       return compareBuff(o1, o2);
     }
 
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index 3f36bbeb..d0eb0a14 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -56,38 +56,35 @@ public final class Dbi<T> {
 
   private final ComparatorCallback ccb;
   private boolean cleaned;
-  private final Comparator<T> compFunc;
+  private final Comparator<T> comparator;
   private final Env<T> env;
   private final byte[] name;
-  private final BufferProxy<T> proxy;
   private final Pointer ptr;
 
   Dbi(final Env<T> env, final Txn<T> txn, final byte[] name,
-      final Comparator<T> comparator, final DbiFlags... flags) {
+      final Comparator<T> comparator, final boolean nativeCb,
+      final BufferProxy<T> proxy, final DbiFlags... flags) {
     this.env = env;
     this.name = name == null ? null : Arrays.copyOf(name, name.length);
+    this.comparator = comparator;
     final int flagsMask = mask(flags);
     final Pointer dbiPtr = allocateDirect(RUNTIME, ADDRESS);
     checkRc(LIB.mdb_dbi_open(txn.pointer(), name, flagsMask, dbiPtr));
     ptr = dbiPtr.getPointer(0);
-    if (comparator == null) {
-      proxy = null;
-      compFunc = null;
-      ccb = null;
-    } else {
-      this.proxy = txn.getProxy();
-      this.compFunc = comparator;
+    if (nativeCb) {
       this.ccb = (keyA, keyB) -> {
         final T compKeyA = proxy.allocate();
         final T compKeyB = proxy.allocate();
         proxy.out(compKeyA, keyA, keyA.address());
         proxy.out(compKeyB, keyB, keyB.address());
-        final int result = compFunc.compare(compKeyA, compKeyB);
+        final int result = this.comparator.compare(compKeyA, compKeyB);
         proxy.deallocate(compKeyA);
         proxy.deallocate(compKeyB);
         return result;
       };
       LIB.mdb_set_compare(txn.pointer(), ptr, ccb);
+    } else {
+      ccb = null;
     }
   }
 
@@ -265,51 +262,20 @@ public CursorIterable<T> iterate(final Txn<T> txn) {
   }
 
   /**
-   * Iterate the database in accordance with the provided {@link KeyRange} and
-   * default {@link Comparator}.
+   * Iterate the database in accordance with the provided {@link KeyRange}.
    *
    * @param txn   transaction handle (not null; not committed)
    * @param range range of acceptable keys (not null)
    * @return iterator (never null)
    */
   public CursorIterable<T> iterate(final Txn<T> txn, final KeyRange<T> range) {
-    return iterate(txn, range, null);
-  }
-
-  /**
-   * Iterate the database in accordance with the provided {@link KeyRange} and
-   * {@link Comparator}.
-   *
-   * <p>
-   * If a comparator is provided, it must reflect the same ordering as LMDB uses
-   * for cursor operations (eg first, next, last, previous etc).
-   *
-   * <p>
-   * If a null comparator is provided, any comparator provided when opening the
-   * database is used. If no database comparator was specified, the buffer's
-   * default comparator is used. Such buffer comparators reflect LMDB's default
-   * lexicographical order.
-   *
-   * @param txn        transaction handle (not null; not committed)
-   * @param range      range of acceptable keys (not null)
-   * @param comparator custom comparator for keys (may be null)
-   * @return iterator (never null)
-   */
-  public CursorIterable<T> iterate(final Txn<T> txn, final KeyRange<T> range,
-                                   final Comparator<T> comparator) {
     if (SHOULD_CHECK) {
       requireNonNull(txn);
       requireNonNull(range);
       env.checkNotClosed();
       txn.checkReady();
     }
-    final Comparator<T> useComp;
-    if (comparator == null) {
-      useComp = compFunc == null ? txn.comparator() : compFunc;
-    } else {
-      useComp = comparator;
-    }
-    return new CursorIterable<>(txn, this, range, useComp);
+    return new CursorIterable<>(txn, this, range, comparator);
   }
 
   /*
diff --git a/src/main/java/org/lmdbjava/DirectBufferProxy.java b/src/main/java/org/lmdbjava/DirectBufferProxy.java
index ac46dec5..62b49095 100644
--- a/src/main/java/org/lmdbjava/DirectBufferProxy.java
+++ b/src/main/java/org/lmdbjava/DirectBufferProxy.java
@@ -28,6 +28,7 @@
 
 import java.nio.ByteBuffer;
 import java.util.ArrayDeque;
+import java.util.Comparator;
 
 import jnr.ffi.Pointer;
 import org.agrona.DirectBuffer;
@@ -111,7 +112,6 @@ protected DirectBuffer allocate() {
     }
   }
 
-  @Override
   protected int compare(final DirectBuffer o1, final DirectBuffer o2) {
     return compareBuff(o1, o2);
   }
@@ -129,6 +129,11 @@ protected byte[] getBytes(final DirectBuffer buffer) {
     return dest;
   }
 
+  @Override
+  protected Comparator<DirectBuffer> getComparator(final DbiFlags... flags) {
+    return this::compare;
+  }
+
   @Override
   protected void in(final DirectBuffer buffer, final Pointer ptr,
                     final long ptrAddr) {
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 45db5064..66ab7cda 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -258,43 +258,79 @@ public boolean isReadOnly() {
   }
 
   /**
-   * Convenience method that opens a {@link Dbi} with a UTF-8 database name.
+   * Convenience method that opens a {@link Dbi} with a UTF-8 database name and
+   * default {@link Comparator} that is not invoked from native code.
    *
    * @param name  name of the database (or null if no name is required)
    * @param flags to open the database with
    * @return a database that is ready to use
    */
   public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
-    return openDbi(name, null, flags);
+    final byte[] nameBytes = name == null ? null : name.getBytes(UTF_8);
+    return openDbi(nameBytes, null, false, flags);
   }
 
   /**
-   * Convenience method that opens a {@link Dbi} with a UTF-8 database name.
+   * Convenience method that opens a {@link Dbi} with a UTF-8 database name and
+   * associated {@link Comparator} that is not invoked from native code.
    *
    * @param name       name of the database (or null if no name is required)
-   * @param comparator custom comparator callback (or null to use LMDB default)
+   * @param comparator custom comparator callback (or null to use default)
    * @param flags      to open the database with
    * @return a database that is ready to use
    */
   public Dbi<T> openDbi(final String name, final Comparator<T> comparator,
                         final DbiFlags... flags) {
     final byte[] nameBytes = name == null ? null : name.getBytes(UTF_8);
-    return openDbi(nameBytes, comparator, flags);
+    return openDbi(nameBytes, comparator, false, flags);
+  }
+
+  /**
+   * Convenience method that opens a {@link Dbi} with a UTF-8 database name and
+   * associated {@link Comparator} that may be invoked from native code if
+   * specified.
+   *
+   * @param name       name of the database (or null if no name is required)
+   * @param comparator custom comparator callback (or null to use default)
+   * @param nativeCb   whether native code calls back to the Java comparator
+   * @param flags      to open the database with
+   * @return a database that is ready to use
+   */
+  public Dbi<T> openDbi(final String name, final Comparator<T> comparator,
+                        final boolean nativeCb, final DbiFlags... flags) {
+    final byte[] nameBytes = name == null ? null : name.getBytes(UTF_8);
+    return openDbi(nameBytes, comparator, nativeCb, flags);
   }
 
   /**
-   * Convenience method that opens a {@link Dbi}.
+   * Convenience method that opens a {@link Dbi} with a default
+   * {@link Comparator} that is not invoked from native code.
    *
    * @param name  name of the database (or null if no name is required)
    * @param flags to open the database with
    * @return a database that is ready to use
    */
   public Dbi<T> openDbi(final byte[] name, final DbiFlags... flags) {
-    return openDbi(name, null, flags);
+    return openDbi(name, null, false, flags);
+  }
+
+  /**
+   * Convenience method that opens a {@link Dbi} with an associated
+   * {@link Comparator} that is not invoked from native code.
+   *
+   * @param name       name of the database (or null if no name is required)
+   * @param comparator custom comparator callback (or null to use LMDB default)
+   * @param flags      to open the database with
+   * @return a database that is ready to use
+   */
+  public Dbi<T> openDbi(final byte[] name, final Comparator<T> comparator,
+                        final DbiFlags... flags) {
+    return openDbi(name, comparator, false, flags);
   }
 
   /**
-   * Convenience method that opens a {@link Dbi} inside a private transaction.
+   * Convenience method that opens a {@link Dbi} with an associated
+   * {@link Comparator} that may be invoked from native code if specified.
    *
    * <p>
    * This method will automatically commit the private transaction before
@@ -303,13 +339,14 @@ public Dbi<T> openDbi(final byte[] name, final DbiFlags... flags) {
    *
    * @param name       name of the database (or null if no name is required)
    * @param comparator custom comparator callback (or null to use LMDB default)
+   * @param nativeCb   whether native code calls back to the Java comparator
    * @param flags      to open the database with
    * @return a database that is ready to use
    */
   public Dbi<T> openDbi(final byte[] name, final Comparator<T> comparator,
-                        final DbiFlags... flags) {
+                        final boolean nativeCb, final DbiFlags... flags) {
     try (Txn<T> txn = readOnly ? txnRead() : txnWrite()) {
-      final Dbi<T> dbi = openDbi(txn, name, comparator, flags);
+      final Dbi<T> dbi = openDbi(txn, name, comparator, nativeCb, flags);
       txn.commit(); // even RO Txns require a commit to retain Dbi in Env
       return dbi;
     }
@@ -323,14 +360,18 @@ public Dbi<T> openDbi(final byte[] name, final Comparator<T> comparator,
    * to retain the <code>Dbi</code> in the <code>Env</code>.
    *
    * <p>
-   * If a custom comparator is specified, this comparator is called from LMDB
-   * any time it needs to compare two keys. The comparator must be used any time
-   * any time this database is opened, otherwise database corruption may occur.
-   * The custom comparator will also be used whenever a {@link CursorIterable}
-   * is created from the returned {@link Dbi}. If a custom comparator is not
-   * specified, LMDB's native default lexicographical order is used. The default
-   * comparator is typically more efficient (as there is no need for the native
-   * library to call back into Java for the comparator result).
+   * A {@link Comparator} may be provided when calling this method. Such
+   * comparator is primarily used by {@link CursorIterable} instances. A
+   * secondary (but uncommon) use of the comparator is to act as a callback from
+   * the native library if <code>nativeCb</code> is <code>true</code>. This is
+   * usually avoided due to the overhead of native code calling back into Java.
+   * It is instead highly recommended to set the correct {@link DbiFlag}s to
+   * allow the native library to correctly order the intended keys.
+   *
+   * <p>
+   * A default comparator will be provided if <code>null</code> is passed as the
+   * comparator. If a custom comparator is provided, it must strictly match the
+   * lexicographical order of keys in the native LMDB database.
    *
    * <p>
    * This method (and its overloaded convenience variants) must not be called
@@ -339,17 +380,24 @@ public Dbi<T> openDbi(final byte[] name, final Comparator<T> comparator,
    * @param txn        transaction to use (required; not closed)
    * @param name       name of the database (or null if no name is required)
    * @param comparator custom comparator callback (or null to use LMDB default)
+   * @param nativeCb   whether native code should call back to the comparator
    * @param flags      to open the database with
    * @return a database that is ready to use
    */
   public Dbi<T> openDbi(final Txn<T> txn, final byte[] name,
-                        final Comparator<T> comparator,
+                        final Comparator<T> comparator, final boolean nativeCb,
                         final DbiFlags... flags) {
     if (SHOULD_CHECK) {
       requireNonNull(txn);
       txn.checkReady();
     }
-    return new Dbi<>(this, txn, name, comparator, flags);
+    final Comparator<T> useComparator;
+    if (comparator == null) {
+      useComparator = proxy.getComparator(flags);
+    } else {
+      useComparator = comparator;
+    }
+    return new Dbi<>(this, txn, name, useComparator, nativeCb, proxy, flags);
   }
 
   /**
diff --git a/src/main/java/org/lmdbjava/Txn.java b/src/main/java/org/lmdbjava/Txn.java
index f3071152..b6d28917 100644
--- a/src/main/java/org/lmdbjava/Txn.java
+++ b/src/main/java/org/lmdbjava/Txn.java
@@ -34,8 +34,6 @@
 import static org.lmdbjava.Txn.State.RESET;
 import static org.lmdbjava.TxnFlags.MDB_RDONLY_TXN;
 
-import java.util.Comparator;
-
 import jnr.ffi.Pointer;
 
 /**
@@ -225,19 +223,6 @@ void checkWritesAllowed() {
     }
   }
 
-  Comparator<T> comparator() {
-    return proxy::compare;
-  }
-
-  /**
-   * Obtain the buffer proxy.
-   *
-   * @return proxy (never null)
-   */
-  BufferProxy<T> getProxy() {
-    return proxy;
-  }
-
   /**
    * Return the state of the transaction.
    *
diff --git a/src/test/java/org/lmdbjava/ComparatorTest.java b/src/test/java/org/lmdbjava/ComparatorTest.java
index 77c5ca37..f21604ee 100644
--- a/src/test/java/org/lmdbjava/ComparatorTest.java
+++ b/src/test/java/org/lmdbjava/ComparatorTest.java
@@ -25,6 +25,7 @@
 import static org.hamcrest.core.Is.is;
 import static org.junit.Assert.assertThat;
 import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
+import static org.lmdbjava.ByteBufProxy.PROXY_NETTY;
 import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
 import static org.lmdbjava.ComparatorTest.ComparatorResult.EQUAL_TO;
 import static org.lmdbjava.ComparatorTest.ComparatorResult.GREATER_THAN;
@@ -146,7 +147,8 @@ private static class ByteArrayRunner implements ComparatorRunner {
 
     @Override
     public int compare(final byte[] o1, final byte[] o2) {
-      return PROXY_BA.compare(o1, o2);
+      final Comparator<byte[]> c = PROXY_BA.getComparator();
+      return c.compare(o1, o2);
     }
   }
 
@@ -157,23 +159,25 @@ private static class ByteBufferRunner implements ComparatorRunner {
 
     @Override
     public int compare(final byte[] o1, final byte[] o2) {
+      final Comparator<ByteBuffer> c = PROXY_OPTIMAL.getComparator();
+
       // Convert arrays to buffers that are larger than the array, with
       // limit set at the array length. One buffer bigger than the other.
       ByteBuffer o1b = arrayToBuffer(o1, o1.length * 3);
       ByteBuffer o2b = arrayToBuffer(o2, o2.length * 2);
-      final int result = PROXY_OPTIMAL.compare(o1b, o2b);
+      final int result = c.compare(o1b, o2b);
 
       // Now swap which buffer is bigger
       o1b = arrayToBuffer(o1, o1.length * 2);
       o2b = arrayToBuffer(o2, o2.length * 3);
-      final int result2 = PROXY_OPTIMAL.compare(o1b, o2b);
+      final int result2 = c.compare(o1b, o2b);
 
       assertThat(result2, is(result));
 
       // Now try with buffers sized to the array.
       o1b = ByteBuffer.wrap(o1);
       o2b = ByteBuffer.wrap(o2);
-      final int result3 = PROXY_OPTIMAL.compare(o1b, o2b);
+      final int result3 = c.compare(o1b, o2b);
 
       assertThat(result3, is(result));
 
@@ -201,7 +205,8 @@ private static class DirectBufferRunner implements ComparatorRunner {
     public int compare(final byte[] o1, final byte[] o2) {
       final DirectBuffer o1b = new UnsafeBuffer(o1);
       final DirectBuffer o2b = new UnsafeBuffer(o2);
-      return PROXY_DB.compare(o1b, o2b);
+      final Comparator<DirectBuffer> c = PROXY_DB.getComparator();
+      return c.compare(o1b, o2b);
     }
   }
 
@@ -240,7 +245,8 @@ public int compare(final byte[] o1, final byte[] o2) {
       final ByteBuf o2b = DEFAULT.directBuffer(o2.length);
       o1b.writeBytes(o1);
       o2b.writeBytes(o2);
-      return ByteBufProxy.PROXY_NETTY.compare(o1b, o2b);
+      final Comparator<ByteBuf> c = PROXY_NETTY.getComparator();
+      return c.compare(o1b, o2b);
     }
   }
 
diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index af7ca27f..e08e9a0c 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -131,10 +131,14 @@ public void before() throws IOException {
         .setMaxDbs(1)
         .open(path, POSIX_MODE, MDB_NOSUBDIR);
     db = env.openDbi(DB_1, MDB_CREATE);
+    populateDatabase(db);
+  }
+
+  private void populateDatabase(final Dbi<ByteBuffer> dbi) {
     list = new LinkedList<>();
     list.addAll(asList(2, 3, 4, 5, 6, 7, 8, 9));
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      final Cursor<ByteBuffer> c = db.openCursor(txn);
+      final Cursor<ByteBuffer> c = dbi.openCursor(txn);
       c.put(bb(2), bb(3), MDB_NOOVERWRITE);
       c.put(bb(4), bb(5));
       c.put(bb(6), bb(7));
@@ -267,8 +271,10 @@ public void openClosedBackwardTestWithGuava() {
       bb2.reset();
       return guava.compare(array1, array2);
     };
-    verify(openClosedBackward(bb(7), bb(2)), comparator, 6, 4, 2);
-    verify(openClosedBackward(bb(8), bb(4)), comparator, 6, 4);
+    final Dbi<ByteBuffer> guavaDbi = env.openDbi(DB_1, comparator, MDB_CREATE);
+    populateDatabase(guavaDbi);
+    verify(openClosedBackward(bb(7), bb(2)), guavaDbi, 6, 4, 2);
+    verify(openClosedBackward(bb(8), bb(4)), guavaDbi, 6, 4);
   }
 
   @Test
@@ -356,17 +362,17 @@ public void forEachRemainingWithClosedEnvTest() {
     }
   }
 
-  private void verify(final KeyRange<ByteBuffer> range, final int... expected) {
-    verify(range, null, expected);
+  private void verify(final KeyRange<ByteBuffer> range,
+                      final int... expected) {
+    verify(range, db, expected);
   }
 
   private void verify(final KeyRange<ByteBuffer> range,
-                      final Comparator<ByteBuffer> comparator,
-                      final int... expected) {
+                      final Dbi<ByteBuffer> dbi, final int... expected) {
     final List<Integer> results = new ArrayList<>();
 
     try (Txn<ByteBuffer> txn = env.txnRead();
-         CursorIterable<ByteBuffer> c = db.iterate(txn, range, comparator)) {
+         CursorIterable<ByteBuffer> c = dbi.iterate(txn, range)) {
       for (final KeyVal<ByteBuffer> kv : c) {
         final int key = kv.key().getInt();
         final int val = kv.val().getInt();
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 6db5a9b8..8646aec2 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -43,6 +43,7 @@
 import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
 import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
+import static org.lmdbjava.DbiFlags.MDB_INTEGERKEY;
 import static org.lmdbjava.DbiFlags.MDB_REVERSEKEY;
 import static org.lmdbjava.Env.create;
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
@@ -117,13 +118,13 @@ public void close() {
   @Test
   public void customComparator() {
     final Comparator<ByteBuffer> reverseOrder = (o1, o2) -> {
-      final int lexicalOrder = ByteBufferProxy.PROXY_OPTIMAL.compare(o1, o2);
-      if (lexicalOrder == 0) {
+      final int lexical = PROXY_OPTIMAL.getComparator().compare(o1, o2);
+      if (lexical == 0) {
         return 0;
       }
-      return lexicalOrder * -1;
+      return lexical * -1;
     };
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, reverseOrder, MDB_CREATE);
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, reverseOrder, true, MDB_CREATE);
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       assertThat(db.put(txn, bb(2), bb(3)), is(true));
       assertThat(db.put(txn, bb(4), bb(6)), is(true));
@@ -150,8 +151,9 @@ public void dbOpenMaxDatabases() {
 
   @Test
   public void dbiWithComparatorThreadSafety() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, PROXY_OPTIMAL::compare,
-                                           MDB_CREATE);
+    final DbiFlags[] flags = new DbiFlags[] {MDB_CREATE, MDB_INTEGERKEY};
+    final Comparator<ByteBuffer> c = PROXY_OPTIMAL.getComparator(flags);
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, c, true, flags);
 
     final List<Integer> keys = range(0, 1_000).boxed().collect(toList());
 

From 0dc67805a55341d24e49db342c51ff2aecb02f50 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Sat, 4 Feb 2023 15:30:18 +1100
Subject: [PATCH 164/322] JavaDoc corrections (#199)

---
 src/main/java/org/lmdbjava/CursorIterable.java | 6 ------
 src/main/java/org/lmdbjava/Env.java            | 2 +-
 2 files changed, 1 insertion(+), 7 deletions(-)

diff --git a/src/main/java/org/lmdbjava/CursorIterable.java b/src/main/java/org/lmdbjava/CursorIterable.java
index 681f805b..39a6d58c 100644
--- a/src/main/java/org/lmdbjava/CursorIterable.java
+++ b/src/main/java/org/lmdbjava/CursorIterable.java
@@ -41,12 +41,6 @@
  * <p>
  * An instance will create and close its own cursor.
  *
- * <p>
- * If iterating over keys stored with {@link DbiFlags#MDB_INTEGERKEY} you must
- * provide a Java comparator when constructing the {@link Dbi} or this class. It
- * is more efficient to use a comparator only with this class, as this avoids
- * LMDB calling back into Java code to perform the integer key comparison.
- *
  * @param <T> buffer type
  */
 public final class CursorIterable<T> implements
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 66ab7cda..0a4c034b 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -365,7 +365,7 @@ public Dbi<T> openDbi(final byte[] name, final Comparator<T> comparator,
    * secondary (but uncommon) use of the comparator is to act as a callback from
    * the native library if <code>nativeCb</code> is <code>true</code>. This is
    * usually avoided due to the overhead of native code calling back into Java.
-   * It is instead highly recommended to set the correct {@link DbiFlag}s to
+   * It is instead highly recommended to set the correct {@link DbiFlags} to
    * allow the native library to correctly order the intended keys.
    *
    * <p>

From 860c827e0b377cb55f6967ff66777428603456a1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pedro=20Lamar=C3=A3o?= <pedro.lamarao@gmail.com>
Date: Wed, 8 Mar 2023 22:29:36 -0300
Subject: [PATCH 165/322] Define manifest attribute Automatic-Module-Name.
 (#213)

---
 pom.xml | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/pom.xml b/pom.xml
index 20b02b04..09b36edb 100644
--- a/pom.xml
+++ b/pom.xml
@@ -117,6 +117,17 @@
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-enforcer-plugin</artifactId>
       </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-jar-plugin</artifactId>
+        <configuration>
+          <archive>
+            <manifestEntries>
+              <Automatic-Module-Name>org.lmdbjava</Automatic-Module-Name>
+            </manifestEntries>
+          </archive>
+        </configuration>
+      </plugin>
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-pmd-plugin</artifactId>

From 9cf97a5cd28cbf996a1b206148f586626982880b Mon Sep 17 00:00:00 2001
From: Martin Hristov <tran4o@gmail.com>
Date: Thu, 9 Mar 2023 03:31:27 +0200
Subject: [PATCH 166/322] Library.java : fix mdb_reader_check api, Env.java :
 readerCheck impl (#212)

* Library.java : fix mdb_reader_check api, Env.java : readerCheck impl

* whitespace in Library.java

* upd

* update Env.java

* remove tabs
---
 src/main/java/org/lmdbjava/Env.java     | 12 ++++++++++++
 src/main/java/org/lmdbjava/Library.java |  2 +-
 2 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 0a4c034b..db8b0f4a 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -41,6 +41,7 @@
 import java.util.List;
 
 import jnr.ffi.Pointer;
+import jnr.ffi.byref.IntByReference;
 import jnr.ffi.byref.PointerByReference;
 import org.lmdbjava.Library.MDB_envinfo;
 import org.lmdbjava.Library.MDB_stat;
@@ -500,6 +501,15 @@ private void validatePath(final File path) {
     validateDirectoryEmpty(path);
   }
 
+  
+  /* Check for stale entries in the reader lock table. */
+  public int readerCheck() {
+    final IntByReference resultPtr = new IntByReference();
+    checkRc(LIB.mdb_reader_check(ptr, resultPtr));
+    return resultPtr.intValue();
+  }
+  
+  
   /**
    * Object has already been closed and the operation is therefore prohibited.
    */
@@ -530,6 +540,7 @@ public AlreadyOpenException() {
     }
   }
 
+ 
   /**
    * Builder for configuring and opening Env.
    *
@@ -595,6 +606,7 @@ public Env<T> open(final File path, final EnvFlags... flags) {
       return open(path, 0664, flags);
     }
 
+
     /**
      * Sets the map size.
      *
diff --git a/src/main/java/org/lmdbjava/Library.java b/src/main/java/org/lmdbjava/Library.java
index 44b17492..e48def73 100644
--- a/src/main/java/org/lmdbjava/Library.java
+++ b/src/main/java/org/lmdbjava/Library.java
@@ -291,7 +291,7 @@ int mdb_put(@In Pointer txn, @In Pointer dbi, @In Pointer key,
                 @In Pointer data,
                 int flags);
 
-    int mdb_reader_check(@In Pointer env, int dead);
+    int mdb_reader_check(@In Pointer env, @Out IntByReference dead);
 
     int mdb_set_compare(@In Pointer txn, @In Pointer dbi, ComparatorCallback cb);
 

From 0c636f1a2718de9d3e01c8afd04699a162265539 Mon Sep 17 00:00:00 2001
From: Ian Kang <iankan@amazon.com>
Date: Thu, 23 Mar 2023 16:16:16 -0400
Subject: [PATCH 167/322] Hold strong reference to all buffers passed to
 LmdbJava (fixes #207)

---
 pom.xml                                       |   8 ++
 src/main/java/org/lmdbjava/Cursor.java        |   7 ++
 src/main/java/org/lmdbjava/Dbi.java           |   6 +
 src/main/java/org/lmdbjava/ReferenceUtil.java |  55 +++++++++
 .../org/lmdbjava/GarbageCollectionTest.java   | 111 ++++++++++++++++++
 5 files changed, 187 insertions(+)
 create mode 100644 src/main/java/org/lmdbjava/ReferenceUtil.java
 create mode 100644 src/test/java/org/lmdbjava/GarbageCollectionTest.java

diff --git a/pom.xml b/pom.xml
index 09b36edb..fa025026 100644
--- a/pom.xml
+++ b/pom.xml
@@ -88,6 +88,12 @@
       <version>0.9.29-1</version>
       <optional>true</optional>
     </dependency>
+    <dependency>
+      <groupId>org.mockito</groupId>
+      <artifactId>mockito-inline</artifactId>
+      <version>4.11.0</version>
+      <scope>test</scope>
+    </dependency>
   </dependencies>
   <build>
     <plugins>
@@ -110,6 +116,8 @@
           </usedDependencies>
           <ignoredDependencies>
             <ignoredDependency>com.github.jnr:jffi</ignoredDependency>
+            <ignoredDependency>org.mockito:mockito-core</ignoredDependency>
+            <ignoredDependency>org.mockito:mockito-inline</ignoredDependency>
           </ignoredDependencies>
         </configuration>
       </plugin>
diff --git a/src/main/java/org/lmdbjava/Cursor.java b/src/main/java/org/lmdbjava/Cursor.java
index aa98a9ea..ed7c1848 100644
--- a/src/main/java/org/lmdbjava/Cursor.java
+++ b/src/main/java/org/lmdbjava/Cursor.java
@@ -162,6 +162,7 @@ public boolean get(final T key, final T data, final SeekOp op) {
     checkRc(rc);
     kv.keyOut();
     kv.valOut();
+    ReferenceUtil.reachabilityFence0(key);
     return true;
   }
 
@@ -192,6 +193,7 @@ public boolean get(final T key, final GetOp op) {
     checkRc(rc);
     kv.keyOut();
     kv.valOut();
+    ReferenceUtil.reachabilityFence0(key);
     return true;
   }
 
@@ -266,6 +268,8 @@ public boolean put(final T key, final T val, final PutFlags... op) {
       return false;
     }
     checkRc(rc);
+    ReferenceUtil.reachabilityFence0(key);
+    ReferenceUtil.reachabilityFence0(val);
     return true;
   }
 
@@ -304,6 +308,8 @@ public void putMultiple(final T key, final T val, final int elements,
     final int rc = LIB.mdb_cursor_put(ptrCursor, txn.kv().pointerKey(),
                                       dataPtr, mask);
     checkRc(rc);
+    ReferenceUtil.reachabilityFence0(key);
+    ReferenceUtil.reachabilityFence0(val);
   }
 
   /**
@@ -362,6 +368,7 @@ public T reserve(final T key, final int size, final PutFlags... op) {
     checkRc(LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(),
                                flags));
     kv.valOut();
+    ReferenceUtil.reachabilityFence0(key);
     return val();
   }
 
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index d0eb0a14..ef8ec315 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -171,6 +171,8 @@ public boolean delete(final Txn<T> txn, final T key, final T val) {
       return false;
     }
     checkRc(rc);
+    ReferenceUtil.reachabilityFence0(key);
+    ReferenceUtil.reachabilityFence0(val);
     return true;
   }
 
@@ -239,6 +241,7 @@ public T get(final Txn<T> txn, final T key) {
       return null;
     }
     checkRc(rc);
+    ReferenceUtil.reachabilityFence0(key);
     return txn.kv().valOut(); // marked as out in LMDB C docs
   }
 
@@ -386,6 +389,8 @@ public boolean put(final Txn<T> txn, final T key, final T val,
       return false;
     }
     checkRc(rc);
+    ReferenceUtil.reachabilityFence0(key);
+    ReferenceUtil.reachabilityFence0(val);
     return true;
   }
 
@@ -421,6 +426,7 @@ public T reserve(final Txn<T> txn, final T key, final int size,
     checkRc(LIB.mdb_put(txn.pointer(), ptr, txn.kv().pointerKey(), txn.kv()
                         .pointerVal(), flags));
     txn.kv().valOut(); // marked as in,out in LMDB C docs
+    ReferenceUtil.reachabilityFence0(key);
     return txn.val();
   }
 
diff --git a/src/main/java/org/lmdbjava/ReferenceUtil.java b/src/main/java/org/lmdbjava/ReferenceUtil.java
new file mode 100644
index 00000000..0002a509
--- /dev/null
+++ b/src/main/java/org/lmdbjava/ReferenceUtil.java
@@ -0,0 +1,55 @@
+/*-
+ * #%L
+ * LmdbJava
+ * %%
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
+ * %%
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * #L%
+ */
+
+package org.lmdbjava;
+
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+
+public final class ReferenceUtil {
+    /**
+     * Ensures that the object referenced by the given reference remains
+     * <a href="package-summary.html#reachability"><em>strongly reachable</em></a>,
+     * regardless of any prior actions of the program that might otherwise cause
+     * the object to become unreachable; thus, the referenced object is not
+     * reclaimable by garbage collection at least until after the invocation of
+     * this method.
+     *
+     * <p> Recent versions of the JDK have a nasty habit of prematurely deciding objects are unreachable.
+     * see: https://stackoverflow.com/questions/26642153/finalize-called-on-strongly-reachable-object-in-java-8
+     * The Java 9 method Reference.reachabilityFence offers a solution to this problem.
+     *
+     * <p> This method is always implemented as a synchronization on {@code ref}, not as
+     * {@code Reference.reachabilityFence} for consistency across platforms and to allow building on JDK 6-8.
+     * <b>It is the caller's responsibility to ensure that this synchronization will not cause deadlock.</b>
+     *
+     * @param ref the reference. If {@code null}, this method has no effect.
+     * @see https://github.com/netty/netty/pull/8410
+     */
+    @SuppressFBWarnings({"ESync_EMPTY_SYNC", "UC_USELESS_VOID_METHOD"})
+    public static void reachabilityFence0(Object ref) {
+        if (ref != null) {
+            synchronized (ref) {
+                // Empty synchronized is ok: https://stackoverflow.com/a/31933260/1151521
+            }
+        }
+    }
+
+    private ReferenceUtil() {}
+}
diff --git a/src/test/java/org/lmdbjava/GarbageCollectionTest.java b/src/test/java/org/lmdbjava/GarbageCollectionTest.java
new file mode 100644
index 00000000..aa8a8856
--- /dev/null
+++ b/src/test/java/org/lmdbjava/GarbageCollectionTest.java
@@ -0,0 +1,111 @@
+/*-
+ * #%L
+ * LmdbJava
+ * %%
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
+ * %%
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * #L%
+ */
+
+package org.lmdbjava;
+
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+import static java.nio.ByteBuffer.allocateDirect;
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.junit.Assert.fail;
+import static org.lmdbjava.DbiFlags.MDB_CREATE;
+import static org.lmdbjava.Env.create;
+
+@SuppressFBWarnings({"DM_GC", "RV_RETURN_VALUE_IGNORED_NO_SIDE_EFFECT"})
+@SuppressWarnings("PMD.DoNotCallGarbageCollectionExplicitly")
+public class GarbageCollectionTest {
+
+    private static final String DB_NAME = "my DB";
+    private static final String KEY_PREFIX = "Uncorruptedkey";
+    private static final String VAL_PREFIX = "Uncorruptedval";
+
+    @Rule
+    public final TemporaryFolder tmp = new TemporaryFolder();
+    private void putBuffer(Dbi<ByteBuffer> db, Txn<ByteBuffer> txn, int i) {
+        ByteBuffer key = allocateDirect(24);
+        ByteBuffer val = allocateDirect(24);
+        key.put((KEY_PREFIX+i).getBytes(UTF_8)).flip();
+        val.put((VAL_PREFIX+i).getBytes(UTF_8)).flip();
+        db.put(txn, key, val);
+    }
+    @Test
+    public void buffersNotGarbageCollectedTest() throws IOException {
+        final File path = tmp.newFolder();
+
+        final Env<ByteBuffer> env = create()
+                .setMapSize(2_085_760_999)
+                .setMaxDbs(1)
+                .open(path);
+        final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
+
+        // Trigger compilation and whatnot
+        try (Txn<ByteBuffer> txn = env.txnWrite()) {
+            for (int i = 0; i < 5000; i++) {
+                putBuffer(db, txn, i);
+            }
+            txn.commit();
+        }
+        // Call gc before writing to lmdb and after last reference to buffer by changing the behavior of mask
+        try (MockedStatic<MaskedFlag> mockedStatic = Mockito.mockStatic(MaskedFlag.class)) {
+            mockedStatic.when(MaskedFlag::mask).thenAnswer(invocationOnMock -> {
+                System.gc();
+                return 0;
+            });
+            try (Txn<ByteBuffer> txn = env.txnWrite()) {
+                for (int i = 0; i < 1000; i++) {
+                    putBuffer(db, txn, i);
+                }
+                txn.commit();
+            }
+        }
+
+        // Find corrupt keys
+        try (Txn<ByteBuffer> txn = env.txnRead()) {
+            try (Cursor<ByteBuffer> c = db.openCursor(txn)) {
+                if (c.first()) {
+                    do {
+                        byte[] rkey = new byte[c.key().remaining()];
+                        c.key().get(rkey);
+                        byte[] rval = new byte[c.val().remaining()];
+                        c.val().get(rval);
+                        String skey = new String(rkey, UTF_8);
+                        String sval = new String(rval, UTF_8);
+                        if (!skey.startsWith("Uncorruptedkey")) {
+                            fail("Found corrupt key " + skey);
+                        }
+                        if (!sval.startsWith("Uncorruptedval")) {
+                            fail("Found corrupt val " + sval);
+                        }
+                    } while (c.next());
+                }
+            }
+        }
+        env.close();
+    }
+}

From 288bb09f00fdfe8f4d2d062aabc33e5dcbef8af8 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 24 Apr 2023 10:17:49 +1000
Subject: [PATCH 168/322] Zig cross-compilation of native libraries (#217)

This new approach provides a number of benefits:

1. The LmdbJava Native project can be archived. This project required
coordination with LmdbJava module releases and added extra artifacts
to Maven Central simply to wrap native libraries. The native project
also required a great deal of Maven configuration and it was always
tedious to support additional platforms. Using Zig eliminates the need
to run QEMU emulators in builds to support unusual platforms etc.

2. Zig supports numerous cross-compilation targets straight out of the
box. A full list is available via zig targets | jq -r '.libc[]' and
this presently lists 64 on my machine. This is likely to accommodate
most LmdbJava platform support requests we are likely to receive.

3. Platform naming conventions have now been standardised based on the
Zig target name. Support for individual build chains or specific
processors is now simplified and much more transparent.

4. The GitHub Action has been amended to perform cross-compilation
under Linux and upload the resulting native artifacts for later build
steps. The later build steps run the Verifier on a native VM where
available (eg Windows, Mac OS) and this therefore tests the
cross-compiled libraries.

5. Target name resolution logic has been refactored and externalised
in its own class with corresponding unit tests to ensure corner cases
are duly considered and any bugs more easily reproduced and
permanently rectified.

This change is backwards compatible with users who used (and may
continue to use) the lmdbjava.native.lib system property.
---
 .github/workflows/maven.yml                   |  27 +++
 .gitignore                                    |   1 +
 README.md                                     |  20 ++-
 cross-compile.sh                              |  27 +++
 pom.xml                                       |  45 -----
 src/main/java/org/lmdbjava/Library.java       |  52 +-----
 src/main/java/org/lmdbjava/TargetName.java    | 156 ++++++++++++++++++
 src/main/resources/org/lmdbjava/.gitignore    |   2 +
 .../java/org/lmdbjava/TargetNameTest.java     |  74 +++++++++
 9 files changed, 310 insertions(+), 94 deletions(-)
 create mode 100755 cross-compile.sh
 create mode 100644 src/main/java/org/lmdbjava/TargetName.java
 create mode 100644 src/main/resources/org/lmdbjava/.gitignore
 create mode 100644 src/test/java/org/lmdbjava/TargetNameTest.java

diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml
index 85d4385f..4c3ac069 100644
--- a/.github/workflows/maven.yml
+++ b/.github/workflows/maven.yml
@@ -22,14 +22,29 @@ jobs:
         java-version: 17
         cache: maven
 
+    - name: Install Zig
+      uses: goto-bus-stop/setup-zig@v2
+
+    - name: Cross compile using Zig
+      run: ./cross-compile.sh
+
     - name: Build with Maven
       run: mvn -B verify
 
+    - name: Store built native libraries for later jobs
+      uses: actions/upload-artifact@v3
+      with:
+        name: native-libraries
+        path: |
+          src/main/resources/org/lmdbjava/*.so
+          src/main/resources/org/lmdbjava/*.dll
+
     - name: Upload code coverage to Codecov
       uses: codecov/codecov-action@v3
 
   compatibility-checks:
     name: Java ${{ matrix.java }} on ${{ matrix.os }} Compatibility
+    needs: [build]
     runs-on: ${{ matrix.os }}
 
     strategy:
@@ -48,6 +63,12 @@ jobs:
           java-version: ${{ matrix.java }}
           cache: maven
 
+      - name: Fetch built native libraries
+        uses: actions/download-artifact@v3
+        with:
+          name: native-libraries
+          path: src/main/resources/org/lmdbjava
+
       - name: Execute verifier
         run: mvn -B test -Dtest=VerifierTest -DverificationSeconds=10
 
@@ -81,6 +102,12 @@ jobs:
         gpg-private-key: ${{ secrets.gpg_private_key }}
         gpg-passphrase: MAVEN_GPG_PASSPHRASE
 
+    - name: Install Zig
+      uses: goto-bus-stop/setup-zig@v2
+
+    - name: Cross compile using Zig
+      run: ./cross-compile.sh
+
     - name: Publish Maven package
       run: mvn -B -Possrh-deploy deploy -DskipTests
       env:
diff --git a/.gitignore b/.gitignore
index fe6430cb..0c771329 100644
--- a/.gitignore
+++ b/.gitignore
@@ -16,3 +16,4 @@ dependency-reduced-pom.xml
 gpg-sign.json
 mvn-sync.json
 secrets.tar
+lmdb
diff --git a/README.md b/README.md
index 450f814f..16ff78ae 100644
--- a/README.md
+++ b/README.md
@@ -27,7 +27,7 @@
 * Modern, idiomatic Java API (including iterators, key ranges, enums, exceptions etc)
 * Nothing to install (the JAR embeds the latest LMDB libraries for Linux, OS X and Windows)
 * Buffer agnostic (Java `ByteBuffer`, Agrona `DirectBuffer`, Netty `ByteBuf`, your own buffer)
-* 100% stock-standard, officially-released, widely-tested LMDB C code ([no extra](https://github.com/lmdbjava/native) C/JNI code)
+* 100% stock-standard, officially-released, widely-tested LMDB C code (no extra C/JNI code)
 * Low latency design (allocation-free; buffer pools; optional checks can be easily disabled in production etc)
 * Mature code (commenced in 2016) and used for heavy production workloads (eg > 500 TB of HFT data)
 * Actively maintained and with a "Zero Bug Policy" before every release (see [issues](https://github.com/lmdbjava/lmdbjava/issues))
@@ -55,6 +55,24 @@ We're happy to help you use LmdbJava. Simply
 [open a GitHub issue](https://github.com/lmdbjava/lmdbjava/issues) if you have
 any questions.
 
+### Building
+
+This project uses [Zig](https://ziglang.org/) to cross-compile the LMDB native
+library for all supported architectures. To locally build LmdbJava you must
+firstly install a recent version of Zig and then execute the project's
+[cross-compile.sh](https://github.com/lmdbjava/lmdbjava/tree/master/cross-compile.sh)
+script. This only needs to be repeated when the `cross-compile.sh` script is
+updated (eg following a new official release of the upstream LMDB library).
+
+If you do not wish to install Zig and/or use an operating system which cannot
+easily execute the `cross-compile.sh` script, you can download the compiled
+LMDB native library for your platform from a location of your choice and set the
+`lmdbjava.native.lib` system property to the resulting file system system
+location. Possible sources of a compiled LMDB native library include operating
+system package managers, running `cross-compile.sh` on a supported system, or
+copying it from the `org/lmdbjava` directory of any recent, officially released
+LmdbJava JAR.
+
 ### Contributing
 
 Contributions are welcome! Please see the [Contributing Guidelines](CONTRIBUTING.md).
diff --git a/cross-compile.sh b/cross-compile.sh
new file mode 100755
index 00000000..1ebf92f6
--- /dev/null
+++ b/cross-compile.sh
@@ -0,0 +1,27 @@
+#!/bin/bash
+
+set -o errexit
+
+rm -rf lmdb
+git clone --depth 1 --branch LMDB_0.9.29 https://github.com/LMDB/lmdb.git
+pushd lmdb/libraries/liblmdb
+trap popd SIGINT
+
+# zig targets | jq -r '.libc[]'
+for target in aarch64-linux-gnu \
+              aarch64-macos-none \
+              x86_64-linux-gnu \
+              x86_64-macos-none \
+              x86_64-windows-gnu
+do
+  echo "##### Building $target ####"
+  make -e clean liblmdb.so CC="zig cc -target $target" AR="zig ar"
+  if [[ "$target" == *-windows-* ]]; then
+    extension="dll"
+  else
+    extension="so"
+  fi
+  cp -v liblmdb.so ../../../src/main/resources/org/lmdbjava/$target.$extension
+done
+
+ls -l ../../../src/main/resources/org/lmdbjava
diff --git a/pom.xml b/pom.xml
index 09b36edb..4c8f03ba 100644
--- a/pom.xml
+++ b/pom.xml
@@ -70,24 +70,6 @@
       <groupId>org.hamcrest</groupId>
       <artifactId>hamcrest</artifactId>
     </dependency>
-    <dependency>
-      <groupId>org.lmdbjava</groupId>
-      <artifactId>lmdbjava-native-linux-x86_64</artifactId>
-      <version>0.9.29-1</version>
-      <optional>true</optional>
-    </dependency>
-    <dependency>
-      <groupId>org.lmdbjava</groupId>
-      <artifactId>lmdbjava-native-osx-x86_64</artifactId>
-      <version>0.9.29-1</version>
-      <optional>true</optional>
-    </dependency>
-    <dependency>
-      <groupId>org.lmdbjava</groupId>
-      <artifactId>lmdbjava-native-windows-x86_64</artifactId>
-      <version>0.9.29-1</version>
-      <optional>true</optional>
-    </dependency>
   </dependencies>
   <build>
     <plugins>
@@ -103,11 +85,6 @@
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-dependency-plugin</artifactId>
         <configuration>
-          <usedDependencies>
-            <usedDependency>org.lmdbjava:lmdbjava-native-linux-x86_64</usedDependency>
-            <usedDependency>org.lmdbjava:lmdbjava-native-windows-x86_64</usedDependency>
-            <usedDependency>org.lmdbjava:lmdbjava-native-osx-x86_64</usedDependency>
-          </usedDependencies>
           <ignoredDependencies>
             <ignoredDependency>com.github.jnr:jffi</ignoredDependency>
           </ignoredDependencies>
@@ -132,28 +109,6 @@
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-pmd-plugin</artifactId>
       </plugin>
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-shade-plugin</artifactId>
-        <executions>
-          <execution>
-            <id>lmdbjava-shade</id>
-            <goals>
-              <goal>shade</goal>
-            </goals>
-            <phase>package</phase>
-            <configuration>
-              <artifactSet>
-                <includes>
-                  <include>org.lmdbjava:lmdbjava-native-linux-x86_64</include>
-                  <include>org.lmdbjava:lmdbjava-native-windows-x86_64</include>
-                  <include>org.lmdbjava:lmdbjava-native-osx-x86_64</include>
-                </includes>
-              </artifactSet>
-            </configuration>
-          </execution>
-        </executions>
-      </plugin>
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-surefire-plugin</artifactId>
diff --git a/src/main/java/org/lmdbjava/Library.java b/src/main/java/org/lmdbjava/Library.java
index e48def73..22308600 100644
--- a/src/main/java/org/lmdbjava/Library.java
+++ b/src/main/java/org/lmdbjava/Library.java
@@ -21,11 +21,8 @@
 package org.lmdbjava;
 
 import static java.io.File.createTempFile;
-import static java.lang.Boolean.getBoolean;
 import static java.lang.System.getProperty;
 import static java.lang.Thread.currentThread;
-import static java.util.Locale.ENGLISH;
-import static java.util.Objects.nonNull;
 import static java.util.Objects.requireNonNull;
 import static jnr.ffi.LibraryLoader.create;
 import static jnr.ffi.Runtime.getRuntime;
@@ -55,35 +52,15 @@
  */
 final class Library {
 
-  /**
-   * Java system property name that can be set to disable automatic extraction
-   * of the LMDB system library from the LmdbJava JAR. This may be desirable if
-   * an operating system-provided LMDB system library is preferred (eg operating
-   * system package management, vendor support, special compiler flags, security
-   * auditing, profile guided optimization builds, faster startup time by
-   * avoiding the library copy etc).
-   */
-  public static final String DISABLE_EXTRACT_PROP = "lmdbjava.disable.extract";
   /**
    * Java system property name that can be set to the path of an existing
    * directory into which the LMDB system library will be extracted from the
    * LmdbJava JAR. If unspecified the LMDB system library is extracted to the
    * <code>java.io.tmpdir</code>. Ignored if the LMDB system library is not
    * being extracted from the LmdbJava JAR (as would be the case if other
-   * system properties defined in <code>Library</code> have been set).
+   * system properties defined in <code>TargetName</code> have been set).
    */
   public static final String LMDB_EXTRACT_DIR_PROP = "lmdbjava.extract.dir";
-  /**
-   * Java system property name that can be set to provide a custom path to a
-   * external LMDB system library. If set, the system property
-   * DISABLE_EXTRACT_PROP will be overridden.
-   */
-  public static final String LMDB_NATIVE_LIB_PROP = "lmdbjava.native.lib";
-  /**
-   * Indicates whether automatic extraction of the LMDB system library is
-   * permitted.
-   */
-  public static final boolean SHOULD_EXTRACT = !getBoolean(DISABLE_EXTRACT_PROP);
   /**
    * Indicates the directory where the LMDB system library will be extracted.
    */
@@ -91,35 +68,14 @@ final class Library {
                                                 getProperty("java.io.tmpdir"));
   static final Lmdb LIB;
   static final jnr.ffi.Runtime RUNTIME;
-  /**
-   * Indicates whether external LMDB system library is provided.
-   */
-  static final boolean SHOULD_USE_LIB = nonNull(
-      getProperty(LMDB_NATIVE_LIB_PROP));
-  private static final String LIB_NAME = "lmdb";
 
   static {
     final String libToLoad;
 
-    final String arch = getProperty("os.arch");
-    final boolean arch64 = "x64".equals(arch) || "amd64".equals(arch)
-                               || "x86_64".equals(arch);
-
-    final String os = getProperty("os.name");
-    final boolean linux = os.toLowerCase(ENGLISH).startsWith("linux");
-    final boolean osx = os.startsWith("Mac OS X");
-    final boolean windows = os.startsWith("Windows");
-
-    if (SHOULD_USE_LIB) {
-      libToLoad = getProperty(LMDB_NATIVE_LIB_PROP);
-    } else if (SHOULD_EXTRACT && arch64 && linux) {
-      libToLoad = extract("org/lmdbjava/lmdbjava-native-linux-x86_64.so");
-    } else if (SHOULD_EXTRACT && arch64 && osx) {
-      libToLoad = extract("org/lmdbjava/lmdbjava-native-osx-x86_64.dylib");
-    } else if (SHOULD_EXTRACT && arch64 && windows) {
-      libToLoad = extract("org/lmdbjava/lmdbjava-native-windows-x86_64.dll");
+    if (TargetName.IS_EXTERNAL) {
+      libToLoad = TargetName.RESOLVED_FILENAME;
     } else {
-      libToLoad = LIB_NAME;
+      libToLoad = extract(TargetName.RESOLVED_FILENAME);
     }
 
     LIB = create(Lmdb.class).load(libToLoad);
diff --git a/src/main/java/org/lmdbjava/TargetName.java b/src/main/java/org/lmdbjava/TargetName.java
new file mode 100644
index 00000000..3f8692a6
--- /dev/null
+++ b/src/main/java/org/lmdbjava/TargetName.java
@@ -0,0 +1,156 @@
+/*-
+ * #%L
+ * LmdbJava
+ * %%
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
+ * %%
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * #L%
+ */
+
+package org.lmdbjava;
+
+import static java.lang.System.getProperty;
+import static java.util.Locale.ENGLISH;
+
+/**
+ * Determines the name of the target LMDB native library.
+ *
+ * <p>
+ * Users will typically use an LMDB native library that is embedded within the
+ * LmdbJava JAR. Embedded libraries are built by a Zig cross-compilation step as
+ * part of the release process. The naming convention reflects the Zig target
+ * name plus a common filename extension. This simplifies support for future Zig
+ * targets (eg with different toolchains etc).
+ *
+ * <p>
+ * Users can set two system properties to override the automatic resolution of
+ * an embedded library. Setting {@link #LMDB_NATIVE_LIB_PROP} will force use of
+ * that external LMDB library. Setting {@link #LMDB_EMBEDDED_LIB_PROP} will
+ * force use of that embedded LMDB library. If both are set, the former property
+ * will take precedence. Most users do not need to set either property.
+ */
+public final class TargetName {
+
+  /**
+   * True if the resolved native filename is an external file (conversely false
+   * indicates the file should be considered a classpath resource).
+   */
+  public static final boolean IS_EXTERNAL;
+
+  /**
+   * Java system property name that can be set to override the embedded library
+   * that will be used. This is likely to required if automatic resolution fails
+   * but the user still prefers to use an LmdbJava-bundled library.
+   */
+  public static final String LMDB_EMBEDDED_LIB_PROP = "lmdbjava.embedded.lib";
+  /**
+   * Java system property name that can be set to provide a custom path to an
+   * external LMDB system library. This path must include the classpath prefix
+   * (usually <code>org/lmdbjava</code>).
+   */
+  public static final String LMDB_NATIVE_LIB_PROP = "lmdbjava.native.lib";
+  /**
+   * Resolved target native filename or fully-qualified classpath location.
+   */
+  public static final String RESOLVED_FILENAME;
+  private static final String ARCH = getProperty("os.arch");
+  private static final String EMBED = getProperty(LMDB_EMBEDDED_LIB_PROP);
+  private static final String EXTERNAL = getProperty(LMDB_NATIVE_LIB_PROP);
+  private static final String OS = getProperty("os.name");
+
+  static {
+    IS_EXTERNAL = isExternal(EXTERNAL);
+    RESOLVED_FILENAME = resolveFilename(EXTERNAL, EMBED, ARCH, OS);
+  }
+
+  private TargetName() {
+  }
+
+  public static String resolveExtension(final String os) {
+    return check(os, "Windows") ? "dll" : "so";
+  }
+
+  static boolean isExternal(final String external) {
+    return external != null && !external.isEmpty();
+  }
+
+  static String resolveFilename(final String external, final String embed,
+                                final String arch, final String os) {
+    if (external != null && !external.isEmpty()) {
+      return external;
+    }
+
+    if (embed != null && !embed.isEmpty()) {
+      return embed;
+    }
+
+    return "org/lmdbjava/" + resolveArch(arch) + "-" + resolveOs(os) + "-"
+               + resolveToolchain(os) + "." + resolveExtension(os);
+  }
+
+  /**
+   * Case insensitively checks whether the passed string starts with any of the
+   * candidate strings.
+   *
+   * @param string     the string being checked
+   * @param candidates one or more candidate strings
+   * @return true if the string starts with any of the candidates
+   */
+  private static boolean check(final String string,
+                               final String... candidates) {
+    if (string == null) {
+      return false;
+    }
+
+    final String strLower = string.toLowerCase(ENGLISH);
+    for (final String c : candidates) {
+      if (strLower.startsWith(c.toLowerCase(ENGLISH))) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  private static String err(final String reason) {
+    return reason + " (please set system property " + LMDB_NATIVE_LIB_PROP
+               + " to the path of an external LMDB native library or property "
+               + LMDB_EMBEDDED_LIB_PROP + " to the name of an LmdbJava embedded"
+               + " library; os.arch='" + ARCH + "' os.name='" + OS + "')";
+  }
+
+  private static String resolveArch(final String arch) {
+    if (check(arch, "aarch64")) {
+      return "aarch64";
+    } else if (check(arch, "x86_64", "amd64")) {
+      return "x86_64";
+    }
+    throw new UnsupportedOperationException(err("Unsupported os.arch"));
+  }
+
+  private static String resolveOs(final String os) {
+    if (check(os, "Linux")) {
+      return "linux";
+    } else if (check(os, "Mac OS")) {
+      return "macos";
+    } else if (check(os, "Windows")) {
+      return "windows";
+    }
+    throw new UnsupportedOperationException(err("Unsupported os.name"));
+  }
+
+  private static String resolveToolchain(final String os) {
+    return check(os, "Mac OS") ? "none" : "gnu";
+  }
+
+}
diff --git a/src/main/resources/org/lmdbjava/.gitignore b/src/main/resources/org/lmdbjava/.gitignore
new file mode 100644
index 00000000..661f98b3
--- /dev/null
+++ b/src/main/resources/org/lmdbjava/.gitignore
@@ -0,0 +1,2 @@
+*.so
+*.dll
diff --git a/src/test/java/org/lmdbjava/TargetNameTest.java b/src/test/java/org/lmdbjava/TargetNameTest.java
new file mode 100644
index 00000000..eec38233
--- /dev/null
+++ b/src/test/java/org/lmdbjava/TargetNameTest.java
@@ -0,0 +1,74 @@
+/*-
+ * #%L
+ * LmdbJava
+ * %%
+ * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
+ * %%
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * #L%
+ */
+
+package org.lmdbjava;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.lmdbjava.TargetName.isExternal;
+import static org.lmdbjava.TargetName.resolveFilename;
+import static org.lmdbjava.TestUtils.invokePrivateConstructor;
+
+import org.junit.Test;
+
+/**
+ * Test {@link TargetName}.
+ */
+public final class TargetNameTest {
+
+  private static final String NONE = "";
+
+  @Test
+  public void coverPrivateConstructors() {
+    invokePrivateConstructor(TargetName.class);
+  }
+
+  @Test
+  public void customEmbedded() {
+    assertThat(resolveFilename(NONE, "x/y.so", NONE, NONE), is("x/y.so"));
+    assertThat(isExternal(NONE), is(false));
+  }
+
+  @Test
+  public void embeddedNameResolution() {
+    embed("aarch64-linux-gnu.so", "aarch64", "Linux");
+    embed("aarch64-macos-none.so", "aarch64", "Mac OS");
+    embed("x86_64-linux-gnu.so", "x86_64", "Linux");
+    embed("x86_64-macos-none.so", "x86_64", "Mac OS");
+    embed("x86_64-windows-gnu.dll", "x86_64", "Windows");
+  }
+
+  @Test
+  public void externalLibrary() {
+    assertThat(resolveFilename("/l.so", NONE, NONE, NONE), is("/l.so"));
+    assertThat(TargetName.isExternal("/l.so"), is(true));
+  }
+
+  @Test
+  public void externalTakesPriority() {
+    assertThat(resolveFilename("/lm.so", "x/y.so", NONE, NONE), is("/lm.so"));
+    assertThat(isExternal("/lm.so"), is(true));
+  }
+
+  private void embed(final String lib, final String arch, final String os) {
+    assertThat(resolveFilename(NONE, NONE, arch, os), is("org/lmdbjava/" + lib));
+    assertThat(isExternal(NONE), is(false));
+  }
+}

From d87bc4b2cef38c28f9917d5f52cc1d4d962c08ea Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 24 Apr 2023 12:55:11 +1000
Subject: [PATCH 169/322] JavaDoc corrections (follows #217)

---
 src/main/java/org/lmdbjava/TargetName.java | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/main/java/org/lmdbjava/TargetName.java b/src/main/java/org/lmdbjava/TargetName.java
index 3f8692a6..48411044 100644
--- a/src/main/java/org/lmdbjava/TargetName.java
+++ b/src/main/java/org/lmdbjava/TargetName.java
@@ -50,14 +50,14 @@ public final class TargetName {
 
   /**
    * Java system property name that can be set to override the embedded library
-   * that will be used. This is likely to required if automatic resolution fails
-   * but the user still prefers to use an LmdbJava-bundled library.
+   * that will be used. This is likely to be required if automatic resolution
+   * fails but the user still prefers to use an LmdbJava-bundled library. This
+   * path must include the classpath prefix (usually <code>org/lmdbjava</code>).
    */
   public static final String LMDB_EMBEDDED_LIB_PROP = "lmdbjava.embedded.lib";
   /**
    * Java system property name that can be set to provide a custom path to an
-   * external LMDB system library. This path must include the classpath prefix
-   * (usually <code>org/lmdbjava</code>).
+   * external LMDB system library.
    */
   public static final String LMDB_NATIVE_LIB_PROP = "lmdbjava.native.lib";
   /**

From 98c233d110fb3876d1f3d7421bca86e514af3586 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 24 Apr 2023 13:22:19 +1000
Subject: [PATCH 170/322] Remove hard-coded package name resolution (follows
 #217)

---
 src/main/java/org/lmdbjava/TargetName.java | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/main/java/org/lmdbjava/TargetName.java b/src/main/java/org/lmdbjava/TargetName.java
index 48411044..446ea5b5 100644
--- a/src/main/java/org/lmdbjava/TargetName.java
+++ b/src/main/java/org/lmdbjava/TargetName.java
@@ -95,7 +95,8 @@ static String resolveFilename(final String external, final String embed,
       return embed;
     }
 
-    return "org/lmdbjava/" + resolveArch(arch) + "-" + resolveOs(os) + "-"
+    final String pkg = TargetName.class.getPackage().getName().replace('.', '/');
+    return pkg + "/" + resolveArch(arch) + "-" + resolveOs(os) + "-"
                + resolveToolchain(os) + "." + resolveExtension(os);
   }
 

From cbdaee61fce707aa33fae2738fd8653a7f78c04c Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 24 Apr 2023 14:25:20 +1000
Subject: [PATCH 171/322] Update formatting, documentation and limit GC test
 write frequency

The GarbageCollectionTest performing 1,000 GC operations caused a
substantial increase in test execution time. Trial and error found
commenting out the new ReferenceUtil.reachabilityFence0 references
resulted in the failures being consistently detected with a value of
250. Nevertheless even a value of 250 would result in the new test
being approximately 3 times longer in duration than any other test. To
resolve this the default value was reduced to 50 and a system property
introduced to allow any arbitrary value to be used. In turn the GitHub
Action was amended to test with 1,000 GC-inducing writes as per the
original code.

As an aside on OpenJDK Java 20 the mere presence of a call to
ReferenceUtil.reachabilityFence0 was sufficient to pass the
tests (even with high values such as 2,000) despite there being no
method body remaining in reachabilityFence0. As such it is unverified
whether the synchronization is actually required for the strong
reachability. This is consistent with
https://github.com/apache/datasketches-memory/issues/91#issuecomment-444294778.
In any event synchronization has been retained given it is the more
conservative approach.
---
 .github/workflows/maven.yml                   |   2 +-
 src/main/java/org/lmdbjava/ReferenceUtil.java |  68 +++++----
 .../org/lmdbjava/GarbageCollectionTest.java   | 144 +++++++++---------
 3 files changed, 116 insertions(+), 98 deletions(-)

diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml
index 4c3ac069..2a4f691c 100644
--- a/.github/workflows/maven.yml
+++ b/.github/workflows/maven.yml
@@ -29,7 +29,7 @@ jobs:
       run: ./cross-compile.sh
 
     - name: Build with Maven
-      run: mvn -B verify
+      run: mvn -B verify -DgcRecordWrites=1000
 
     - name: Store built native libraries for later jobs
       uses: actions/upload-artifact@v3
diff --git a/src/main/java/org/lmdbjava/ReferenceUtil.java b/src/main/java/org/lmdbjava/ReferenceUtil.java
index 0002a509..36bf9247 100644
--- a/src/main/java/org/lmdbjava/ReferenceUtil.java
+++ b/src/main/java/org/lmdbjava/ReferenceUtil.java
@@ -22,34 +22,46 @@
 
 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
 
+/**
+ * Supports creating strong references in manner compatible with Java 8.
+ */
 public final class ReferenceUtil {
-    /**
-     * Ensures that the object referenced by the given reference remains
-     * <a href="package-summary.html#reachability"><em>strongly reachable</em></a>,
-     * regardless of any prior actions of the program that might otherwise cause
-     * the object to become unreachable; thus, the referenced object is not
-     * reclaimable by garbage collection at least until after the invocation of
-     * this method.
-     *
-     * <p> Recent versions of the JDK have a nasty habit of prematurely deciding objects are unreachable.
-     * see: https://stackoverflow.com/questions/26642153/finalize-called-on-strongly-reachable-object-in-java-8
-     * The Java 9 method Reference.reachabilityFence offers a solution to this problem.
-     *
-     * <p> This method is always implemented as a synchronization on {@code ref}, not as
-     * {@code Reference.reachabilityFence} for consistency across platforms and to allow building on JDK 6-8.
-     * <b>It is the caller's responsibility to ensure that this synchronization will not cause deadlock.</b>
-     *
-     * @param ref the reference. If {@code null}, this method has no effect.
-     * @see https://github.com/netty/netty/pull/8410
-     */
-    @SuppressFBWarnings({"ESync_EMPTY_SYNC", "UC_USELESS_VOID_METHOD"})
-    public static void reachabilityFence0(Object ref) {
-        if (ref != null) {
-            synchronized (ref) {
-                // Empty synchronized is ok: https://stackoverflow.com/a/31933260/1151521
-            }
-        }
-    }
 
-    private ReferenceUtil() {}
+  private ReferenceUtil() {
+  }
+
+  /**
+   * Ensures that the object referenced by the given reference remains
+   * <em>strongly reachable</em>, regardless of any prior actions of the program
+   * that might otherwise cause the object to become unreachable. Thus, the
+   * referenced object is not reclaimable by garbage collection at least until
+   * after the invocation of this method.
+   *
+   * <p>
+   * Recent versions of the JDK have a nasty habit of prematurely deciding
+   * objects are unreachable (eg
+   * <a href="https://tinyurl.com/so26642153">StackOverflow question
+   * 26642153</a>.
+   *
+   * <p>
+   * <code>java.lang.ref.Reference.reachabilityFence</code> offers a solution to
+   * this problem, but it was only introduced in Java 9. LmdbJava presently
+   * supports Java 8 and therefore this method provides an alternative.
+   *
+   * <p>
+   * This method is always implemented as a synchronization on {@code ref}.
+   * <b>It is the caller's responsibility to ensure that this synchronization
+   * will not cause deadlock.</b>
+   *
+   * @param ref the reference (null is acceptable but has no effect)
+   * @see <a href="https://github.com/netty/netty/pull/8410">Netty PR 8410</a>
+   */
+  @SuppressFBWarnings({"ESync_EMPTY_SYNC", "UC_USELESS_VOID_METHOD"})
+  public static void reachabilityFence0(final Object ref) {
+    if (ref != null) {
+      synchronized (ref) {
+        // Empty synchronized is ok: https://stackoverflow.com/a/31933260/1151521
+      }
+    }
+  }
 }
diff --git a/src/test/java/org/lmdbjava/GarbageCollectionTest.java b/src/test/java/org/lmdbjava/GarbageCollectionTest.java
index aa8a8856..49d56b1d 100644
--- a/src/test/java/org/lmdbjava/GarbageCollectionTest.java
+++ b/src/test/java/org/lmdbjava/GarbageCollectionTest.java
@@ -20,6 +20,16 @@
 
 package org.lmdbjava;
 
+import static java.nio.ByteBuffer.allocateDirect;
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.junit.Assert.fail;
+import static org.lmdbjava.DbiFlags.MDB_CREATE;
+import static org.lmdbjava.Env.create;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
 import org.junit.Rule;
 import org.junit.Test;
@@ -27,85 +37,81 @@
 import org.mockito.MockedStatic;
 import org.mockito.Mockito;
 
-import java.io.File;
-import java.io.IOException;
-import java.nio.ByteBuffer;
-
-import static java.nio.ByteBuffer.allocateDirect;
-import static java.nio.charset.StandardCharsets.UTF_8;
-import static org.junit.Assert.fail;
-import static org.lmdbjava.DbiFlags.MDB_CREATE;
-import static org.lmdbjava.Env.create;
-
 @SuppressFBWarnings({"DM_GC", "RV_RETURN_VALUE_IGNORED_NO_SIDE_EFFECT"})
 @SuppressWarnings("PMD.DoNotCallGarbageCollectionExplicitly")
 public class GarbageCollectionTest {
 
-    private static final String DB_NAME = "my DB";
-    private static final String KEY_PREFIX = "Uncorruptedkey";
-    private static final String VAL_PREFIX = "Uncorruptedval";
+  private static final String DB_NAME = "my DB";
+  private static final String KEY_PREFIX = "Uncorruptedkey";
+  private static final String VAL_PREFIX = "Uncorruptedval";
 
-    @Rule
-    public final TemporaryFolder tmp = new TemporaryFolder();
-    private void putBuffer(Dbi<ByteBuffer> db, Txn<ByteBuffer> txn, int i) {
-        ByteBuffer key = allocateDirect(24);
-        ByteBuffer val = allocateDirect(24);
-        key.put((KEY_PREFIX+i).getBytes(UTF_8)).flip();
-        val.put((VAL_PREFIX+i).getBytes(UTF_8)).flip();
-        db.put(txn, key, val);
-    }
-    @Test
-    public void buffersNotGarbageCollectedTest() throws IOException {
-        final File path = tmp.newFolder();
+  @Rule
+  public final TemporaryFolder tmp = new TemporaryFolder();
 
-        final Env<ByteBuffer> env = create()
-                .setMapSize(2_085_760_999)
-                .setMaxDbs(1)
-                .open(path);
-        final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
+  @Test
+  public void buffersNotGarbageCollectedTest() throws IOException {
+    final File path = tmp.newFolder();
+    try (Env<ByteBuffer> env = create()
+        .setMapSize(2_085_760_999)
+        .setMaxDbs(1)
+        .open(path)) {
+      final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
 
-        // Trigger compilation and whatnot
-        try (Txn<ByteBuffer> txn = env.txnWrite()) {
-            for (int i = 0; i < 5000; i++) {
-                putBuffer(db, txn, i);
-            }
-            txn.commit();
+      try (Txn<ByteBuffer> txn = env.txnWrite()) {
+        for (int i = 0; i < 5_000; i++) {
+          putBuffer(db, txn, i);
         }
-        // Call gc before writing to lmdb and after last reference to buffer by changing the behavior of mask
-        try (MockedStatic<MaskedFlag> mockedStatic = Mockito.mockStatic(MaskedFlag.class)) {
-            mockedStatic.when(MaskedFlag::mask).thenAnswer(invocationOnMock -> {
-                System.gc();
-                return 0;
-            });
-            try (Txn<ByteBuffer> txn = env.txnWrite()) {
-                for (int i = 0; i < 1000; i++) {
-                    putBuffer(db, txn, i);
-                }
-                txn.commit();
-            }
+        txn.commit();
+      }
+
+      // Call GC before writing to LMDB and after last reference to buffer by
+      // changing the behavior of mask
+      try (MockedStatic<MaskedFlag> mockedStatic = Mockito.mockStatic(
+          MaskedFlag.class)) {
+        mockedStatic.when(MaskedFlag::mask).thenAnswer(invocationOnMock -> {
+          System.gc();
+          return 0;
+        });
+        final int gcRecordWrites = Integer.getInteger("gcRecordWrites", 50);
+        try (Txn<ByteBuffer> txn = env.txnWrite()) {
+          for (int i = 0; i < gcRecordWrites; i++) {
+            putBuffer(db, txn, i);
+          }
+          txn.commit();
         }
+      }
 
-        // Find corrupt keys
-        try (Txn<ByteBuffer> txn = env.txnRead()) {
-            try (Cursor<ByteBuffer> c = db.openCursor(txn)) {
-                if (c.first()) {
-                    do {
-                        byte[] rkey = new byte[c.key().remaining()];
-                        c.key().get(rkey);
-                        byte[] rval = new byte[c.val().remaining()];
-                        c.val().get(rval);
-                        String skey = new String(rkey, UTF_8);
-                        String sval = new String(rval, UTF_8);
-                        if (!skey.startsWith("Uncorruptedkey")) {
-                            fail("Found corrupt key " + skey);
-                        }
-                        if (!sval.startsWith("Uncorruptedval")) {
-                            fail("Found corrupt val " + sval);
-                        }
-                    } while (c.next());
-                }
-            }
+      // Find corrupt keys
+      try (Txn<ByteBuffer> txn = env.txnRead()) {
+        try (Cursor<ByteBuffer> c = db.openCursor(txn)) {
+          if (c.first()) {
+            do {
+              final byte[] rkey = new byte[c.key().remaining()];
+              c.key().get(rkey);
+              final byte[] rval = new byte[c.val().remaining()];
+              c.val().get(rval);
+              final String skey = new String(rkey, UTF_8);
+              final String sval = new String(rval, UTF_8);
+              if (!skey.startsWith("Uncorruptedkey")) {
+                fail("Found corrupt key " + skey);
+              }
+              if (!sval.startsWith("Uncorruptedval")) {
+                fail("Found corrupt val " + sval);
+              }
+            } while (c.next());
+          }
         }
-        env.close();
+      }
     }
+  }
+
+  private void putBuffer(final Dbi<ByteBuffer> db, final Txn<ByteBuffer> txn,
+                         final int i) {
+    final ByteBuffer key = allocateDirect(24);
+    final ByteBuffer val = allocateDirect(24);
+    key.put((KEY_PREFIX + i).getBytes(UTF_8)).flip();
+    val.put((VAL_PREFIX + i).getBytes(UTF_8)).flip();
+    db.put(txn, key, val);
+  }
+
 }

From 838a8a0e2663a5469f450dea4471054ee138bf8f Mon Sep 17 00:00:00 2001
From: Mark Wardle <mark@wardle.org>
Date: Tue, 25 Apr 2023 10:47:34 +0100
Subject: [PATCH 172/322] Fix build on aarch64 (e.g. Apple Silicon) (#218)

* Increase map size to multiple of larger page size

Most architectures such as x86 and x86-64 use 4KiB, while aarch64 systems can use 4, 16 or 64KiB. Apple Silicon machines currently have 16KiB page sizes. The LMDB documentation states that map size should be a multiple of the page size, so a 100KiB default map size for tests fails for systems with a page size that is not 4 KiB.

This commit simply increases the map size for tests. Of course, this applies only to these tests, as in production, users can choose the appropriate map size for their requirements and system architecture. It is not straightforward to determine architecture page size at runtime. Otherwise, it might be more appropriate to dynamically determine a minimum map size.

* Tweak test of page size

The options for determining architecture page size are a) environment variables, b) unsafe and undocumented JDK internals or c) looking to get answer using FFI. Given this test is asking checking the statistics returned by LMDB, on balance it is reasonable to simply validate we're getting a multiple of 4096 in the statistics report.

* Fix test for cut-off given large map sizes
---
 src/test/java/org/lmdbjava/CursorIterableTest.java |  2 +-
 src/test/java/org/lmdbjava/DbiTest.java            |  2 +-
 src/test/java/org/lmdbjava/EnvTest.java            | 11 ++++++-----
 src/test/java/org/lmdbjava/TxnTest.java            |  2 +-
 4 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index e08e9a0c..db28405a 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -126,7 +126,7 @@ public void atMostTest() {
   public void before() throws IOException {
     final File path = tmp.newFile();
     env = create()
-        .setMapSize(KIBIBYTES.toBytes(100))
+        .setMapSize(KIBIBYTES.toBytes(256))
         .setMaxReaders(1)
         .setMaxDbs(1)
         .open(path, POSIX_MODE, MDB_NOSUBDIR);
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 8646aec2..5a8cf549 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -460,7 +460,7 @@ public void stats() {
     assertThat(stat.entries, is(3L));
     assertThat(stat.leafPages, is(1L));
     assertThat(stat.overflowPages, is(0L));
-    assertThat(stat.pageSize, is(4_096));
+    assertThat(stat.pageSize % 4_096, is(0));
   }
 
   @Test(expected = MapFullException.class)
diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index f26d42f3..46d8766f 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -20,6 +20,7 @@
 
 package org.lmdbjava;
 
+import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
 import static com.jakewharton.byteunits.BinaryByteUnit.MEBIBYTES;
 import static java.nio.ByteBuffer.allocateDirect;
 import static org.hamcrest.CoreMatchers.containsString;
@@ -338,7 +339,7 @@ public void setMapSize() throws IOException {
     final Random rnd = new Random();
     try (Env<ByteBuffer> env = create()
         .setMaxReaders(1)
-        .setMapSize(50_000)
+        .setMapSize(KIBIBYTES.toBytes(256))
         .setMaxDbs(1)
         .open(path)) {
       final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
@@ -346,7 +347,7 @@ public void setMapSize() throws IOException {
       db.put(bb(1), bb(42));
       boolean mapFullExThrown = false;
       try {
-        for (int i = 0; i < 30; i++) {
+        for (int i = 0; i < 70; i++) {
           rnd.nextBytes(k);
           key.clear();
           key.put(k).flip();
@@ -358,7 +359,7 @@ public void setMapSize() throws IOException {
       }
       assertThat(mapFullExThrown, is(true));
 
-      env.setMapSize(500_000);
+      env.setMapSize(KIBIBYTES.toBytes(512));
 
       try (Txn<ByteBuffer> roTxn = env.txnRead()) {
         assertThat(db.get(roTxn, bb(1)).getInt(), is(42));
@@ -366,7 +367,7 @@ public void setMapSize() throws IOException {
 
       mapFullExThrown = false;
       try {
-        for (int i = 0; i < 30; i++) {
+        for (int i = 0; i < 70; i++) {
           rnd.nextBytes(k);
           key.clear();
           key.put(k).flip();
@@ -393,7 +394,7 @@ public void stats() throws IOException {
       assertThat(stat.entries, is(0L));
       assertThat(stat.leafPages, is(0L));
       assertThat(stat.overflowPages, is(0L));
-      assertThat(stat.pageSize, is(4_096));
+      assertThat(stat.pageSize % 4_096, is(0));
       assertThat(stat.toString(), containsString("pageSize="));
     }
   }
diff --git a/src/test/java/org/lmdbjava/TxnTest.java b/src/test/java/org/lmdbjava/TxnTest.java
index c115be0b..775a10a6 100644
--- a/src/test/java/org/lmdbjava/TxnTest.java
+++ b/src/test/java/org/lmdbjava/TxnTest.java
@@ -84,7 +84,7 @@ public void after() {
   public void before() throws IOException {
     path = tmp.newFile();
     env = create()
-        .setMapSize(KIBIBYTES.toBytes(100))
+        .setMapSize(KIBIBYTES.toBytes(256))
         .setMaxReaders(1)
         .setMaxDbs(2)
         .open(path, POSIX_MODE, MDB_NOSUBDIR);

From 790212695d21a2a8c38acb7c652eb49cf2295502 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Tue, 22 Aug 2023 16:23:33 +1000
Subject: [PATCH 173/322] private static final classes to be final (checkstyle)

---
 src/test/java/org/lmdbjava/ComparatorTest.java | 14 +++++++-------
 src/test/java/org/lmdbjava/KeyRangeTest.java   |  2 +-
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/test/java/org/lmdbjava/ComparatorTest.java b/src/test/java/org/lmdbjava/ComparatorTest.java
index f21604ee..8371a1ae 100644
--- a/src/test/java/org/lmdbjava/ComparatorTest.java
+++ b/src/test/java/org/lmdbjava/ComparatorTest.java
@@ -143,7 +143,7 @@ public void equalBuffers() {
   /**
    * Tests {@link ByteArrayProxy}.
    */
-  private static class ByteArrayRunner implements ComparatorRunner {
+  private static final class ByteArrayRunner implements ComparatorRunner {
 
     @Override
     public int compare(final byte[] o1, final byte[] o2) {
@@ -155,7 +155,7 @@ public int compare(final byte[] o1, final byte[] o2) {
   /**
    * Tests {@link ByteBufferProxy}.
    */
-  private static class ByteBufferRunner implements ComparatorRunner {
+  private static final class ByteBufferRunner implements ComparatorRunner {
 
     @Override
     public int compare(final byte[] o1, final byte[] o2) {
@@ -199,7 +199,7 @@ private ByteBuffer arrayToBuffer(final byte[] arr, final int bufferCapacity) {
   /**
    * Tests {@link DirectBufferProxy}.
    */
-  private static class DirectBufferRunner implements ComparatorRunner {
+  private static final class DirectBufferRunner implements ComparatorRunner {
 
     @Override
     public int compare(final byte[] o1, final byte[] o2) {
@@ -213,7 +213,7 @@ public int compare(final byte[] o1, final byte[] o2) {
   /**
    * Tests using Guava's {@link SignedBytes} comparator.
    */
-  private static class GuavaSignedBytes implements ComparatorRunner {
+  private static final class GuavaSignedBytes implements ComparatorRunner {
 
     @Override
     public int compare(final byte[] o1, final byte[] o2) {
@@ -225,7 +225,7 @@ public int compare(final byte[] o1, final byte[] o2) {
   /**
    * Tests using Guava's {@link UnsignedBytes} comparator.
    */
-  private static class GuavaUnsignedBytes implements ComparatorRunner {
+  private static final class GuavaUnsignedBytes implements ComparatorRunner {
 
     @Override
     public int compare(final byte[] o1, final byte[] o2) {
@@ -237,7 +237,7 @@ public int compare(final byte[] o1, final byte[] o2) {
   /**
    * Tests {@link ByteBufProxy}.
    */
-  private static class NettyRunner implements ComparatorRunner {
+  private static final class NettyRunner implements ComparatorRunner {
 
     @Override
     public int compare(final byte[] o1, final byte[] o2) {
@@ -254,7 +254,7 @@ public int compare(final byte[] o1, final byte[] o2) {
    * Tests {@link String} by providing a reference implementation of what a
    * comparator involving ASCII-encoded bytes should return.
    */
-  private static class StringRunner implements ComparatorRunner {
+  private static final class StringRunner implements ComparatorRunner {
 
     @Override
     public int compare(final byte[] o1, final byte[] o2) {
diff --git a/src/test/java/org/lmdbjava/KeyRangeTest.java b/src/test/java/org/lmdbjava/KeyRangeTest.java
index 1b4384f9..3ea8c146 100644
--- a/src/test/java/org/lmdbjava/KeyRangeTest.java
+++ b/src/test/java/org/lmdbjava/KeyRangeTest.java
@@ -233,7 +233,7 @@ private void verify(final KeyRange<Integer> range, final int... expected) {
    * We use <code>Integer</code> rather than the primitive to represent a
    * <code>null</code> buffer.
    */
-  private static class FakeCursor {
+  private static final class FakeCursor {
 
     private static final int[] KEYS = new int[]{2, 4, 6, 8};
     private int position;

From c5f5689394364dea6a75771d4e5a2a0787345db2 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Tue, 22 Aug 2023 16:23:56 +1000
Subject: [PATCH 174/322] Acegi Standard Project 0.7.0

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 57abcdcd..4f4706ee 100644
--- a/pom.xml
+++ b/pom.xml
@@ -4,7 +4,7 @@
   <parent>
     <groupId>au.com.acegi</groupId>
     <artifactId>acegi-standard-project</artifactId>
-    <version>0.6.7</version>
+    <version>0.7.0</version>
   </parent>
   <groupId>org.lmdbjava</groupId>
   <artifactId>lmdbjava</artifactId>

From e3c33f7649b6676dee94b34799af9d24e436664a Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Tue, 22 Aug 2023 16:25:31 +1000
Subject: [PATCH 175/322] Test on Java 20 instead of Java 19

---
 .github/workflows/maven.yml | 2 +-
 README.md                   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml
index 2a4f691c..c7df2ed3 100644
--- a/.github/workflows/maven.yml
+++ b/.github/workflows/maven.yml
@@ -50,7 +50,7 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest]
-        java: [8, 11, 17, 19]
+        java: [8, 11, 17, 20]
 
     steps:
       - name: Check out Git repository
diff --git a/README.md b/README.md
index 16ff78ae..168e046e 100644
--- a/README.md
+++ b/README.md
@@ -32,7 +32,7 @@
 * Mature code (commenced in 2016) and used for heavy production workloads (eg > 500 TB of HFT data)
 * Actively maintained and with a "Zero Bug Policy" before every release (see [issues](https://github.com/lmdbjava/lmdbjava/issues))
 * Available from [Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22org.lmdbjava%22%20AND%20a%3A%22lmdbjava%22) and [OSS Sonatype Snapshots](https://oss.sonatype.org/content/repositories/snapshots/org/lmdbjava/lmdbjava)
-* [Continuous integration](https://github.com/lmdbjava/lmdbjava/actions) testing on Linux, Windows and macOS with Java 8, 11, 17 and 19
+* [Continuous integration](https://github.com/lmdbjava/lmdbjava/actions) testing on Linux, Windows and macOS with Java 8, 11, 17 and 20
 
 ### Performance
 

From 9b65ffdf142278fd7da4fc18db8e86c8174bb4eb Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Tue, 22 Aug 2023 16:40:27 +1000
Subject: [PATCH 176/322] Duplicate Finder Maven Plugin only to run on Java 11+

---
 pom.xml | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/pom.xml b/pom.xml
index 4f4706ee..429e183a 100644
--- a/pom.xml
+++ b/pom.xml
@@ -125,10 +125,6 @@
           <reuseForks>false</reuseForks>
         </configuration>
       </plugin>
-      <plugin>
-        <groupId>org.basepom.maven</groupId>
-        <artifactId>duplicate-finder-maven-plugin</artifactId>
-      </plugin>
       <plugin>
         <groupId>org.codehaus.mojo</groupId>
         <artifactId>buildnumber-maven-plugin</artifactId>
@@ -225,6 +221,10 @@
             <groupId>org.apache.maven.plugins</groupId>
             <artifactId>maven-checkstyle-plugin</artifactId>
           </plugin>
+          <plugin>
+            <groupId>org.basepom.maven</groupId>
+            <artifactId>duplicate-finder-maven-plugin</artifactId>
+          </plugin>
         </plugins>
       </build>
     </profile>

From 1cc7e6c9e4c7e7a1e4dab6012e2d002b9bd05fba Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 4 Dec 2023 18:42:08 +1100
Subject: [PATCH 177/322] Test on Java 21

---
 .github/workflows/maven.yml | 4 ++--
 README.md                   | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml
index c7df2ed3..32668e32 100644
--- a/.github/workflows/maven.yml
+++ b/.github/workflows/maven.yml
@@ -19,7 +19,7 @@ jobs:
       uses: actions/setup-java@v3
       with:
         distribution: zulu
-        java-version: 17
+        java-version: 21
         cache: maven
 
     - name: Install Zig
@@ -50,7 +50,7 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest]
-        java: [8, 11, 17, 20]
+        java: [8, 11, 17, 21]
 
     steps:
       - name: Check out Git repository
diff --git a/README.md b/README.md
index 168e046e..048e57bc 100644
--- a/README.md
+++ b/README.md
@@ -32,7 +32,7 @@
 * Mature code (commenced in 2016) and used for heavy production workloads (eg > 500 TB of HFT data)
 * Actively maintained and with a "Zero Bug Policy" before every release (see [issues](https://github.com/lmdbjava/lmdbjava/issues))
 * Available from [Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22org.lmdbjava%22%20AND%20a%3A%22lmdbjava%22) and [OSS Sonatype Snapshots](https://oss.sonatype.org/content/repositories/snapshots/org/lmdbjava/lmdbjava)
-* [Continuous integration](https://github.com/lmdbjava/lmdbjava/actions) testing on Linux, Windows and macOS with Java 8, 11, 17 and 20
+* [Continuous integration](https://github.com/lmdbjava/lmdbjava/actions) testing on Linux, Windows and macOS with Java 8, 11, 17 and 21
 
 ### Performance
 

From 844c5195e40e1ab629b87633e857522101a958c4 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Tue, 5 Dec 2023 11:36:39 +1100
Subject: [PATCH 178/322] Update to JNR-FFI 2.2.15

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 429e183a..1ea89d76 100644
--- a/pom.xml
+++ b/pom.xml
@@ -26,7 +26,7 @@
     <dependency>
       <groupId>com.github.jnr</groupId>
       <artifactId>jnr-ffi</artifactId>
-      <version>2.2.13</version>
+      <version>2.2.15</version>
     </dependency>
     <dependency>
       <groupId>com.google.code.findbugs</groupId>

From bdccf3bc8593ad15342995124ef69bb5233275fd Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Tue, 5 Dec 2023 11:36:47 +1100
Subject: [PATCH 179/322] Update to Guava 32.1.3-JRE

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 1ea89d76..542f1b43 100644
--- a/pom.xml
+++ b/pom.xml
@@ -35,7 +35,7 @@
     <dependency>
       <groupId>com.google.guava</groupId>
       <artifactId>guava</artifactId>
-      <version>31.1-jre</version>
+      <version>32.1.3-jre</version>
       <scope>test</scope>
       <exclusions>
         <exclusion>

From 7ae7754a627c7d8153de4e907e2163be430cb03d Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Tue, 5 Dec 2023 11:37:02 +1100
Subject: [PATCH 180/322] Update to Netty Buffer 4.1.101.Final

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 542f1b43..205ef433 100644
--- a/pom.xml
+++ b/pom.xml
@@ -53,7 +53,7 @@
     <dependency>
       <groupId>io.netty</groupId>
       <artifactId>netty-buffer</artifactId>
-      <version>4.1.87.Final</version>
+      <version>4.1.101.Final</version>
       <optional>true</optional>
     </dependency>
     <dependency>

From 699b735de002dab61f68441279b30ecdb09f09e3 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Tue, 5 Dec 2023 11:37:13 +1100
Subject: [PATCH 181/322] Update to Agrona 1.20.0

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 205ef433..1946e3e9 100644
--- a/pom.xml
+++ b/pom.xml
@@ -63,7 +63,7 @@
     <dependency>
       <groupId>org.agrona</groupId>
       <artifactId>agrona</artifactId>
-      <version>1.17.1</version>
+      <version>1.20.0</version>
       <optional>true</optional>
     </dependency>
     <dependency>

From f17b63f0ab8c90946d30f360a75b9e3107886a0c Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Tue, 5 Dec 2023 12:34:17 +1100
Subject: [PATCH 182/322] [maven-release-plugin] prepare release lmdbjava-0.9.0

---
 pom.xml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pom.xml b/pom.xml
index 1946e3e9..52bc82f9 100644
--- a/pom.xml
+++ b/pom.xml
@@ -8,7 +8,7 @@
   </parent>
   <groupId>org.lmdbjava</groupId>
   <artifactId>lmdbjava</artifactId>
-  <version>0.9.0-SNAPSHOT</version>
+  <version>0.9.0</version>
   <packaging>jar</packaging>
   <name>LmdbJava</name>
   <description>Low latency Java API for the ultra-fast, embedded Symas Lightning Database (LMDB)</description>
@@ -176,7 +176,7 @@
     <connection>scm:git:git@github.com:${github.org}/${github.repo}.git</connection>
     <developerConnection>scm:git:git@github.com:${github.org}/${github.repo}.git</developerConnection>
     <url>git@github.com:${github.org}/${github.repo}.git</url>
-    <tag>HEAD</tag>
+    <tag>lmdbjava-0.9.0</tag>
   </scm>
   <issueManagement>
     <system>GitHub Issues</system>

From 991be9adcef071c3d805c2cf6b7ca128fa63fcf5 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Tue, 5 Dec 2023 12:34:24 +1100
Subject: [PATCH 183/322] [maven-release-plugin] prepare for next development
 iteration

---
 pom.xml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pom.xml b/pom.xml
index 52bc82f9..75ce0fe6 100644
--- a/pom.xml
+++ b/pom.xml
@@ -8,7 +8,7 @@
   </parent>
   <groupId>org.lmdbjava</groupId>
   <artifactId>lmdbjava</artifactId>
-  <version>0.9.0</version>
+  <version>0.9.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>LmdbJava</name>
   <description>Low latency Java API for the ultra-fast, embedded Symas Lightning Database (LMDB)</description>
@@ -176,7 +176,7 @@
     <connection>scm:git:git@github.com:${github.org}/${github.repo}.git</connection>
     <developerConnection>scm:git:git@github.com:${github.org}/${github.repo}.git</developerConnection>
     <url>git@github.com:${github.org}/${github.repo}.git</url>
-    <tag>lmdbjava-0.9.0</tag>
+    <tag>HEAD</tag>
   </scm>
   <issueManagement>
     <system>GitHub Issues</system>

From 5332a0e4a9d764e783029792c2edac18f17dfc8f Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Sun, 16 Feb 2025 23:34:56 +0000
Subject: [PATCH 184/322] Uplift jnr-ffi to 2.2.17 (#235) and upload-artifact /
 download-artifact actions

* Uplift jnr-ffi to 2.2.16

Potentially fixes this https://github.com/jnr/jffi/issues/138

* Uplift jnr-ffi to 2.2.17

* Uplift actions/upload-artifact to v4

* Uplift download-artifact action to v4

* Uplift upload-artifact action to v4
---
 .github/workflows/maven.yml | 8 ++++----
 pom.xml                     | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml
index 32668e32..4fc1b22c 100644
--- a/.github/workflows/maven.yml
+++ b/.github/workflows/maven.yml
@@ -32,7 +32,7 @@ jobs:
       run: mvn -B verify -DgcRecordWrites=1000
 
     - name: Store built native libraries for later jobs
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       with:
         name: native-libraries
         path: |
@@ -64,7 +64,7 @@ jobs:
           cache: maven
 
       - name: Fetch built native libraries
-        uses: actions/download-artifact@v3
+        uses: actions/download-artifact@v4
         with:
           name: native-libraries
           path: src/main/resources/org/lmdbjava
@@ -73,7 +73,7 @@ jobs:
         run: mvn -B test -Dtest=VerifierTest -DverificationSeconds=10
 
       - name: Upload Surefire reports on test failure
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         if: failure()
         with:
           name: surefire-test-log
@@ -116,7 +116,7 @@ jobs:
         MAVEN_CENTRAL_TOKEN: ${{ secrets.nexus_password }}
 
     - name: Debug settings.xml
-      uses: actions/upload-artifact@v3
+      uses: actions/upload-artifact@v4
       if: failure()
       with:
         name: settings.xml
diff --git a/pom.xml b/pom.xml
index 75ce0fe6..9ef2ea4f 100644
--- a/pom.xml
+++ b/pom.xml
@@ -26,7 +26,7 @@
     <dependency>
       <groupId>com.github.jnr</groupId>
       <artifactId>jnr-ffi</artifactId>
-      <version>2.2.15</version>
+      <version>2.2.17</version>
     </dependency>
     <dependency>
       <groupId>com.google.code.findbugs</groupId>

From b5dfb253767ca0d7ffcdfcdb8a00a50a31c84c7b Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Sun, 16 Feb 2025 23:37:16 +0000
Subject: [PATCH 185/322] Uplift lmdb from 0.9.29 to 0.9.31 (#245)

* Uplidt LMDB lib from 0.9.29 to 0.9.31

* Uplift upload-artifact action to v4
---
 cross-compile.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cross-compile.sh b/cross-compile.sh
index 1ebf92f6..ebf92d72 100755
--- a/cross-compile.sh
+++ b/cross-compile.sh
@@ -3,7 +3,7 @@
 set -o errexit
 
 rm -rf lmdb
-git clone --depth 1 --branch LMDB_0.9.29 https://github.com/LMDB/lmdb.git
+git clone --depth 1 --branch LMDB_0.9.31 https://github.com/LMDB/lmdb.git
 pushd lmdb/libraries/liblmdb
 trap popd SIGINT
 

From 68f0a4465d91a05cc3bebaf602f6afbe8ba3b44b Mon Sep 17 00:00:00 2001
From: Cosimo Damiano Prete <8491864+cdprete@users.noreply.github.com>
Date: Mon, 17 Feb 2025 00:46:30 +0100
Subject: [PATCH 186/322] Regression: Add DbiFlags#MDB_UNSIGNEDKEY to allow to
 compare byte array, ByteBuffer and DirectBuffer keys as unsigned like in
 versions prior to 0.9.0 (#237)

Co-authored-by: Cosimo Damiano Prete <cosimo.prete.damiano@gmail.com>
---
 src/main/java/org/lmdbjava/BufferProxy.java   | 22 ++++++-
 .../java/org/lmdbjava/ByteArrayProxy.java     | 50 +++++++++++----
 src/main/java/org/lmdbjava/ByteBufProxy.java  | 28 ++++++---
 .../java/org/lmdbjava/ByteBufferProxy.java    | 28 ++++-----
 src/main/java/org/lmdbjava/Cursor.java        | 10 +--
 src/main/java/org/lmdbjava/Dbi.java           | 38 +++++++-----
 src/main/java/org/lmdbjava/DbiFlags.java      | 21 ++++++-
 .../java/org/lmdbjava/DirectBufferProxy.java  | 40 +++++++-----
 src/main/java/org/lmdbjava/Env.java           | 42 +++++--------
 src/main/java/org/lmdbjava/MaskedFlag.java    | 62 +++++++++++++++----
 src/main/java/org/lmdbjava/Txn.java           |  6 +-
 11 files changed, 233 insertions(+), 114 deletions(-)

diff --git a/src/main/java/org/lmdbjava/BufferProxy.java b/src/main/java/org/lmdbjava/BufferProxy.java
index aff732bc..f42da7ff 100644
--- a/src/main/java/org/lmdbjava/BufferProxy.java
+++ b/src/main/java/org/lmdbjava/BufferProxy.java
@@ -21,6 +21,10 @@
 package org.lmdbjava;
 
 import static java.lang.Long.BYTES;
+import static org.lmdbjava.DbiFlags.MDB_INTEGERKEY;
+import static org.lmdbjava.DbiFlags.MDB_UNSIGNEDKEY;
+import static org.lmdbjava.MaskedFlag.isSet;
+import static org.lmdbjava.MaskedFlag.mask;
 
 import java.util.Comparator;
 
@@ -72,8 +76,24 @@ public abstract class BufferProxy<T> {
    * @param flags for the database
    * @return a comparator that can be used (never null)
    */
-  protected abstract Comparator<T> getComparator(DbiFlags... flags);
+  protected Comparator<T> getComparator(DbiFlags... flags) {
+    final int intFlag = mask(flags);
 
+    return isSet(intFlag, MDB_INTEGERKEY) || isSet(intFlag, MDB_UNSIGNEDKEY) ? getUnsignedComparator() : getSignedComparator();
+  }
+
+  /**
+   * Get a suitable default {@link Comparator} to compare numeric key values as unsigned.
+   *
+   * @return a comparator that can be used (never null)
+   */
+  protected abstract Comparator<T> getUnsignedComparator();
+  /**
+   * Get a suitable default {@link Comparator} to compare numeric key values as signed.
+   *
+   * @return a comparator that can be used (never null)
+   */
+  protected abstract Comparator<T> getSignedComparator();
   /**
    * Deallocate a buffer that was previously provided by {@link #allocate()}.
    *
diff --git a/src/main/java/org/lmdbjava/ByteArrayProxy.java b/src/main/java/org/lmdbjava/ByteArrayProxy.java
index 3fe8184a..2066b679 100644
--- a/src/main/java/org/lmdbjava/ByteArrayProxy.java
+++ b/src/main/java/org/lmdbjava/ByteArrayProxy.java
@@ -20,14 +20,15 @@
 
 package org.lmdbjava;
 
-import static java.util.Objects.requireNonNull;
-import static org.lmdbjava.Library.RUNTIME;
+import jnr.ffi.Pointer;
+import jnr.ffi.provider.MemoryManager;
 
 import java.util.Arrays;
 import java.util.Comparator;
 
-import jnr.ffi.Pointer;
-import jnr.ffi.provider.MemoryManager;
+import static java.lang.Math.min;
+import static java.util.Objects.requireNonNull;
+import static org.lmdbjava.Library.RUNTIME;
 
 /**
  * Byte array proxy.
@@ -43,7 +44,10 @@ public final class ByteArrayProxy extends BufferProxy<byte[]> {
 
   private static final MemoryManager MEM_MGR = RUNTIME.getMemoryManager();
 
-  private ByteArrayProxy() {
+  private static final Comparator<byte[]> signedComparator = ByteArrayProxy::compareArraysSigned;
+  private static final Comparator<byte[]> unsignedComparator = ByteArrayProxy::compareArrays;
+
+    private ByteArrayProxy() {
   }
 
   /**
@@ -60,7 +64,7 @@ public static int compareArrays(final byte[] o1, final byte[] o2) {
     if (o1 == o2) {
       return 0;
     }
-    final int minLength = Math.min(o1.length, o2.length);
+    final int minLength = min(o1.length, o2.length);
 
     for (int i = 0; i < minLength; i++) {
       final int lw = Byte.toUnsignedInt(o1[i]);
@@ -74,15 +78,32 @@ public static int compareArrays(final byte[] o1, final byte[] o2) {
     return o1.length - o2.length;
   }
 
+  /**
+   * Compare two byte arrays.
+   *
+   * @param b1 left operand (required)
+   * @param b2 right operand (required)
+   * @return as specified by {@link Comparable} interface
+   */
+  @SuppressWarnings("PMD.CompareObjectsWithEquals")
+  public static int compareArraysSigned(final byte[] b1, final byte[] b2) {
+    requireNonNull(b1);
+    requireNonNull(b2);
+
+    if (b1 == b2) return 0;
+
+    for(int i = 0; i < min(b1.length, b2.length); ++i) {
+      if(b1[i] != b2[i]) return b1[i] - b2[i];
+    }
+
+    return b1.length - b2.length;
+  }
+
   @Override
   protected byte[] allocate() {
     return new byte[0];
   }
 
-  protected int compare(final byte[] o1, final byte[] o2) {
-    return compareArrays(o1, o2);
-  }
-
   @Override
   protected void deallocate(final byte[] buff) {
     // byte arrays cannot be allocated
@@ -94,8 +115,13 @@ protected byte[] getBytes(final byte[] buffer) {
   }
 
   @Override
-  protected Comparator<byte[]> getComparator(final DbiFlags... flags) {
-    return this::compare;
+  protected Comparator<byte[]> getSignedComparator() {
+    return signedComparator;
+  }
+
+  @Override
+  protected Comparator<byte[]> getUnsignedComparator() {
+    return unsignedComparator;
   }
 
   @Override
diff --git a/src/main/java/org/lmdbjava/ByteBufProxy.java b/src/main/java/org/lmdbjava/ByteBufProxy.java
index 26351676..ed3d71e1 100644
--- a/src/main/java/org/lmdbjava/ByteBufProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufProxy.java
@@ -20,16 +20,17 @@
 
 package org.lmdbjava;
 
-import static io.netty.buffer.PooledByteBufAllocator.DEFAULT;
-import static java.lang.Class.forName;
-import static org.lmdbjava.UnsafeAccess.UNSAFE;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.PooledByteBufAllocator;
+import jnr.ffi.Pointer;
 
 import java.lang.reflect.Field;
 import java.util.Comparator;
 
-import io.netty.buffer.ByteBuf;
-import io.netty.buffer.PooledByteBufAllocator;
-import jnr.ffi.Pointer;
+import static io.netty.buffer.PooledByteBufAllocator.DEFAULT;
+import static java.lang.Class.forName;
+import static java.util.Objects.requireNonNull;
+import static org.lmdbjava.UnsafeAccess.UNSAFE;
 
 /**
  * A buffer proxy backed by Netty's {@link ByteBuf}.
@@ -51,6 +52,12 @@ public final class ByteBufProxy extends BufferProxy<ByteBuf> {
   private static final String FIELD_NAME_ADDRESS = "memoryAddress";
   private static final String FIELD_NAME_LENGTH = "length";
   private static final String NAME = "io.netty.buffer.PooledUnsafeDirectByteBuf";
+  private static final Comparator<ByteBuf> comparator = (o1, o2) -> {
+    requireNonNull(o1);
+    requireNonNull(o2);
+
+    return o1.compareTo(o2);
+  };
   private final long lengthOffset;
   private final long addressOffset;
   
@@ -107,13 +114,14 @@ protected ByteBuf allocate() {
     throw new IllegalStateException("Netty buffer must be " + NAME);
   }
 
-  protected int compare(final ByteBuf o1, final ByteBuf o2) {
-    return o1.compareTo(o2);
+  @Override
+  protected Comparator<ByteBuf> getSignedComparator() {
+    return comparator;
   }
 
   @Override
-  protected Comparator<ByteBuf> getComparator(final DbiFlags... flags) {
-    return this::compare;
+  protected Comparator<ByteBuf> getUnsignedComparator() {
+    return comparator;
   }
 
   @Override
diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
index 8eb95da8..9983d76e 100644
--- a/src/main/java/org/lmdbjava/ByteBufferProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -27,6 +27,7 @@
 import static java.nio.ByteOrder.LITTLE_ENDIAN;
 import static java.util.Objects.requireNonNull;
 import static org.lmdbjava.DbiFlags.MDB_INTEGERKEY;
+import static org.lmdbjava.DbiFlags.MDB_UNSIGNEDKEY;
 import static org.lmdbjava.Env.SHOULD_CHECK;
 import static org.lmdbjava.MaskedFlag.isSet;
 import static org.lmdbjava.MaskedFlag.mask;
@@ -111,6 +112,14 @@ abstract static class AbstractByteBufferProxy extends BufferProxy<ByteBuffer> {
     protected static final String FIELD_NAME_ADDRESS = "address";
     protected static final String FIELD_NAME_CAPACITY = "capacity";
 
+    private static final Comparator<ByteBuffer> signedComparator = (o1, o2) -> {
+      requireNonNull(o1);
+      requireNonNull(o2);
+
+      return o1.compareTo(o2);
+    };
+    private static final Comparator<ByteBuffer> unsignedComparator = AbstractByteBufferProxy::compareBuff;
+
     /**
      * A thread-safe pool for a given length. If the buffer found is valid (ie
      * not of a negative length) then that buffer is used. If no valid buffer is
@@ -193,22 +202,13 @@ protected final ByteBuffer allocate() {
     }
 
     @Override
-    protected Comparator<ByteBuffer> getComparator(final DbiFlags... flags) {
-      final int flagInt = mask(flags);
-      if (isSet(flagInt, MDB_INTEGERKEY)) {
-        return this::compareCustom;
-      }
-      return this::compareDefault;
+    protected Comparator<ByteBuffer> getSignedComparator() {
+      return signedComparator;
     }
 
-    protected final int compareDefault(final ByteBuffer o1,
-                                       final ByteBuffer o2) {
-      return o1.compareTo(o2);
-    }
-
-    protected final int compareCustom(final ByteBuffer o1,
-                                      final ByteBuffer o2) {
-      return compareBuff(o1, o2);
+    @Override
+    protected Comparator<ByteBuffer> getUnsignedComparator() {
+      return unsignedComparator;
     }
 
     @Override
diff --git a/src/main/java/org/lmdbjava/Cursor.java b/src/main/java/org/lmdbjava/Cursor.java
index ed7c1848..cb9130e3 100644
--- a/src/main/java/org/lmdbjava/Cursor.java
+++ b/src/main/java/org/lmdbjava/Cursor.java
@@ -40,6 +40,8 @@
 import jnr.ffi.Pointer;
 import jnr.ffi.byref.NativeLongByReference;
 
+import java.util.Arrays;
+
 /**
  * A cursor handle.
  *
@@ -120,7 +122,7 @@ public void delete(final PutFlags... f) {
       txn.checkReady();
       txn.checkWritesAllowed();
     }
-    final int flags = mask(f);
+    final int flags = mask(true, f);
     checkRc(LIB.mdb_cursor_del(ptrCursor, flags));
   }
 
@@ -256,7 +258,7 @@ public boolean put(final T key, final T val, final PutFlags... op) {
     }
     kv.keyIn(key);
     kv.valIn(val);
-    final int mask = mask(op);
+    final int mask = mask(true, op);
     final int rc = LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(),
                                       kv.pointerVal(), mask);
     if (rc == MDB_KEYEXIST) {
@@ -299,7 +301,7 @@ public void putMultiple(final T key, final T val, final int elements,
       txn.checkReady();
       txn.checkWritesAllowed();
     }
-    final int mask = mask(op);
+    final int mask = mask(true, op);
     if (SHOULD_CHECK && !isSet(mask, MDB_MULTIPLE)) {
       throw new IllegalArgumentException("Must set " + MDB_MULTIPLE + " flag");
     }
@@ -364,7 +366,7 @@ public T reserve(final T key, final int size, final PutFlags... op) {
     }
     kv.keyIn(key);
     kv.valIn(size);
-    final int flags = mask(op) | MDB_RESERVE.getMask();
+    final int flags = mask(true, op) | MDB_RESERVE.getMask();
     checkRc(LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(),
                                flags));
     kv.valOut();
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index ef8ec315..c5be4f85 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -20,6 +20,17 @@
 
 package org.lmdbjava;
 
+import jnr.ffi.Pointer;
+import jnr.ffi.byref.IntByReference;
+import jnr.ffi.byref.PointerByReference;
+import org.lmdbjava.Library.ComparatorCallback;
+import org.lmdbjava.Library.MDB_stat;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+
 import static java.util.Objects.requireNonNull;
 import static jnr.ffi.Memory.allocateDirect;
 import static jnr.ffi.NativeType.ADDRESS;
@@ -36,17 +47,6 @@
 import static org.lmdbjava.PutFlags.MDB_RESERVE;
 import static org.lmdbjava.ResultCodeMapper.checkRc;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Comparator;
-import java.util.List;
-
-import jnr.ffi.Pointer;
-import jnr.ffi.byref.IntByReference;
-import jnr.ffi.byref.PointerByReference;
-import org.lmdbjava.Library.ComparatorCallback;
-import org.lmdbjava.Library.MDB_stat;
-
 /**
  * LMDB Database.
  *
@@ -64,10 +64,18 @@ public final class Dbi<T> {
   Dbi(final Env<T> env, final Txn<T> txn, final byte[] name,
       final Comparator<T> comparator, final boolean nativeCb,
       final BufferProxy<T> proxy, final DbiFlags... flags) {
+    if (SHOULD_CHECK) {
+      requireNonNull(txn);
+      txn.checkReady();
+    }
     this.env = env;
     this.name = name == null ? null : Arrays.copyOf(name, name.length);
-    this.comparator = comparator;
-    final int flagsMask = mask(flags);
+    if(comparator == null) {
+      this.comparator = proxy.getComparator(flags);
+    } else {
+      this.comparator = comparator;
+    }
+    final int flagsMask = mask(true, flags);
     final Pointer dbiPtr = allocateDirect(RUNTIME, ADDRESS);
     checkRc(LIB.mdb_dbi_open(txn.pointer(), name, flagsMask, dbiPtr));
     ptr = dbiPtr.getPointer(0);
@@ -377,7 +385,7 @@ public boolean put(final Txn<T> txn, final T key, final T val,
     }
     txn.kv().keyIn(key);
     txn.kv().valIn(val);
-    final int mask = mask(flags);
+    final int mask = mask(true, flags);
     final int rc = LIB.mdb_put(txn.pointer(), ptr, txn.kv().pointerKey(), txn
                                .kv().pointerVal(), mask);
     if (rc == MDB_KEYEXIST) {
@@ -422,7 +430,7 @@ public T reserve(final Txn<T> txn, final T key, final int size,
     }
     txn.kv().keyIn(key);
     txn.kv().valIn(size);
-    final int flags = mask(op) | MDB_RESERVE.getMask();
+    final int flags = mask(true, op) | MDB_RESERVE.getMask();
     checkRc(LIB.mdb_put(txn.pointer(), ptr, txn.kv().pointerKey(), txn.kv()
                         .pointerVal(), flags));
     txn.kv().valOut(); // marked as in,out in LMDB C docs
diff --git a/src/main/java/org/lmdbjava/DbiFlags.java b/src/main/java/org/lmdbjava/DbiFlags.java
index 081fb80e..7277b55b 100644
--- a/src/main/java/org/lmdbjava/DbiFlags.java
+++ b/src/main/java/org/lmdbjava/DbiFlags.java
@@ -68,6 +68,15 @@ public enum DbiFlags implements MaskedFlag {
    * similar to {@link #MDB_INTEGERKEY} keys.
    */
   MDB_INTEGERDUP(0x20),
+  /**
+   * Compare the <b>numeric</b> keys in native byte order and as unsigned.
+   *
+   * <p>
+   * This option is applied only to {@link java.nio.ByteBuffer}, {@link org.agrona.DirectBuffer} and byte array keys.
+   * {@link io.netty.buffer.ByteBuf} keys are always compared in native byte order and as unsigned.
+   * </p>
+   */
+  MDB_UNSIGNEDKEY(0x30, false),
   /**
    * With {@link #MDB_DUPSORT}, use reverse string dups.
    *
@@ -86,9 +95,15 @@ public enum DbiFlags implements MaskedFlag {
   MDB_CREATE(0x4_0000);
 
   private final int mask;
+  private final boolean propagatedToLmdb;
 
-  DbiFlags(final int mask) {
+  DbiFlags(final int mask, final boolean propagatedToLmdb) {
     this.mask = mask;
+    this.propagatedToLmdb = propagatedToLmdb;
+  }
+
+  DbiFlags(final int mask) {
+    this(mask, true);
   }
 
   @Override
@@ -96,4 +111,8 @@ public int getMask() {
     return mask;
   }
 
+  @Override
+  public boolean isPropagatedToLmdb() {
+    return propagatedToLmdb;
+  }
 }
diff --git a/src/main/java/org/lmdbjava/DirectBufferProxy.java b/src/main/java/org/lmdbjava/DirectBufferProxy.java
index 62b49095..3bde81ec 100644
--- a/src/main/java/org/lmdbjava/DirectBufferProxy.java
+++ b/src/main/java/org/lmdbjava/DirectBufferProxy.java
@@ -20,20 +20,20 @@
 
 package org.lmdbjava;
 
-import static java.lang.ThreadLocal.withInitial;
-import static java.nio.ByteBuffer.allocateDirect;
-import static java.nio.ByteOrder.BIG_ENDIAN;
-import static java.util.Objects.requireNonNull;
-import static org.lmdbjava.UnsafeAccess.UNSAFE;
+import jnr.ffi.Pointer;
+import org.agrona.DirectBuffer;
+import org.agrona.MutableDirectBuffer;
+import org.agrona.concurrent.UnsafeBuffer;
 
 import java.nio.ByteBuffer;
 import java.util.ArrayDeque;
 import java.util.Comparator;
 
-import jnr.ffi.Pointer;
-import org.agrona.DirectBuffer;
-import org.agrona.MutableDirectBuffer;
-import org.agrona.concurrent.UnsafeBuffer;
+import static java.lang.ThreadLocal.withInitial;
+import static java.nio.ByteBuffer.allocateDirect;
+import static java.nio.ByteOrder.BIG_ENDIAN;
+import static java.util.Objects.requireNonNull;
+import static org.lmdbjava.UnsafeAccess.UNSAFE;
 
 /**
  * A buffer proxy backed by Agrona's {@link DirectBuffer}.
@@ -42,6 +42,13 @@
  * This class requires {@link UnsafeAccess} and Agrona must be in the classpath.
  */
 public final class DirectBufferProxy extends BufferProxy<DirectBuffer> {
+  private static final Comparator<DirectBuffer> signedComparator = (o1, o2) -> {
+    requireNonNull(o1);
+    requireNonNull(o2);
+
+    return o1.compareTo(o2);
+  };
+  private static final Comparator<DirectBuffer> unsignedComparator = DirectBufferProxy::compareBuff;
 
   /**
    * The {@link MutableDirectBuffer} proxy. Guaranteed to never be null,
@@ -112,8 +119,14 @@ protected DirectBuffer allocate() {
     }
   }
 
-  protected int compare(final DirectBuffer o1, final DirectBuffer o2) {
-    return compareBuff(o1, o2);
+  @Override
+  protected Comparator<DirectBuffer> getSignedComparator() {
+    return signedComparator;
+  }
+
+  @Override
+  protected Comparator<DirectBuffer> getUnsignedComparator() {
+    return unsignedComparator;
   }
 
   @Override
@@ -129,11 +142,6 @@ protected byte[] getBytes(final DirectBuffer buffer) {
     return dest;
   }
 
-  @Override
-  protected Comparator<DirectBuffer> getComparator(final DbiFlags... flags) {
-    return this::compare;
-  }
-
   @Override
   protected void in(final DirectBuffer buffer, final Pointer ptr,
                     final long ptrAddr) {
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index db8b0f4a..ae7e46c9 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -20,6 +20,19 @@
 
 package org.lmdbjava;
 
+import jnr.ffi.Pointer;
+import jnr.ffi.byref.IntByReference;
+import jnr.ffi.byref.PointerByReference;
+import org.lmdbjava.Library.MDB_envinfo;
+import org.lmdbjava.Library.MDB_stat;
+
+import java.io.File;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
 import static java.lang.Boolean.getBoolean;
 import static java.nio.charset.StandardCharsets.UTF_8;
 import static java.util.Objects.requireNonNull;
@@ -33,19 +46,6 @@
 import static org.lmdbjava.ResultCodeMapper.checkRc;
 import static org.lmdbjava.TxnFlags.MDB_RDONLY_TXN;
 
-import java.io.File;
-import java.nio.ByteBuffer;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.List;
-
-import jnr.ffi.Pointer;
-import jnr.ffi.byref.IntByReference;
-import jnr.ffi.byref.PointerByReference;
-import org.lmdbjava.Library.MDB_envinfo;
-import org.lmdbjava.Library.MDB_stat;
-
 /**
  * LMDB environment.
  *
@@ -159,7 +159,7 @@ public void close() {
   public void copy(final File path, final CopyFlags... flags) {
     requireNonNull(path);
     validatePath(path);
-    final int flagsMask = mask(flags);
+    final int flagsMask = mask(true, flags);
     checkRc(LIB.mdb_env_copy2(ptr, path.getAbsolutePath(), flagsMask));
   }
 
@@ -388,17 +388,7 @@ public Dbi<T> openDbi(final byte[] name, final Comparator<T> comparator,
   public Dbi<T> openDbi(final Txn<T> txn, final byte[] name,
                         final Comparator<T> comparator, final boolean nativeCb,
                         final DbiFlags... flags) {
-    if (SHOULD_CHECK) {
-      requireNonNull(txn);
-      txn.checkReady();
-    }
-    final Comparator<T> useComparator;
-    if (comparator == null) {
-      useComparator = proxy.getComparator(flags);
-    } else {
-      useComparator = comparator;
-    }
-    return new Dbi<>(this, txn, name, useComparator, nativeCb, proxy, flags);
+    return new Dbi<>(this, txn, name, comparator, nativeCb, proxy, flags);
   }
 
   /**
@@ -583,7 +573,7 @@ public Env<T> open(final File path, final int mode,
         checkRc(LIB.mdb_env_set_mapsize(ptr, mapSize));
         checkRc(LIB.mdb_env_set_maxdbs(ptr, maxDbs));
         checkRc(LIB.mdb_env_set_maxreaders(ptr, maxReaders));
-        final int flagsMask = mask(flags);
+        final int flagsMask = mask(true, flags);
         final boolean readOnly = isSet(flagsMask, MDB_RDONLY_ENV);
         final boolean noSubDir = isSet(flagsMask, MDB_NOSUBDIR);
         checkRc(LIB.mdb_env_open(ptr, path.getAbsolutePath(), flagsMask, mode));
diff --git a/src/main/java/org/lmdbjava/MaskedFlag.java b/src/main/java/org/lmdbjava/MaskedFlag.java
index 9bdef636..242ca589 100644
--- a/src/main/java/org/lmdbjava/MaskedFlag.java
+++ b/src/main/java/org/lmdbjava/MaskedFlag.java
@@ -20,6 +20,11 @@
 
 package org.lmdbjava;
 
+import java.util.Arrays;
+import java.util.Objects;
+import java.util.function.Predicate;
+import java.util.stream.Stream;
+
 import static java.util.Objects.requireNonNull;
 
 /**
@@ -34,25 +39,58 @@ public interface MaskedFlag {
    */
   int getMask();
 
+  /**
+   * Indicates if the flag must be propagated to the underlying C code of LMDB or not.
+   *
+   * @return the boolean value indicating the propagation
+   */
+  default boolean isPropagatedToLmdb() {
+    return true;
+  }
+
+  /**
+   * Fetch the integer mask for all presented flags.
+   *
+   * @param flags to mask (null or empty returns zero)
+   * @return the integer mask for use in C
+   */
+  @SafeVarargs
+  static <M extends MaskedFlag> int mask(final M... flags) {
+    return mask(false, flags);
+  }
+
   /**
    * Fetch the integer mask for all presented flags.
    *
    * @param flags to mask (null or empty returns zero)
    * @return the integer mask for use in C
    */
-  static int mask(final MaskedFlag... flags) {
-    if (flags == null || flags.length == 0) {
-      return 0;
-    }
+  static <M extends MaskedFlag> int mask(final Stream<M> flags) {
+    return mask(false, flags);
+  }
+
+  /**
+   * Fetch the integer mask for the presented flags.
+   *
+   * @param onlyPropagatedToLmdb if to include only the flags which are also propagate to the C code or all of them
+   * @param flags to mask (null or empty returns zero)
+   * @return the integer mask for use in C
+   */
+  @SafeVarargs
+  static <M extends MaskedFlag> int mask(final boolean onlyPropagatedToLmdb, final M... flags) {
+    return flags == null ? 0 : mask(onlyPropagatedToLmdb, Arrays.stream(flags));
+  }
+
+  /**
+   * Fetch the integer mask for all presented flags.
+   *
+   * @param onlyPropagatedToLmdb if to include only the flags which are also propagate to the C code or all of them
+   * @return the integer mask for use in C
+   */
+  static <M extends MaskedFlag> int mask(final boolean onlyPropagatedToLmdb, final Stream<M> flags) {
+    final Predicate<M> filter = onlyPropagatedToLmdb ? MaskedFlag::isPropagatedToLmdb : f -> true;
 
-    int result = 0;
-    for (final MaskedFlag flag : flags) {
-      if (flag == null) {
-        continue;
-      }
-      result |= flag.getMask();
-    }
-    return result;
+    return flags == null ? 0 : flags.filter(Objects::nonNull).filter(filter).map(M::getMask).reduce(0, (f1, f2) -> f1 | f2);
   }
 
   /**
diff --git a/src/main/java/org/lmdbjava/Txn.java b/src/main/java/org/lmdbjava/Txn.java
index b6d28917..3092c7c4 100644
--- a/src/main/java/org/lmdbjava/Txn.java
+++ b/src/main/java/org/lmdbjava/Txn.java
@@ -20,6 +20,8 @@
 
 package org.lmdbjava;
 
+import jnr.ffi.Pointer;
+
 import static jnr.ffi.Memory.allocateDirect;
 import static jnr.ffi.NativeType.ADDRESS;
 import static org.lmdbjava.Env.SHOULD_CHECK;
@@ -34,8 +36,6 @@
 import static org.lmdbjava.Txn.State.RESET;
 import static org.lmdbjava.TxnFlags.MDB_RDONLY_TXN;
 
-import jnr.ffi.Pointer;
-
 /**
  * LMDB transaction.
  *
@@ -55,7 +55,7 @@ public final class Txn<T> implements AutoCloseable {
       final TxnFlags... flags) {
     this.proxy = proxy;
     this.keyVal = proxy.keyVal();
-    final int flagsMask = mask(flags);
+    final int flagsMask = mask(true, flags);
     this.readOnly = isSet(flagsMask, MDB_RDONLY_TXN);
     if (env.isReadOnly() && !this.readOnly) {
       throw new EnvIsReadOnly();

From 309d8d9be4d2ff84109fa0b140afd2910d1f49d3 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 17 Feb 2025 13:32:42 +1100
Subject: [PATCH 187/322] Refactor project build configuration

This commit makes no functional changes to any LmdbJava code. It is
purely confined to build system related adjustments. These are aimed
at simplifying long-term maintenance and ease of third party
contributions. The changes include:

* Removal of parent POM
* Removal of PMD, SpotBugs and Checkstyle
* Replacement of license plugin
* Automatic code formatting (using Google style)
* Update to Codecov integration
---
 .github/workflows/maven.yml                   |   4 +-
 README.md                                     |   5 +
 cross-compile.sh                              |  16 +
 pom.xml                                       | 351 ++++++++++++++++--
 src/main/java/org/lmdbjava/BufferProxy.java   | 115 +++---
 .../java/org/lmdbjava/ByteArrayProxy.java     |  52 +--
 src/main/java/org/lmdbjava/ByteBufProxy.java  |  79 ++--
 .../java/org/lmdbjava/ByteBufferProxy.java    | 119 +++---
 src/main/java/org/lmdbjava/CopyFlags.java     |  28 +-
 src/main/java/org/lmdbjava/Cursor.java        | 127 +++----
 .../java/org/lmdbjava/CursorIterable.java     |  70 ++--
 src/main/java/org/lmdbjava/Dbi.java           | 246 ++++++------
 src/main/java/org/lmdbjava/DbiFlags.java      |  69 ++--
 .../java/org/lmdbjava/DirectBufferProxy.java  |  80 ++--
 src/main/java/org/lmdbjava/Env.java           | 319 +++++++---------
 src/main/java/org/lmdbjava/EnvFlags.java      | 166 ++++-----
 src/main/java/org/lmdbjava/EnvInfo.java       |  74 ++--
 src/main/java/org/lmdbjava/GetOp.java         |  36 +-
 src/main/java/org/lmdbjava/KeyRange.java      |  78 ++--
 src/main/java/org/lmdbjava/KeyRangeType.java  | 337 +++++++----------
 src/main/java/org/lmdbjava/KeyVal.java        |  35 +-
 src/main/java/org/lmdbjava/Library.java       | 103 ++---
 src/main/java/org/lmdbjava/LmdbException.java |  24 +-
 .../org/lmdbjava/LmdbNativeException.java     |  57 +--
 src/main/java/org/lmdbjava/MaskedFlag.java    |  52 +--
 src/main/java/org/lmdbjava/Meta.java          |  54 +--
 src/main/java/org/lmdbjava/PutFlags.java      |  45 +--
 src/main/java/org/lmdbjava/ReferenceUtil.java |  56 +--
 .../java/org/lmdbjava/ResultCodeMapper.java   |  31 +-
 src/main/java/org/lmdbjava/SeekOp.java        |  87 ++---
 src/main/java/org/lmdbjava/Stat.java          |  75 ++--
 src/main/java/org/lmdbjava/TargetName.java    | 108 +++---
 src/main/java/org/lmdbjava/Txn.java           | 140 +++----
 src/main/java/org/lmdbjava/TxnFlags.java      |  26 +-
 src/main/java/org/lmdbjava/UnsafeAccess.java  |  52 +--
 src/main/java/org/lmdbjava/Verifier.java      | 111 +++---
 src/main/java/org/lmdbjava/package-info.java  |  69 ++--
 src/misc/license-template.txt                 |  13 +
 .../org/lmdbjava/ByteBufferProxyTest.java     |  30 +-
 .../java/org/lmdbjava/ComparatorTest.java     |  79 ++--
 .../java/org/lmdbjava/CursorIterableTest.java |  83 ++---
 .../java/org/lmdbjava/CursorParamTest.java    |  68 ++--
 src/test/java/org/lmdbjava/CursorTest.java    |  88 ++---
 src/test/java/org/lmdbjava/DbiTest.java       | 137 +++----
 src/test/java/org/lmdbjava/EnvTest.java       | 136 ++-----
 .../org/lmdbjava/GarbageCollectionTest.java   |  47 +--
 src/test/java/org/lmdbjava/KeyRangeTest.java  |  36 +-
 src/test/java/org/lmdbjava/LibraryTest.java   |  21 +-
 .../java/org/lmdbjava/MaskedFlagTest.java     |  25 +-
 src/test/java/org/lmdbjava/MetaTest.java      |  25 +-
 .../org/lmdbjava/ResultCodeMapperTest.java    |  23 +-
 .../java/org/lmdbjava/TargetNameTest.java     |  21 +-
 src/test/java/org/lmdbjava/TestUtils.java     |  38 +-
 src/test/java/org/lmdbjava/TutorialTest.java  | 131 +++----
 src/test/java/org/lmdbjava/TxnTest.java       |  53 +--
 src/test/java/org/lmdbjava/VerifierTest.java  |  37 +-
 src/test/java/org/lmdbjava/package-info.java  |  20 +-
 57 files changed, 1991 insertions(+), 2616 deletions(-)
 create mode 100644 src/misc/license-template.txt

diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml
index 4fc1b22c..b28e8481 100644
--- a/.github/workflows/maven.yml
+++ b/.github/workflows/maven.yml
@@ -40,7 +40,9 @@ jobs:
           src/main/resources/org/lmdbjava/*.dll
 
     - name: Upload code coverage to Codecov
-      uses: codecov/codecov-action@v3
+      uses: codecov/codecov-action@v5
+      env:
+        CODECOV_TOKEN: ${{ secrets.CODECOV_ORG_TOKEN }}
 
   compatibility-checks:
     name: Java ${{ matrix.java }} on ${{ matrix.os }} Compatibility
diff --git a/README.md b/README.md
index 048e57bc..62c5abe1 100644
--- a/README.md
+++ b/README.md
@@ -73,6 +73,11 @@ system package managers, running `cross-compile.sh` on a supported system, or
 copying it from the `org/lmdbjava` directory of any recent, officially released
 LmdbJava JAR.
 
+### Releasing
+
+GitHub Actions will perform an official release whenever a developer executes
+`mvn release:clean release:prepare`.
+
 ### Contributing
 
 Contributions are welcome! Please see the [Contributing Guidelines](CONTRIBUTING.md).
diff --git a/cross-compile.sh b/cross-compile.sh
index ebf92d72..aa8815d5 100755
--- a/cross-compile.sh
+++ b/cross-compile.sh
@@ -1,4 +1,20 @@
 #!/bin/bash
+#
+# Copyright © 2016-2025 The LmdbJava Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
 
 set -o errexit
 
diff --git a/pom.xml b/pom.xml
index 9ef2ea4f..9e695d0f 100644
--- a/pom.xml
+++ b/pom.xml
@@ -1,11 +1,23 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+    Copyright © 2016-2025 The LmdbJava Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
+-->
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
   <modelVersion>4.0.0</modelVersion>
-  <parent>
-    <groupId>au.com.acegi</groupId>
-    <artifactId>acegi-standard-project</artifactId>
-    <version>0.7.0</version>
-  </parent>
   <groupId>org.lmdbjava</groupId>
   <artifactId>lmdbjava</artifactId>
   <version>0.9.1-SNAPSHOT</version>
@@ -13,9 +25,13 @@
   <name>LmdbJava</name>
   <description>Low latency Java API for the ultra-fast, embedded Symas Lightning Database (LMDB)</description>
   <properties>
-    <github.org>lmdbjava</github.org>
-    <github.repo>lmdbjava</github.repo>
-    <license.licenseName>apache_v2</license.licenseName>
+    <maven.build.timestamp.format>yyyy-MM-dd'T'HH:mm:ss'Z'</maven.build.timestamp.format>
+    <maven.compiler.source>1.8</maven.compiler.source>
+    <maven.compiler.target>1.8</maven.compiler.target>
+    <maven.enforcer.java>1.8</maven.enforcer.java>
+    <maven.enforcer.mvn>3.5.4</maven.enforcer.mvn>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    <trimStackTrace>false</trimStackTrace>
   </properties>
   <dependencies>
     <dependency>
@@ -28,10 +44,6 @@
       <artifactId>jnr-ffi</artifactId>
       <version>2.2.17</version>
     </dependency>
-    <dependency>
-      <groupId>com.google.code.findbugs</groupId>
-      <artifactId>annotations</artifactId>
-    </dependency>
     <dependency>
       <groupId>com.google.guava</groupId>
       <artifactId>guava</artifactId>
@@ -59,6 +71,14 @@
     <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
+      <version>4.13.2</version>
+      <scope>test</scope>
+      <exclusions>
+        <exclusion>
+          <groupId>org.hamcrest</groupId>
+          <artifactId>hamcrest-core</artifactId>
+        </exclusion>
+      </exclusions>
     </dependency>
     <dependency>
       <groupId>org.agrona</groupId>
@@ -69,6 +89,8 @@
     <dependency>
       <groupId>org.hamcrest</groupId>
       <artifactId>hamcrest</artifactId>
+      <version>2.2</version>
+      <scope>test</scope>
     </dependency>
     <dependency>
       <groupId>org.mockito</groupId>
@@ -80,73 +102,246 @@
   <build>
     <plugins>
       <plugin>
-        <groupId>au.com.acegi</groupId>
-        <artifactId>xml-format-maven-plugin</artifactId>
+        <groupId>com.mycila</groupId>
+        <artifactId>license-maven-plugin</artifactId>
+        <version>4.6</version>
+        <configuration>
+          <licenseSets>
+            <licenseSet>
+              <header>src/misc/license-template.txt</header>
+              <excludes>
+                <exclude>LICENSE.txt</exclude>
+                <exclude>**/*.md</exclude>
+                <exclude>lmdb/**</exclude>
+              </excludes>
+            </licenseSet>
+          </licenseSets>
+          <useDefaultExcludes>true</useDefaultExcludes>
+        </configuration>
+        <dependencies>
+          <dependency>
+            <groupId>com.mycila</groupId>
+            <artifactId>license-maven-plugin-git</artifactId>
+            <version>4.6</version>
+          </dependency>
+        </dependencies>
+        <executions>
+          <execution>
+            <id>apply-license</id>
+            <goals>
+              <goal>format</goal>
+            </goals>
+            <phase>package</phase>
+            <configuration>
+              <indentSize>2</indentSize>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-clean-plugin</artifactId>
+        <version>3.4.0</version>
+        <configuration>
+          <failOnError>false</failOnError>
+        </configuration>
       </plugin>
       <plugin>
-        <groupId>com.github.spotbugs</groupId>
-        <artifactId>spotbugs-maven-plugin</artifactId>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>3.13.0</version>
       </plugin>
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-dependency-plugin</artifactId>
-        <configuration>
-          <ignoredDependencies>
-            <ignoredDependency>com.github.jnr:jffi</ignoredDependency>
-            <ignoredDependency>org.mockito:mockito-core</ignoredDependency>
-            <ignoredDependency>org.mockito:mockito-inline</ignoredDependency>
-          </ignoredDependencies>
-        </configuration>
+        <version>3.8.1</version>
+        <executions>
+          <execution>
+            <goals>
+              <goal>analyze-only</goal>
+              <goal>properties</goal>
+            </goals>
+            <configuration>
+              <failOnWarning>false</failOnWarning>
+              <ignoredDependencies>
+                <ignoredDependency>com.github.jnr:jffi</ignoredDependency>
+                <ignoredDependency>org.mockito:mockito-core</ignoredDependency>
+                <ignoredDependency>org.mockito:mockito-inline</ignoredDependency>
+              </ignoredDependencies>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-deploy-plugin</artifactId>
+        <version>3.1.3</version>
       </plugin>
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-enforcer-plugin</artifactId>
+        <version>3.5.0</version>
+        <executions>
+          <execution>
+            <id>config-enforcer</id>
+            <goals>
+              <goal>enforce</goal>
+            </goals>
+            <configuration>
+              <rules>
+                <dependencyConvergence/>
+                <requireMavenVersion>
+                  <version>[${maven.enforcer.mvn},)</version>
+                </requireMavenVersion>
+                <requireJavaVersion>
+                  <version>[${maven.enforcer.java},)</version>
+                </requireJavaVersion>
+                <requireNoRepositories/>
+                <requirePluginVersions/>
+                <requireReleaseDeps>
+                  <onlyWhenRelease>true</onlyWhenRelease>
+                </requireReleaseDeps>
+                <requireUpperBoundDeps/>
+              </rules>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-install-plugin</artifactId>
+        <version>3.1.3</version>
       </plugin>
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-jar-plugin</artifactId>
+        <version>3.4.2</version>
         <configuration>
           <archive>
+            <manifest>
+              <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
+            </manifest>
             <manifestEntries>
-              <Automatic-Module-Name>org.lmdbjava</Automatic-Module-Name>
+              <Implementation-Build>${buildNumber}</Implementation-Build>
             </manifestEntries>
           </archive>
         </configuration>
       </plugin>
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-pmd-plugin</artifactId>
+        <artifactId>maven-javadoc-plugin</artifactId>
+        <version>3.11.1</version>
+        <executions>
+          <execution>
+            <id>attach-javadocs</id>
+            <goals>
+              <goal>jar</goal>
+            </goals>
+          </execution>
+        </executions>
       </plugin>
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-surefire-plugin</artifactId>
+        <artifactId>maven-release-plugin</artifactId>
+        <version>3.1.1</version>
         <configuration>
-          <forkCount>1</forkCount>
-          <reuseForks>false</reuseForks>
+          <completionGoals>clean</completionGoals>
+          <preparationGoals>clean</preparationGoals>
+          <useReleaseProfile>false</useReleaseProfile>
+          <autoVersionSubmodules>true</autoVersionSubmodules>
         </configuration>
       </plugin>
       <plugin>
-        <groupId>org.codehaus.mojo</groupId>
-        <artifactId>buildnumber-maven-plugin</artifactId>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-resources-plugin</artifactId>
+        <version>3.3.1</version>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-site-plugin</artifactId>
+        <version>3.21.0</version>
+        <configuration>
+          <skipDeploy>true</skipDeploy>
+        </configuration>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-source-plugin</artifactId>
+        <version>3.3.1</version>
+        <executions>
+          <execution>
+            <id>attach-sources</id>
+            <goals>
+              <goal>jar-no-fork</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-surefire-plugin</artifactId>
+        <version>3.5.2</version>
       </plugin>
       <plugin>
         <groupId>org.codehaus.mojo</groupId>
-        <artifactId>license-maven-plugin</artifactId>
+        <artifactId>buildnumber-maven-plugin</artifactId>
+        <version>3.2.1</version>
+        <configuration>
+          <doCheck>false</doCheck>
+          <doUpdate>false</doUpdate>
+          <revisionOnScmFailure>UNKNOWN</revisionOnScmFailure>
+          <providerImplementations>
+            <git>jgit</git>
+          </providerImplementations>
+          <getRevisionOnlyOnce>true</getRevisionOnlyOnce>
+          <shortRevisionLength>7</shortRevisionLength>
+        </configuration>
+        <dependencies>
+          <dependency>
+            <groupId>org.apache.maven.scm</groupId>
+            <artifactId>maven-scm-provider-jgit</artifactId>
+            <version>2.1.0</version>
+          </dependency>
+        </dependencies>
+        <executions>
+          <execution>
+            <goals>
+              <goal>create</goal>
+            </goals>
+            <phase>initialize</phase>
+          </execution>
+        </executions>
       </plugin>
       <plugin>
         <groupId>org.codehaus.mojo</groupId>
         <artifactId>versions-maven-plugin</artifactId>
+        <version>2.18.0</version>
       </plugin>
       <plugin>
         <groupId>org.jacoco</groupId>
         <artifactId>jacoco-maven-plugin</artifactId>
+        <version>0.8.12</version>
+        <executions>
+          <execution>
+            <id>config-jacoco-prepare-agent</id>
+            <goals>
+              <goal>prepare-agent</goal>
+            </goals>
+          </execution>
+          <execution>
+            <id>config-jacoco-report</id>
+            <goals>
+              <goal>report</goal>
+            </goals>
+          </execution>
+        </executions>
       </plugin>
     </plugins>
   </build>
   <inceptionYear>2016</inceptionYear>
   <organization>
     <name>The LmdbJava Open Source Project</name>
-    <url>https://github.com/${github.org}</url>
+    <url>https://github.com/lmdbjava</url>
   </organization>
   <licenses>
     <license>
@@ -173,19 +368,29 @@
     </developer>
   </developers>
   <scm>
-    <connection>scm:git:git@github.com:${github.org}/${github.repo}.git</connection>
-    <developerConnection>scm:git:git@github.com:${github.org}/${github.repo}.git</developerConnection>
-    <url>git@github.com:${github.org}/${github.repo}.git</url>
+    <connection>scm:git:git@github.com:lmdbjava/lmdbjava.git</connection>
+    <developerConnection>scm:git:git@github.com:lmdbjava/lmdbjava.git</developerConnection>
+    <url>git@github.com:lmdbjava/lmdbjava.git</url>
     <tag>HEAD</tag>
   </scm>
   <issueManagement>
     <system>GitHub Issues</system>
-    <url>https://github.com/${github.org}/${github.repo}/issues</url>
+    <url>https://github.com/lmdbjava/lmdbjava/issues</url>
   </issueManagement>
   <ciManagement>
     <system>GitHub Actions</system>
-    <url>https://github.com/${github.org}/${github.repo}/actions</url>
+    <url>https://github.com/lmdbjava/lmdbjava/actions</url>
   </ciManagement>
+  <distributionManagement>
+    <repository>
+      <id>ossrh</id>
+      <url>https://oss.sonatype.org/service/local/staging/deploy/maven2/</url>
+    </repository>
+    <snapshotRepository>
+      <id>ossrh</id>
+      <url>https://oss.sonatype.org/content/repositories/snapshots</url>
+    </snapshotRepository>
+  </distributionManagement>
   <profiles>
     <profile>
       <id>add-opens-on-java-9-and-above</id>
@@ -198,7 +403,7 @@
             <groupId>org.apache.maven.plugins</groupId>
             <artifactId>maven-surefire-plugin</artifactId>
             <configuration>
-              <argLine>--add-opens java.base/java.nio=ALL-UNNAMED --add-opens java.base/sun.nio.ch=ALL-UNNAMED</argLine>
+              <argLine>@{argLine} --add-opens java.base/java.nio=ALL-UNNAMED --add-opens java.base/sun.nio.ch=ALL-UNNAMED</argLine>
               <forkCount>1</forkCount>
               <reuseForks>false</reuseForks>
             </configuration>
@@ -216,14 +421,78 @@
           <plugin>
             <groupId>com.github.ekryd.sortpom</groupId>
             <artifactId>sortpom-maven-plugin</artifactId>
+            <version>4.0.0</version>
+            <configuration>
+              <pomFile>${project.basedir}/pom.xml</pomFile>
+              <encoding>${project.build.sourceEncoding}</encoding>
+              <predefinedSortOrder>custom_1</predefinedSortOrder>
+              <keepBlankLines>true</keepBlankLines>
+              <sortDependencies>groupId,artifactId</sortDependencies>
+              <sortPlugins>groupId,artifactId</sortPlugins>
+              <sortProperties>true</sortProperties>
+              <sortModules>false</sortModules>
+              <createBackupFile>false</createBackupFile>
+              <lineSeparator>\n</lineSeparator>
+              <expandEmptyElements>false</expandEmptyElements>
+            </configuration>
+            <executions>
+              <execution>
+                <goals>
+                  <goal>sort</goal>
+                </goals>
+                <phase>prepare-package</phase>
+              </execution>
+            </executions>
           </plugin>
+          <plugin>
+            <groupId>com.spotify.fmt</groupId>
+            <artifactId>fmt-maven-plugin</artifactId>
+            <version>2.25</version>
+            <executions>
+              <execution>
+                <goals>
+                  <goal>format</goal>
+                </goals>
+              </execution>
+            </executions>
+          </plugin>
+        </plugins>
+      </build>
+    </profile>
+    <profile>
+      <id>ossrh-deploy</id>
+      <build>
+        <plugins>
           <plugin>
             <groupId>org.apache.maven.plugins</groupId>
-            <artifactId>maven-checkstyle-plugin</artifactId>
+            <artifactId>maven-gpg-plugin</artifactId>
+            <version>3.2.7</version>
+            <executions>
+              <execution>
+                <id>sign-artifacts</id>
+                <goals>
+                  <goal>sign</goal>
+                </goals>
+                <phase>verify</phase>
+                <configuration>
+                  <gpgArguments>
+                    <arg>--pinentry-mode</arg>
+                    <arg>loopback</arg>
+                  </gpgArguments>
+                </configuration>
+              </execution>
+            </executions>
           </plugin>
           <plugin>
-            <groupId>org.basepom.maven</groupId>
-            <artifactId>duplicate-finder-maven-plugin</artifactId>
+            <groupId>org.sonatype.plugins</groupId>
+            <artifactId>nexus-staging-maven-plugin</artifactId>
+            <version>1.7.0</version>
+            <extensions>true</extensions>
+            <configuration>
+              <serverId>ossrh</serverId>
+              <nexusUrl>https://oss.sonatype.org/</nexusUrl>
+              <autoReleaseAfterClose>true</autoReleaseAfterClose>
+            </configuration>
           </plugin>
         </plugins>
       </build>
diff --git a/src/main/java/org/lmdbjava/BufferProxy.java b/src/main/java/org/lmdbjava/BufferProxy.java
index f42da7ff..e66031d2 100644
--- a/src/main/java/org/lmdbjava/BufferProxy.java
+++ b/src/main/java/org/lmdbjava/BufferProxy.java
@@ -1,23 +1,18 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
 import static java.lang.Long.BYTES;
@@ -27,51 +22,59 @@
 import static org.lmdbjava.MaskedFlag.mask;
 
 import java.util.Comparator;
-
 import jnr.ffi.Pointer;
 
 /**
  * The strategy for mapping memory address to a given buffer type.
  *
- * <p>
- * The proxy is passed to the {@link Env#create(org.lmdbjava.BufferProxy)}
- * method and is subsequently used by every {@link Txn}, {@link Dbi} and
- * {@link Cursor} associated with the {@link Env}.
+ * <p>The proxy is passed to the {@link Env#create(org.lmdbjava.BufferProxy)} method and is
+ * subsequently used by every {@link Txn}, {@link Dbi} and {@link Cursor} associated with the {@link
+ * Env}.
  *
  * @param <T> buffer type
  */
-@SuppressWarnings("checkstyle:AbstractClassName")
 public abstract class BufferProxy<T> {
 
-  /**
-   * Size of a <code>MDB_val</code> pointer in bytes.
-   */
+  /** Size of a <code>MDB_val</code> pointer in bytes. */
   protected static final int MDB_VAL_STRUCT_SIZE = BYTES * 2;
 
-  /**
-   * Offset from a pointer of the <code>MDB_val.mv_data</code> field.
-   */
+  /** Offset from a pointer of the <code>MDB_val.mv_data</code> field. */
   protected static final int STRUCT_FIELD_OFFSET_DATA = BYTES;
 
-  /**
-   * Offset from a pointer of the <code>MDB_val.mv_size</code> field.
-   */
+  /** Offset from a pointer of the <code>MDB_val.mv_size</code> field. */
   protected static final int STRUCT_FIELD_OFFSET_SIZE = 0;
 
+  /** Explicitly-defined default constructor to avoid warnings. */
+  protected BufferProxy() {}
+
   /**
-   * Allocate a new buffer suitable for passing to
-   * {@link #out(java.lang.Object, jnr.ffi.Pointer, long)}.
+   * Allocate a new buffer suitable for passing to {@link #out(java.lang.Object, jnr.ffi.Pointer,
+   * long)}.
    *
    * @return a buffer for passing to the <code>out</code> method
    */
   protected abstract T allocate();
 
+  /**
+   * Deallocate a buffer that was previously provided by {@link #allocate()}.
+   *
+   * @param buff the buffer to deallocate (required)
+   */
+  protected abstract void deallocate(T buff);
+
+  /**
+   * Obtain a copy of the bytes contained within the passed buffer.
+   *
+   * @param buffer a non-null buffer created by this proxy instance
+   * @return a copy of the bytes this buffer is currently representing
+   */
+  protected abstract byte[] getBytes(T buffer);
+
   /**
    * Get a suitable default {@link Comparator} given the provided flags.
    *
-   * <p>
-   * The provided comparator must strictly match the lexicographical order of
-   * keys in the native LMDB database.
+   * <p>The provided comparator must strictly match the lexicographical order of keys in the native
+   * LMDB database.
    *
    * @param flags for the database
    * @return a comparator that can be used (never null)
@@ -79,64 +82,51 @@ public abstract class BufferProxy<T> {
   protected Comparator<T> getComparator(DbiFlags... flags) {
     final int intFlag = mask(flags);
 
-    return isSet(intFlag, MDB_INTEGERKEY) || isSet(intFlag, MDB_UNSIGNEDKEY) ? getUnsignedComparator() : getSignedComparator();
+    return isSet(intFlag, MDB_INTEGERKEY) || isSet(intFlag, MDB_UNSIGNEDKEY)
+        ? getUnsignedComparator()
+        : getSignedComparator();
   }
 
-  /**
-   * Get a suitable default {@link Comparator} to compare numeric key values as unsigned.
-   *
-   * @return a comparator that can be used (never null)
-   */
-  protected abstract Comparator<T> getUnsignedComparator();
   /**
    * Get a suitable default {@link Comparator} to compare numeric key values as signed.
    *
    * @return a comparator that can be used (never null)
    */
   protected abstract Comparator<T> getSignedComparator();
-  /**
-   * Deallocate a buffer that was previously provided by {@link #allocate()}.
-   *
-   * @param buff the buffer to deallocate (required)
-   */
-  protected abstract void deallocate(T buff);
 
   /**
-   * Obtain a copy of the bytes contained within the passed buffer.
+   * Get a suitable default {@link Comparator} to compare numeric key values as unsigned.
    *
-   * @param buffer a non-null buffer created by this proxy instance
-   * @return a copy of the bytes this buffer is currently representing
+   * @return a comparator that can be used (never null)
    */
-  protected abstract byte[] getBytes(T buffer);
+  protected abstract Comparator<T> getUnsignedComparator();
 
   /**
-   * Called when the <code>MDB_val</code> should be set to reflect the passed
-   * buffer. This buffer will have been created by end users, not
-   * {@link #allocate()}.
+   * Called when the <code>MDB_val</code> should be set to reflect the passed buffer. This buffer
+   * will have been created by end users, not {@link #allocate()}.
    *
-   * @param buffer  the buffer to write to <code>MDB_val</code>
-   * @param ptr     the pointer to the <code>MDB_val</code>
+   * @param buffer the buffer to write to <code>MDB_val</code>
+   * @param ptr the pointer to the <code>MDB_val</code>
    * @param ptrAddr the address of the <code>MDB_val</code> pointer
    */
   protected abstract void in(T buffer, Pointer ptr, long ptrAddr);
 
   /**
-   * Called when the <code>MDB_val</code> should be set to reflect the passed
-   * buffer.
+   * Called when the <code>MDB_val</code> should be set to reflect the passed buffer.
    *
-   * @param buffer  the buffer to write to <code>MDB_val</code>
-   * @param size    the buffer size to write to <code>MDB_val</code>
-   * @param ptr     the pointer to the <code>MDB_val</code>
+   * @param buffer the buffer to write to <code>MDB_val</code>
+   * @param size the buffer size to write to <code>MDB_val</code>
+   * @param ptr the pointer to the <code>MDB_val</code>
    * @param ptrAddr the address of the <code>MDB_val</code> pointer
    */
   protected abstract void in(T buffer, int size, Pointer ptr, long ptrAddr);
 
   /**
-   * Called when the <code>MDB_val</code> may have changed and the passed buffer
-   * should be modified to reflect the new <code>MDB_val</code>.
+   * Called when the <code>MDB_val</code> may have changed and the passed buffer should be modified
+   * to reflect the new <code>MDB_val</code>.
    *
-   * @param buffer  the buffer to write to <code>MDB_val</code>
-   * @param ptr     the pointer to the <code>MDB_val</code>
+   * @param buffer the buffer to write to <code>MDB_val</code>
+   * @param ptr the pointer to the <code>MDB_val</code>
    * @param ptrAddr the address of the <code>MDB_val</code> pointer
    * @return the buffer for <code>MDB_val</code>
    */
@@ -150,5 +140,4 @@ protected Comparator<T> getComparator(DbiFlags... flags) {
   final KeyVal<T> keyVal() {
     return new KeyVal<>(this);
   }
-
 }
diff --git a/src/main/java/org/lmdbjava/ByteArrayProxy.java b/src/main/java/org/lmdbjava/ByteArrayProxy.java
index 2066b679..4a22ab83 100644
--- a/src/main/java/org/lmdbjava/ByteArrayProxy.java
+++ b/src/main/java/org/lmdbjava/ByteArrayProxy.java
@@ -1,45 +1,37 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
-import jnr.ffi.Pointer;
-import jnr.ffi.provider.MemoryManager;
-
-import java.util.Arrays;
-import java.util.Comparator;
-
 import static java.lang.Math.min;
 import static java.util.Objects.requireNonNull;
 import static org.lmdbjava.Library.RUNTIME;
 
+import java.util.Arrays;
+import java.util.Comparator;
+import jnr.ffi.Pointer;
+import jnr.ffi.provider.MemoryManager;
+
 /**
  * Byte array proxy.
  *
- * {@link Env#create(org.lmdbjava.BufferProxy)}.
+ * <p>{@link Env#create(org.lmdbjava.BufferProxy)}.
  */
 public final class ByteArrayProxy extends BufferProxy<byte[]> {
 
-  /**
-   * The byte array proxy. Guaranteed to never be null.
-   */
+  /** The byte array proxy. Guaranteed to never be null. */
   public static final BufferProxy<byte[]> PROXY_BA = new ByteArrayProxy();
 
   private static final MemoryManager MEM_MGR = RUNTIME.getMemoryManager();
@@ -47,8 +39,7 @@ public final class ByteArrayProxy extends BufferProxy<byte[]> {
   private static final Comparator<byte[]> signedComparator = ByteArrayProxy::compareArraysSigned;
   private static final Comparator<byte[]> unsignedComparator = ByteArrayProxy::compareArrays;
 
-    private ByteArrayProxy() {
-  }
+  private ByteArrayProxy() {}
 
   /**
    * Lexicographically compare two byte arrays.
@@ -57,7 +48,6 @@ private ByteArrayProxy() {
    * @param o2 right operand (required)
    * @return as specified by {@link Comparable} interface
    */
-  @SuppressWarnings("PMD.CompareObjectsWithEquals")
   public static int compareArrays(final byte[] o1, final byte[] o2) {
     requireNonNull(o1);
     requireNonNull(o2);
@@ -85,15 +75,14 @@ public static int compareArrays(final byte[] o1, final byte[] o2) {
    * @param b2 right operand (required)
    * @return as specified by {@link Comparable} interface
    */
-  @SuppressWarnings("PMD.CompareObjectsWithEquals")
   public static int compareArraysSigned(final byte[] b1, final byte[] b2) {
     requireNonNull(b1);
     requireNonNull(b2);
 
     if (b1 == b2) return 0;
 
-    for(int i = 0; i < min(b1.length, b2.length); ++i) {
-      if(b1[i] != b2[i]) return b1[i] - b2[i];
+    for (int i = 0; i < min(b1.length, b2.length); ++i) {
+      if (b1[i] != b2[i]) return b1[i] - b2[i];
     }
 
     return b1.length - b2.length;
@@ -125,8 +114,7 @@ protected Comparator<byte[]> getUnsignedComparator() {
   }
 
   @Override
-  protected void in(final byte[] buffer, final Pointer ptr,
-                    final long ptrAddr) {
+  protected void in(final byte[] buffer, final Pointer ptr, final long ptrAddr) {
     final Pointer pointer = MEM_MGR.allocateDirect(buffer.length);
     pointer.put(0, buffer, 0, buffer.length);
     ptr.putLong(STRUCT_FIELD_OFFSET_SIZE, buffer.length);
@@ -134,14 +122,12 @@ protected void in(final byte[] buffer, final Pointer ptr,
   }
 
   @Override
-  protected void in(final byte[] buffer, final int size, final Pointer ptr,
-                    final long ptrAddr) {
+  protected void in(final byte[] buffer, final int size, final Pointer ptr, final long ptrAddr) {
     // cannot reserve for byte arrays
   }
 
   @Override
-  protected byte[] out(final byte[] buffer, final Pointer ptr,
-                       final long ptrAddr) {
+  protected byte[] out(final byte[] buffer, final Pointer ptr, final long ptrAddr) {
     final long addr = ptr.getAddress(STRUCT_FIELD_OFFSET_DATA);
     final int size = (int) ptr.getLong(STRUCT_FIELD_OFFSET_SIZE);
     final Pointer pointer = MEM_MGR.newPointer(addr, size);
diff --git a/src/main/java/org/lmdbjava/ByteBufProxy.java b/src/main/java/org/lmdbjava/ByteBufProxy.java
index ed3d71e1..cac5b97b 100644
--- a/src/main/java/org/lmdbjava/ByteBufProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufProxy.java
@@ -1,50 +1,42 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
-import io.netty.buffer.ByteBuf;
-import io.netty.buffer.PooledByteBufAllocator;
-import jnr.ffi.Pointer;
-
-import java.lang.reflect.Field;
-import java.util.Comparator;
-
 import static io.netty.buffer.PooledByteBufAllocator.DEFAULT;
 import static java.lang.Class.forName;
 import static java.util.Objects.requireNonNull;
 import static org.lmdbjava.UnsafeAccess.UNSAFE;
 
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.PooledByteBufAllocator;
+import java.lang.reflect.Field;
+import java.util.Comparator;
+import jnr.ffi.Pointer;
+
 /**
  * A buffer proxy backed by Netty's {@link ByteBuf}.
  *
- * <p>
- * This class requires {@link UnsafeAccess} and netty-buffer must be in the
- * classpath.
+ * <p>This class requires {@link UnsafeAccess} and netty-buffer must be in the classpath.
  */
 public final class ByteBufProxy extends BufferProxy<ByteBuf> {
 
   /**
-   * A proxy for using Netty {@link ByteBuf}. Guaranteed to never be null,
-   * although a class initialization exception will occur if an attempt is made
-   * to access this field when Netty is unavailable.
+   * A proxy for using Netty {@link ByteBuf}. Guaranteed to never be null, although a class
+   * initialization exception will occur if an attempt is made to access this field when Netty is
+   * unavailable.
    */
   public static final BufferProxy<ByteBuf> PROXY_NETTY = new ByteBufProxy();
 
@@ -52,22 +44,29 @@ public final class ByteBufProxy extends BufferProxy<ByteBuf> {
   private static final String FIELD_NAME_ADDRESS = "memoryAddress";
   private static final String FIELD_NAME_LENGTH = "length";
   private static final String NAME = "io.netty.buffer.PooledUnsafeDirectByteBuf";
-  private static final Comparator<ByteBuf> comparator = (o1, o2) -> {
-    requireNonNull(o1);
-    requireNonNull(o2);
+  private static final Comparator<ByteBuf> comparator =
+      (o1, o2) -> {
+        requireNonNull(o1);
+        requireNonNull(o2);
 
-    return o1.compareTo(o2);
-  };
+        return o1.compareTo(o2);
+      };
   private final long lengthOffset;
   private final long addressOffset;
-  
+
   private final PooledByteBufAllocator nettyAllocator;
 
   private ByteBufProxy() {
     this(DEFAULT);
   }
 
+  /**
+   * Constructs a buffer proxy for use with Netty.
+   *
+   * @param allocator the Netty allocator to obtain the {@link ByteBuf} from
+   */
   public ByteBufProxy(final PooledByteBufAllocator allocator) {
+    super();
     this.nettyAllocator = allocator;
 
     try {
@@ -138,24 +137,20 @@ protected byte[] getBytes(final ByteBuf buffer) {
 
   @Override
   protected void in(final ByteBuf buffer, final Pointer ptr, final long ptrAddr) {
-    UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_SIZE,
-                   buffer.writerIndex() - buffer.readerIndex());
-    UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_DATA,
-                   buffer.memoryAddress() + buffer.readerIndex());
+    UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_SIZE, buffer.writerIndex() - buffer.readerIndex());
+    UNSAFE.putLong(
+        ptrAddr + STRUCT_FIELD_OFFSET_DATA, buffer.memoryAddress() + buffer.readerIndex());
   }
 
   @Override
-  protected void in(final ByteBuf buffer, final int size, final Pointer ptr,
-                    final long ptrAddr) {
-    UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_SIZE,
-                   size);
-    UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_DATA,
-                   buffer.memoryAddress() + buffer.readerIndex());
+  protected void in(final ByteBuf buffer, final int size, final Pointer ptr, final long ptrAddr) {
+    UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_SIZE, size);
+    UNSAFE.putLong(
+        ptrAddr + STRUCT_FIELD_OFFSET_DATA, buffer.memoryAddress() + buffer.readerIndex());
   }
 
   @Override
-  protected ByteBuf out(final ByteBuf buffer, final Pointer ptr,
-                        final long ptrAddr) {
+  protected ByteBuf out(final ByteBuf buffer, final Pointer ptr, final long ptrAddr) {
     final long addr = UNSAFE.getLong(ptrAddr + STRUCT_FIELD_OFFSET_DATA);
     final long size = UNSAFE.getLong(ptrAddr + STRUCT_FIELD_OFFSET_SIZE);
     UNSAFE.putLong(buffer, addressOffset, addr);
diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
index 9983d76e..2b7cdf0d 100644
--- a/src/main/java/org/lmdbjava/ByteBufferProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -1,23 +1,18 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
 import static java.lang.Long.reverseBytes;
@@ -26,11 +21,7 @@
 import static java.nio.ByteOrder.BIG_ENDIAN;
 import static java.nio.ByteOrder.LITTLE_ENDIAN;
 import static java.util.Objects.requireNonNull;
-import static org.lmdbjava.DbiFlags.MDB_INTEGERKEY;
-import static org.lmdbjava.DbiFlags.MDB_UNSIGNEDKEY;
 import static org.lmdbjava.Env.SHOULD_CHECK;
-import static org.lmdbjava.MaskedFlag.isSet;
-import static org.lmdbjava.MaskedFlag.mask;
 import static org.lmdbjava.UnsafeAccess.UNSAFE;
 
 import java.lang.reflect.Field;
@@ -38,38 +29,32 @@
 import java.nio.ByteBuffer;
 import java.util.ArrayDeque;
 import java.util.Comparator;
-
 import jnr.ffi.Pointer;
 
 /**
  * {@link ByteBuffer}-based proxy.
  *
- * <p>
- * There are two concrete {@link ByteBuffer} proxy implementations available:
+ * <p>There are two concrete {@link ByteBuffer} proxy implementations available:
+ *
  * <ul>
- * <li>A "fast" implementation: {@link UnsafeProxy}</li>
- * <li>A "safe" implementation: {@link ReflectiveProxy}</li>
+ *   <li>A "fast" implementation: {@link UnsafeProxy}
+ *   <li>A "safe" implementation: {@link ReflectiveProxy}
  * </ul>
  *
- * <p>
- * Users nominate which implementation they prefer by referencing the
- * {@link #PROXY_OPTIMAL} or {@link #PROXY_SAFE} field when invoking
- * {@link Env#create(org.lmdbjava.BufferProxy)}.
+ * <p>Users nominate which implementation they prefer by referencing the {@link #PROXY_OPTIMAL} or
+ * {@link #PROXY_SAFE} field when invoking {@link Env#create(org.lmdbjava.BufferProxy)}.
  */
 public final class ByteBufferProxy {
 
   /**
-   * The fastest {@link ByteBuffer} proxy that is available on this platform.
-   * This will always be the same instance as {@link #PROXY_SAFE} if the
-   * {@link UnsafeAccess#DISABLE_UNSAFE_PROP} has been set to <code>true</code>
-   * and/or {@link UnsafeAccess} is unavailable. Guaranteed to never be null.
+   * The fastest {@link ByteBuffer} proxy that is available on this platform. This will always be
+   * the same instance as {@link #PROXY_SAFE} if the {@link UnsafeAccess#DISABLE_UNSAFE_PROP} has
+   * been set to <code>true</code> and/or {@link UnsafeAccess} is unavailable. Guaranteed to never
+   * be null.
    */
   public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
 
-  /**
-   * The safe, reflective {@link ByteBuffer} proxy for this system. Guaranteed
-   * to never be null.
-   */
+  /** The safe, reflective {@link ByteBuffer} proxy for this system. Guaranteed to never be null. */
   public static final BufferProxy<ByteBuffer> PROXY_SAFE;
 
   static {
@@ -77,8 +62,7 @@ public final class ByteBufferProxy {
     PROXY_OPTIMAL = getProxyOptimal();
   }
 
-  private ByteBufferProxy() {
-  }
+  private ByteBufferProxy() {}
 
   private static BufferProxy<ByteBuffer> getProxyOptimal() {
     try {
@@ -88,45 +72,42 @@ private static BufferProxy<ByteBuffer> getProxyOptimal() {
     }
   }
 
-  /**
-   * The buffer must be a direct buffer (not heap allocated).
-   */
+  /** The buffer must be a direct buffer (not heap allocated). */
   public static final class BufferMustBeDirectException extends LmdbException {
 
     private static final long serialVersionUID = 1L;
 
-    /**
-     * Creates a new instance.
-     */
+    /** Creates a new instance. */
     public BufferMustBeDirectException() {
       super("The buffer must be a direct buffer (not heap allocated");
     }
   }
 
   /**
-   * Provides {@link ByteBuffer} pooling and address resolution for concrete
-   * {@link BufferProxy} implementations.
+   * Provides {@link ByteBuffer} pooling and address resolution for concrete {@link BufferProxy}
+   * implementations.
    */
   abstract static class AbstractByteBufferProxy extends BufferProxy<ByteBuffer> {
 
     protected static final String FIELD_NAME_ADDRESS = "address";
     protected static final String FIELD_NAME_CAPACITY = "capacity";
 
-    private static final Comparator<ByteBuffer> signedComparator = (o1, o2) -> {
-      requireNonNull(o1);
-      requireNonNull(o2);
+    private static final Comparator<ByteBuffer> signedComparator =
+        (o1, o2) -> {
+          requireNonNull(o1);
+          requireNonNull(o2);
 
-      return o1.compareTo(o2);
-    };
-    private static final Comparator<ByteBuffer> unsignedComparator = AbstractByteBufferProxy::compareBuff;
+          return o1.compareTo(o2);
+        };
+    private static final Comparator<ByteBuffer> unsignedComparator =
+        AbstractByteBufferProxy::compareBuff;
 
     /**
-     * A thread-safe pool for a given length. If the buffer found is valid (ie
-     * not of a negative length) then that buffer is used. If no valid buffer is
-     * found, a new buffer is created.
+     * A thread-safe pool for a given length. If the buffer found is valid (ie not of a negative
+     * length) then that buffer is used. If no valid buffer is found, a new buffer is created.
      */
-    private static final ThreadLocal<ArrayDeque<ByteBuffer>> BUFFERS
-        = withInitial(() -> new ArrayDeque<>(16));
+    private static final ThreadLocal<ArrayDeque<ByteBuffer>> BUFFERS =
+        withInitial(() -> new ArrayDeque<>(16));
 
     /**
      * Lexicographically compare two buffers.
@@ -135,7 +116,6 @@ abstract static class AbstractByteBufferProxy extends BufferProxy<ByteBuffer> {
      * @param o2 right operand (required)
      * @return as specified by {@link Comparable} interface
      */
-    @SuppressWarnings("PMD.CyclomaticComplexity")
     public static int compareBuff(final ByteBuffer o1, final ByteBuffer o2) {
       requireNonNull(o1);
       requireNonNull(o2);
@@ -224,12 +204,11 @@ protected byte[] getBytes(final ByteBuffer buffer) {
       buffer.get(dest, 0, buffer.limit());
       return dest;
     }
-
   }
 
   /**
-   * A proxy that uses Java reflection to modify byte buffer fields, and
-   * official JNR-FFF methods to manipulate native pointers.
+   * A proxy that uses Java reflection to modify byte buffer fields, and official JNR-FFF methods to
+   * manipulate native pointers.
    */
   private static final class ReflectiveProxy extends AbstractByteBufferProxy {
 
@@ -242,22 +221,20 @@ private static final class ReflectiveProxy extends AbstractByteBufferProxy {
     }
 
     @Override
-    protected void in(final ByteBuffer buffer, final Pointer ptr,
-                      final long ptrAddr) {
+    protected void in(final ByteBuffer buffer, final Pointer ptr, final long ptrAddr) {
       ptr.putAddress(STRUCT_FIELD_OFFSET_DATA, address(buffer));
       ptr.putLong(STRUCT_FIELD_OFFSET_SIZE, buffer.remaining());
     }
 
     @Override
-    protected void in(final ByteBuffer buffer, final int size, final Pointer ptr,
-                      final long ptrAddr) {
+    protected void in(
+        final ByteBuffer buffer, final int size, final Pointer ptr, final long ptrAddr) {
       ptr.putLong(STRUCT_FIELD_OFFSET_SIZE, size);
       ptr.putAddress(STRUCT_FIELD_OFFSET_DATA, address(buffer));
     }
 
     @Override
-    protected ByteBuffer out(final ByteBuffer buffer, final Pointer ptr,
-                             final long ptrAddr) {
+    protected ByteBuffer out(final ByteBuffer buffer, final Pointer ptr, final long ptrAddr) {
       final long addr = ptr.getAddress(STRUCT_FIELD_OFFSET_DATA);
       final long size = ptr.getLong(STRUCT_FIELD_OFFSET_SIZE);
       try {
@@ -269,12 +246,11 @@ protected ByteBuffer out(final ByteBuffer buffer, final Pointer ptr,
       buffer.clear();
       return buffer;
     }
-
   }
 
   /**
-   * A proxy that uses Java's "unsafe" class to directly manipulate byte buffer
-   * fields and JNR-FFF allocated memory pointers.
+   * A proxy that uses Java's "unsafe" class to directly manipulate byte buffer fields and JNR-FFF
+   * allocated memory pointers.
    */
   private static final class UnsafeProxy extends AbstractByteBufferProxy {
 
@@ -293,22 +269,20 @@ private static final class UnsafeProxy extends AbstractByteBufferProxy {
     }
 
     @Override
-    protected void in(final ByteBuffer buffer, final Pointer ptr,
-                      final long ptrAddr) {
+    protected void in(final ByteBuffer buffer, final Pointer ptr, final long ptrAddr) {
       UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_SIZE, buffer.remaining());
       UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_DATA, address(buffer));
     }
 
     @Override
-    protected void in(final ByteBuffer buffer, final int size, final Pointer ptr,
-                      final long ptrAddr) {
+    protected void in(
+        final ByteBuffer buffer, final int size, final Pointer ptr, final long ptrAddr) {
       UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_SIZE, size);
       UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_DATA, address(buffer));
     }
 
     @Override
-    protected ByteBuffer out(final ByteBuffer buffer, final Pointer ptr,
-                             final long ptrAddr) {
+    protected ByteBuffer out(final ByteBuffer buffer, final Pointer ptr, final long ptrAddr) {
       final long addr = UNSAFE.getLong(ptrAddr + STRUCT_FIELD_OFFSET_DATA);
       final long size = UNSAFE.getLong(ptrAddr + STRUCT_FIELD_OFFSET_SIZE);
       UNSAFE.putLong(buffer, ADDRESS_OFFSET, addr);
@@ -317,5 +291,4 @@ protected ByteBuffer out(final ByteBuffer buffer, final Pointer ptr,
       return buffer;
     }
   }
-
 }
diff --git a/src/main/java/org/lmdbjava/CopyFlags.java b/src/main/java/org/lmdbjava/CopyFlags.java
index 88649a04..4365563c 100644
--- a/src/main/java/org/lmdbjava/CopyFlags.java
+++ b/src/main/java/org/lmdbjava/CopyFlags.java
@@ -1,35 +1,24 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
-/**
- * Flags for use when performing a
- * {@link Env#copy(java.io.File, org.lmdbjava.CopyFlags...)}.
- */
+/** Flags for use when performing a {@link Env#copy(java.io.File, org.lmdbjava.CopyFlags...)}. */
 public enum CopyFlags implements MaskedFlag {
 
-  /**
-   * Compacting copy: Omit free space from copy, and renumber all pages
-   * sequentially.
-   */
+  /** Compacting copy: Omit free space from copy, and renumber all pages sequentially. */
   MDB_CP_COMPACT(0x01);
 
   private final int mask;
@@ -42,5 +31,4 @@ public enum CopyFlags implements MaskedFlag {
   public int getMask() {
     return mask;
   }
-
 }
diff --git a/src/main/java/org/lmdbjava/Cursor.java b/src/main/java/org/lmdbjava/Cursor.java
index cb9130e3..d49a9bed 100644
--- a/src/main/java/org/lmdbjava/Cursor.java
+++ b/src/main/java/org/lmdbjava/Cursor.java
@@ -1,23 +1,18 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
 import static java.util.Objects.requireNonNull;
@@ -40,8 +35,6 @@
 import jnr.ffi.Pointer;
 import jnr.ffi.byref.NativeLongByReference;
 
-import java.util.Arrays;
-
 /**
  * A cursor handle.
  *
@@ -67,9 +60,8 @@ public final class Cursor<T> implements AutoCloseable {
   /**
    * Close a cursor handle.
    *
-   * <p>
-   * The cursor handle will be freed and must not be used again after this call.
-   * Its transaction must still be live if it is a write-transaction.
+   * <p>The cursor handle will be freed and must not be used again after this call. Its transaction
+   * must still be live if it is a write-transaction.
    */
   @Override
   public void close() {
@@ -90,9 +82,8 @@ public void close() {
   /**
    * Return count of duplicates for current key.
    *
-   * <p>
-   * This call is only valid on databases that support sorted duplicate data
-   * items {@link DbiFlags#MDB_DUPSORT}.
+   * <p>This call is only valid on databases that support sorted duplicate data items {@link
+   * DbiFlags#MDB_DUPSORT}.
    *
    * @return count of duplicates for current key
    */
@@ -110,8 +101,7 @@ public long count() {
   /**
    * Delete current key/data pair.
    *
-   * <p>
-   * This function deletes the key/data pair to which the cursor refers.
+   * <p>This function deletes the key/data pair to which the cursor refers.
    *
    * @param f flags (either null or {@link PutFlags#MDB_NODUPDATA}
    */
@@ -138,9 +128,9 @@ public boolean first() {
   /**
    * Reposition the key/value buffers based on the passed key and operation.
    *
-   * @param key  to search for
+   * @param key to search for
    * @param data to search for
-   * @param op   options for this operation
+   * @param op options for this operation
    * @return false if key not found
    */
   public boolean get(final T key, final T data, final SeekOp op) {
@@ -154,8 +144,7 @@ public boolean get(final T key, final T data, final SeekOp op) {
     kv.keyIn(key);
     kv.valIn(data);
 
-    final int rc = LIB.mdb_cursor_get(ptrCursor, kv.pointerKey(), kv
-                                      .pointerVal(), op.getCode());
+    final int rc = LIB.mdb_cursor_get(ptrCursor, kv.pointerKey(), kv.pointerVal(), op.getCode());
 
     if (rc == MDB_NOTFOUND) {
       return false;
@@ -172,7 +161,7 @@ public boolean get(final T key, final T data, final SeekOp op) {
    * Reposition the key/value buffers based on the passed key and operation.
    *
    * @param key to search for
-   * @param op  options for this operation
+   * @param op options for this operation
    * @return false if key not found
    */
   public boolean get(final T key, final GetOp op) {
@@ -185,8 +174,7 @@ public boolean get(final T key, final GetOp op) {
     }
     kv.keyIn(key);
 
-    final int rc = LIB.mdb_cursor_get(ptrCursor, kv.pointerKey(), kv
-                                      .pointerVal(), op.getCode());
+    final int rc = LIB.mdb_cursor_get(ptrCursor, kv.pointerKey(), kv.pointerVal(), op.getCode());
 
     if (rc == MDB_NOTFOUND) {
       return false;
@@ -238,14 +226,13 @@ public boolean prev() {
   /**
    * Store by cursor.
    *
-   * <p>
-   * This function stores key/data pairs into the database.
+   * <p>This function stores key/data pairs into the database.
    *
    * @param key key to store
    * @param val data to store
-   * @param op  options for this operation
-   * @return true if the value was put, false if MDB_NOOVERWRITE or
-   *         MDB_NODUPDATA were set and the key/value existed already.
+   * @param op options for this operation
+   * @return true if the value was put, false if MDB_NOOVERWRITE or MDB_NODUPDATA were set and the
+   *     key/value existed already.
    */
   public boolean put(final T key, final T val, final PutFlags... op) {
     if (SHOULD_CHECK) {
@@ -259,8 +246,7 @@ public boolean put(final T key, final T val, final PutFlags... op) {
     kv.keyIn(key);
     kv.valIn(val);
     final int mask = mask(true, op);
-    final int rc = LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(),
-                                      kv.pointerVal(), mask);
+    final int rc = LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(), mask);
     if (rc == MDB_KEYEXIST) {
       if (isSet(mask, MDB_NOOVERWRITE)) {
         kv.valOut(); // marked as in,out in LMDB C docs
@@ -276,23 +262,19 @@ public boolean put(final T key, final T val, final PutFlags... op) {
   }
 
   /**
-   * Put multiple values into the database in one <code>MDB_MULTIPLE</code>
-   * operation.
+   * Put multiple values into the database in one <code>MDB_MULTIPLE</code> operation.
    *
-   * <p>
-   * The database must have been opened with {@link DbiFlags#MDB_DUPFIXED}. The
-   * buffer must contain fixed-sized values to be inserted. The size of each
-   * element is calculated from the buffer's size divided by the given element
-   * count. For example, to populate 10 X 4 byte integers at once, present a
-   * buffer of 40 bytes and specify the element as 10.
+   * <p>The database must have been opened with {@link DbiFlags#MDB_DUPFIXED}. The buffer must
+   * contain fixed-sized values to be inserted. The size of each element is calculated from the
+   * buffer's size divided by the given element count. For example, to populate 10 X 4 byte integers
+   * at once, present a buffer of 40 bytes and specify the element as 10.
    *
-   * @param key      key to store in the database (not null)
-   * @param val      value to store in the database (not null)
+   * @param key key to store in the database (not null)
+   * @param val value to store in the database (not null)
    * @param elements number of elements contained in the passed value buffer
-   * @param op       options for operation (must set <code>MDB_MULTIPLE</code>)
+   * @param op options for operation (must set <code>MDB_MULTIPLE</code>)
    */
-  public void putMultiple(final T key, final T val, final int elements,
-                          final PutFlags... op) {
+  public void putMultiple(final T key, final T val, final int elements, final PutFlags... op) {
     if (SHOULD_CHECK) {
       requireNonNull(txn);
       requireNonNull(key);
@@ -307,8 +289,7 @@ public void putMultiple(final T key, final T val, final int elements,
     }
     txn.kv().keyIn(key);
     final Pointer dataPtr = txn.kv().valInMulti(val, elements);
-    final int rc = LIB.mdb_cursor_put(ptrCursor, txn.kv().pointerKey(),
-                                      dataPtr, mask);
+    final int rc = LIB.mdb_cursor_put(ptrCursor, txn.kv().pointerKey(), dataPtr, mask);
     checkRc(rc);
     ReferenceUtil.reachabilityFence0(key);
     ReferenceUtil.reachabilityFence0(val);
@@ -317,13 +298,10 @@ public void putMultiple(final T key, final T val, final int elements,
   /**
    * Renew a cursor handle.
    *
-   * <p>
-   * A cursor is associated with a specific transaction and database. Cursors
-   * that are only used in read-only transactions may be re-used, to avoid
-   * unnecessary malloc/free overhead. The cursor may be associated with a new
-   * read-only transaction, and referencing the same database handle as it was
-   * created with. This may be done whether the previous transaction is live or
-   * dead.
+   * <p>A cursor is associated with a specific transaction and database. Cursors that are only used
+   * in read-only transactions may be re-used, to avoid unnecessary malloc/free overhead. The cursor
+   * may be associated with a new read-only transaction, and referencing the same database handle as
+   * it was created with. This may be done whether the previous transaction is live or dead.
    *
    * @param newTxn transaction handle
    */
@@ -341,19 +319,17 @@ public void renew(final Txn<T> newTxn) {
   }
 
   /**
-   * Reserve space for data of the given size, but don't copy the given val.
-   * Instead, return a pointer to the reserved space, which the caller can fill
-   * in later - before the next update operation or the transaction ends. This
-   * saves an extra memcpy if the data is being generated later. LMDB does
-   * nothing else with this memory, the caller is expected to modify all of the
+   * Reserve space for data of the given size, but don't copy the given val. Instead, return a
+   * pointer to the reserved space, which the caller can fill in later - before the next update
+   * operation or the transaction ends. This saves an extra memcpy if the data is being generated
+   * later. LMDB does nothing else with this memory, the caller is expected to modify all of the
    * space requested.
    *
-   * <p>
-   * This flag must not be specified if the database was opened with MDB_DUPSORT
+   * <p>This flag must not be specified if the database was opened with MDB_DUPSORT
    *
-   * @param key  key to store in the database (not null)
+   * @param key key to store in the database (not null)
    * @param size size of the value to be stored in the database (not null)
-   * @param op   options for this operation
+   * @param op options for this operation
    * @return a buffer that can be used to modify the value
    */
   public T reserve(final T key, final int size, final PutFlags... op) {
@@ -367,8 +343,7 @@ public T reserve(final T key, final int size, final PutFlags... op) {
     kv.keyIn(key);
     kv.valIn(size);
     final int flags = mask(true, op) | MDB_RESERVE.getMask();
-    checkRc(LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(),
-                               flags));
+    checkRc(LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(), flags));
     kv.valOut();
     ReferenceUtil.reachabilityFence0(key);
     return val();
@@ -388,8 +363,7 @@ public boolean seek(final SeekOp op) {
       txn.checkReady();
     }
 
-    final int rc = LIB.mdb_cursor_get(ptrCursor, kv.pointerKey(), kv
-                                      .pointerVal(), op.getCode());
+    final int rc = LIB.mdb_cursor_get(ptrCursor, kv.pointerKey(), kv.pointerVal(), op.getCode());
 
     if (rc == MDB_NOTFOUND) {
       return false;
@@ -416,24 +390,18 @@ private void checkNotClosed() {
     }
   }
 
-  /**
-   * Cursor has already been closed.
-   */
+  /** Cursor has already been closed. */
   public static final class ClosedException extends LmdbException {
 
     private static final long serialVersionUID = 1L;
 
-    /**
-     * Creates a new instance.
-     */
+    /** Creates a new instance. */
     public ClosedException() {
       super("Cursor has already been closed");
     }
   }
 
-  /**
-   * Cursor stack too deep - internal error.
-   */
+  /** Cursor stack too deep - internal error. */
   public static final class FullException extends LmdbNativeException {
 
     static final int MDB_CURSOR_FULL = -30_787;
@@ -443,5 +411,4 @@ public static final class FullException extends LmdbNativeException {
       super(MDB_CURSOR_FULL, "Cursor stack too deep - internal error");
     }
   }
-
 }
diff --git a/src/main/java/org/lmdbjava/CursorIterable.java b/src/main/java/org/lmdbjava/CursorIterable.java
index 39a6d58c..6a03bd90 100644
--- a/src/main/java/org/lmdbjava/CursorIterable.java
+++ b/src/main/java/org/lmdbjava/CursorIterable.java
@@ -1,23 +1,18 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
 import static org.lmdbjava.CursorIterable.State.RELEASED;
@@ -30,21 +25,18 @@
 import java.util.Comparator;
 import java.util.Iterator;
 import java.util.NoSuchElementException;
-
 import org.lmdbjava.KeyRangeType.CursorOp;
 import org.lmdbjava.KeyRangeType.IteratorOp;
 
 /**
- * {@link Iterable} that creates a single {@link Iterator} that will iterate
- * over a {@link Cursor} as specified by a {@link KeyRange}.
+ * {@link Iterable} that creates a single {@link Iterator} that will iterate over a {@link Cursor}
+ * as specified by a {@link KeyRange}.
  *
- * <p>
- * An instance will create and close its own cursor.
+ * <p>An instance will create and close its own cursor.
  *
  * @param <T> buffer type
  */
-public final class CursorIterable<T> implements
-    Iterable<CursorIterable.KeyVal<T>>, AutoCloseable {
+public final class CursorIterable<T> implements Iterable<CursorIterable.KeyVal<T>>, AutoCloseable {
 
   private final Comparator<T> comparator;
   private final Cursor<T> cursor;
@@ -53,8 +45,8 @@ public final class CursorIterable<T> implements
   private final KeyRange<T> range;
   private State state = REQUIRES_INITIAL_OP;
 
-  CursorIterable(final Txn<T> txn, final Dbi<T> dbi, final KeyRange<T> range,
-                 final Comparator<T> comparator) {
+  CursorIterable(
+      final Txn<T> txn, final Dbi<T> dbi, final KeyRange<T> range, final Comparator<T> comparator) {
     this.cursor = dbi.openCursor(txn);
     this.range = range;
     this.comparator = comparator;
@@ -69,17 +61,14 @@ public void close() {
   /**
    * Obtain an iterator.
    *
-   * <p>
-   * As iteration of the returned iterator will cause movement of the underlying
-   * LMDB cursor, an {@link IllegalStateException} is thrown if an attempt is
-   * made to obtain the iterator more than once. For advanced cursor control
-   * (such as being able to iterate over the same data multiple times etc)
-   * please instead refer to {@link Dbi#openCursor(org.lmdbjava.Txn)}.
+   * <p>As iteration of the returned iterator will cause movement of the underlying LMDB cursor, an
+   * {@link IllegalStateException} is thrown if an attempt is made to obtain the iterator more than
+   * once. For advanced cursor control (such as being able to iterate over the same data multiple
+   * times etc) please instead refer to {@link Dbi#openCursor(org.lmdbjava.Txn)}.
    *
    * @return an iterator
    */
   @Override
-  @SuppressWarnings("checkstyle:AnonInnerLength")
   public Iterator<KeyVal<T>> iterator() {
     if (iteratorReturned) {
       throw new IllegalStateException("Iterator can only be returned once");
@@ -111,7 +100,6 @@ public void remove() {
     };
   }
 
-  @SuppressWarnings({"PMD.CyclomaticComplexity", "PMD.NullAssignment"})
   private void executeCursorOp(final CursorOp op) {
     final boolean found;
     switch (op) {
@@ -141,9 +129,8 @@ private void executeCursorOp(final CursorOp op) {
   }
 
   private void executeIteratorOp() {
-    final IteratorOp op = range.getType().iteratorOp(range.getStart(),
-                                                     range.getStop(),
-                                                     entry.key(), comparator);
+    final IteratorOp op =
+        range.getType().iteratorOp(range.getStart(), range.getStop(), entry.key(), comparator);
     switch (op) {
       case CALL_NEXT_OP:
         executeCursorOp(range.getType().nextOp());
@@ -183,10 +170,9 @@ private void update() {
   /**
    * Holder for a key and value pair.
    *
-   * <p>
-   * The same holder instance will always be returned for a given iterator.
-   * The returned keys and values may change or point to different memory
-   * locations following changes in the iterator, cursor or transaction.
+   * <p>The same holder instance will always be returned for a given iterator. The returned keys and
+   * values may change or point to different memory locations following changes in the iterator,
+   * cursor or transaction.
    *
    * @param <T> buffer type
    */
@@ -195,6 +181,9 @@ public static final class KeyVal<T> {
     private T k;
     private T v;
 
+    /** Explicitly-defined default constructor to avoid warnings. */
+    public KeyVal() {}
+
     /**
      * The key.
      *
@@ -220,15 +209,14 @@ void setK(final T key) {
     void setV(final T val) {
       this.v = val;
     }
-
   }
 
-  /**
-   * Represents the internal {@link CursorIterable} state.
-   */
+  /** Represents the internal {@link CursorIterable} state. */
   enum State {
-    REQUIRES_INITIAL_OP, REQUIRES_NEXT_OP, REQUIRES_ITERATOR_OP, RELEASED,
+    REQUIRES_INITIAL_OP,
+    REQUIRES_NEXT_OP,
+    REQUIRES_ITERATOR_OP,
+    RELEASED,
     TERMINATED
   }
-
 }
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index c5be4f85..ad1bb5a7 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -1,36 +1,20 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
-import jnr.ffi.Pointer;
-import jnr.ffi.byref.IntByReference;
-import jnr.ffi.byref.PointerByReference;
-import org.lmdbjava.Library.ComparatorCallback;
-import org.lmdbjava.Library.MDB_stat;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Comparator;
-import java.util.List;
-
 import static java.util.Objects.requireNonNull;
 import static jnr.ffi.Memory.allocateDirect;
 import static jnr.ffi.NativeType.ADDRESS;
@@ -47,6 +31,16 @@
 import static org.lmdbjava.PutFlags.MDB_RESERVE;
 import static org.lmdbjava.ResultCodeMapper.checkRc;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+import jnr.ffi.Pointer;
+import jnr.ffi.byref.IntByReference;
+import jnr.ffi.byref.PointerByReference;
+import org.lmdbjava.Library.ComparatorCallback;
+import org.lmdbjava.Library.MDB_stat;
+
 /**
  * LMDB Database.
  *
@@ -61,16 +55,21 @@ public final class Dbi<T> {
   private final byte[] name;
   private final Pointer ptr;
 
-  Dbi(final Env<T> env, final Txn<T> txn, final byte[] name,
-      final Comparator<T> comparator, final boolean nativeCb,
-      final BufferProxy<T> proxy, final DbiFlags... flags) {
+  Dbi(
+      final Env<T> env,
+      final Txn<T> txn,
+      final byte[] name,
+      final Comparator<T> comparator,
+      final boolean nativeCb,
+      final BufferProxy<T> proxy,
+      final DbiFlags... flags) {
     if (SHOULD_CHECK) {
       requireNonNull(txn);
       txn.checkReady();
     }
     this.env = env;
     this.name = name == null ? null : Arrays.copyOf(name, name.length);
-    if(comparator == null) {
+    if (comparator == null) {
       this.comparator = proxy.getComparator(flags);
     } else {
       this.comparator = comparator;
@@ -80,16 +79,17 @@ public final class Dbi<T> {
     checkRc(LIB.mdb_dbi_open(txn.pointer(), name, flagsMask, dbiPtr));
     ptr = dbiPtr.getPointer(0);
     if (nativeCb) {
-      this.ccb = (keyA, keyB) -> {
-        final T compKeyA = proxy.allocate();
-        final T compKeyB = proxy.allocate();
-        proxy.out(compKeyA, keyA, keyA.address());
-        proxy.out(compKeyB, keyB, keyB.address());
-        final int result = this.comparator.compare(compKeyA, compKeyB);
-        proxy.deallocate(compKeyA);
-        proxy.deallocate(compKeyB);
-        return result;
-      };
+      this.ccb =
+          (keyA, keyB) -> {
+            final T compKeyA = proxy.allocate();
+            final T compKeyB = proxy.allocate();
+            proxy.out(compKeyA, keyA, keyA.address());
+            proxy.out(compKeyB, keyB, keyB.address());
+            final int result = this.comparator.compare(compKeyA, compKeyB);
+            proxy.deallocate(compKeyA);
+            proxy.deallocate(compKeyB);
+            return result;
+          };
       LIB.mdb_set_compare(txn.pointer(), ptr, ccb);
     } else {
       ccb = null;
@@ -99,13 +99,11 @@ public final class Dbi<T> {
   /**
    * Close the database handle (normally unnecessary; use with caution).
    *
-   * <p>
-   * It is very rare that closing a database handle is useful. There are also
-   * many warnings/restrictions if closing a database handle (refer to the LMDB
-   * C documentation). As such this is non-routine usage and this class does not
-   * track the open/closed state of the {@link Dbi}. Advanced users are expected
-   * to have specific reasons for using this method and will manage their own
-   * state accordingly.
+   * <p>It is very rare that closing a database handle is useful. There are also many
+   * warnings/restrictions if closing a database handle (refer to the LMDB C documentation). As such
+   * this is non-routine usage and this class does not track the open/closed state of the {@link
+   * Dbi}. Advanced users are expected to have specific reasons for using this method and will
+   * manage their own state accordingly.
    */
   public void close() {
     clean();
@@ -120,7 +118,6 @@ public void close() {
    *
    * @param key key to delete from the database (not null)
    * @return true if the key/data pair was found, false otherwise
-   *
    * @see #delete(org.lmdbjava.Txn, java.lang.Object, java.lang.Object)
    */
   public boolean delete(final T key) {
@@ -137,7 +134,6 @@ public boolean delete(final T key) {
    * @param txn transaction handle (not null; not committed; must be R-W)
    * @param key key to delete from the database (not null)
    * @return true if the key/data pair was found, false otherwise
-   *
    * @see #delete(org.lmdbjava.Txn, java.lang.Object, java.lang.Object)
    */
   public boolean delete(final Txn<T> txn, final T key) {
@@ -147,12 +143,10 @@ public boolean delete(final Txn<T> txn, final T key) {
   /**
    * Removes key/data pairs from the database.
    *
-   * <p>
-   * If the database does not support sorted duplicate data items
-   * ({@link DbiFlags#MDB_DUPSORT}) the value parameter is ignored. If the
-   * database supports sorted duplicates and the value parameter is null, all of
-   * the duplicate data items for the key will be deleted. Otherwise, if the
-   * data parameter is non-null only the matching data item will be deleted.
+   * <p>If the database does not support sorted duplicate data items ({@link DbiFlags#MDB_DUPSORT})
+   * the value parameter is ignored. If the database supports sorted duplicates and the value
+   * parameter is null, all of the duplicate data items for the key will be deleted. Otherwise, if
+   * the data parameter is non-null only the matching data item will be deleted.
    *
    * @param txn transaction handle (not null; not committed; must be R-W)
    * @param key key to delete from the database (not null)
@@ -187,10 +181,8 @@ public boolean delete(final Txn<T> txn, final T key, final T val) {
   /**
    * Drops the data in this database, leaving the database open for further use.
    *
-   * <p>
-   * This method slightly differs from the LMDB C API in that it does not
-   * provide support for also closing the DB handle. If closing the DB handle is
-   * required, please see {@link #close()}.
+   * <p>This method slightly differs from the LMDB C API in that it does not provide support for
+   * also closing the DB handle. If closing the DB handle is required, please see {@link #close()}.
    *
    * @param txn transaction handle (not null; not committed; must be R-W)
    */
@@ -199,11 +191,11 @@ public void drop(final Txn<T> txn) {
   }
 
   /**
-   * Drops the database. If delete is set to true, the database will be deleted
-   * and handle will be closed. See {@link #close()} for implication of handle
-   * close. Otherwise, only the data in this database will be dropped.
+   * Drops the database. If delete is set to true, the database will be deleted and handle will be
+   * closed. See {@link #close()} for implication of handle close. Otherwise, only the data in this
+   * database will be dropped.
    *
-   * @param txn    transaction handle (not null; not committed; must be R-W)
+   * @param txn transaction handle (not null; not committed; must be R-W)
    * @param delete whether database should be deleted.
    */
   public void drop(final Txn<T> txn, final boolean delete) {
@@ -223,12 +215,10 @@ public void drop(final Txn<T> txn, final boolean delete) {
   /**
    * Get items from a database, moving the {@link Txn#val()} to the value.
    *
-   * <p>
-   * This function retrieves key/data pairs from the database. The address and
-   * length of the data associated with the specified \b key are returned in the
-   * structure to which \b data refers. If the database supports duplicate keys
-   * ({@link org.lmdbjava.DbiFlags#MDB_DUPSORT}) then the first data item for
-   * the key will be returned. Retrieval of other items requires the use of
+   * <p>This function retrieves key/data pairs from the database. The address and length of the data
+   * associated with the specified \b key are returned in the structure to which \b data refers. If
+   * the database supports duplicate keys ({@link org.lmdbjava.DbiFlags#MDB_DUPSORT}) then the first
+   * data item for the key will be returned. Retrieval of other items requires the use of
    * #mdb_cursor_get().
    *
    * @param txn transaction handle (not null; not committed)
@@ -243,8 +233,7 @@ public T get(final Txn<T> txn, final T key) {
       txn.checkReady();
     }
     txn.kv().keyIn(key);
-    final int rc = LIB.mdb_get(txn.pointer(), ptr, txn.kv().pointerKey(), txn
-                               .kv().pointerVal());
+    final int rc = LIB.mdb_get(txn.pointer(), ptr, txn.kv().pointerKey(), txn.kv().pointerVal());
     if (rc == MDB_NOTFOUND) {
       return null;
     }
@@ -275,7 +264,7 @@ public CursorIterable<T> iterate(final Txn<T> txn) {
   /**
    * Iterate the database in accordance with the provided {@link KeyRange}.
    *
-   * @param txn   transaction handle (not null; not committed)
+   * @param txn transaction handle (not null; not committed)
    * @param range range of acceptable keys (not null)
    * @return iterator (never null)
    */
@@ -289,11 +278,11 @@ public CursorIterable<T> iterate(final Txn<T> txn, final KeyRange<T> range) {
     return new CursorIterable<>(txn, this, range, comparator);
   }
 
-  /*
-  * Return DbiFlags for this Dbi.
-  *
-  * @param txn transaction handle (not null; not committed)
-  * @return the list of flags this Dbi was created with
+  /**
+   * Return DbiFlags for this Dbi.
+   *
+   * @param txn transaction handle (not null; not committed)
+   * @return the list of flags this Dbi was created with
    */
   public List<DbiFlags> listFlags(final Txn<T> txn) {
     if (SHOULD_CHECK) {
@@ -318,15 +307,13 @@ public List<DbiFlags> listFlags(final Txn<T> txn) {
   /**
    * Create a cursor handle.
    *
-   * <p>
-   * A cursor is associated with a specific transaction and database. A cursor
-   * cannot be used when its database handle is closed. Nor when its transaction
-   * has ended, except with {@link Cursor#renew(org.lmdbjava.Txn)}. It can be
-   * discarded with {@link Cursor#close()}. A cursor in a write-transaction can
-   * be closed before its transaction ends, and will otherwise be closed when
-   * its transaction ends. A cursor in a read-only transaction must be closed
-   * explicitly, before or after its transaction ends. It can be reused with
-   * {@link Cursor#renew(org.lmdbjava.Txn)} before finally closing it.
+   * <p>A cursor is associated with a specific transaction and database. A cursor cannot be used
+   * when its database handle is closed. Nor when its transaction has ended, except with {@link
+   * Cursor#renew(org.lmdbjava.Txn)}. It can be discarded with {@link Cursor#close()}. A cursor in a
+   * write-transaction can be closed before its transaction ends, and will otherwise be closed when
+   * its transaction ends. A cursor in a read-only transaction must be closed explicitly, before or
+   * after its transaction ends. It can be reused with {@link Cursor#renew(org.lmdbjava.Txn)} before
+   * finally closing it.
    *
    * @param txn transaction handle (not null; not committed)
    * @return cursor handle
@@ -347,8 +334,7 @@ public Cursor<T> openCursor(final Txn<T> txn) {
    *
    * @param key key to store in the database (not null)
    * @param val value to store in the database (not null)
-   * @see #put(org.lmdbjava.Txn, java.lang.Object, java.lang.Object,
-   * org.lmdbjava.PutFlags...)
+   * @see #put(org.lmdbjava.Txn, java.lang.Object, java.lang.Object, org.lmdbjava.PutFlags...)
    */
   public void put(final T key, final T val) {
     try (Txn<T> txn = env.txnWrite()) {
@@ -360,21 +346,18 @@ public void put(final T key, final T val) {
   /**
    * Store a key/value pair in the database.
    *
-   * <p>
-   * This function stores key/data pairs in the database. The default behavior
-   * is to enter the new key/data pair, replacing any previously existing key if
-   * duplicates are disallowed, or adding a duplicate data item if duplicates
-   * are allowed ({@link DbiFlags#MDB_DUPSORT}).
+   * <p>This function stores key/data pairs in the database. The default behavior is to enter the
+   * new key/data pair, replacing any previously existing key if duplicates are disallowed, or
+   * adding a duplicate data item if duplicates are allowed ({@link DbiFlags#MDB_DUPSORT}).
    *
-   * @param txn   transaction handle (not null; not committed; must be R-W)
-   * @param key   key to store in the database (not null)
-   * @param val   value to store in the database (not null)
+   * @param txn transaction handle (not null; not committed; must be R-W)
+   * @param key key to store in the database (not null)
+   * @param val value to store in the database (not null)
    * @param flags Special options for this operation
-   * @return true if the value was put, false if MDB_NOOVERWRITE or
-   *         MDB_NODUPDATA were set and the key/value existed already.
+   * @return true if the value was put, false if MDB_NOOVERWRITE or MDB_NODUPDATA were set and the
+   *     key/value existed already.
    */
-  public boolean put(final Txn<T> txn, final T key, final T val,
-                     final PutFlags... flags) {
+  public boolean put(final Txn<T> txn, final T key, final T val, final PutFlags... flags) {
     if (SHOULD_CHECK) {
       requireNonNull(txn);
       requireNonNull(key);
@@ -386,8 +369,8 @@ public boolean put(final Txn<T> txn, final T key, final T val,
     txn.kv().keyIn(key);
     txn.kv().valIn(val);
     final int mask = mask(true, flags);
-    final int rc = LIB.mdb_put(txn.pointer(), ptr, txn.kv().pointerKey(), txn
-                               .kv().pointerVal(), mask);
+    final int rc =
+        LIB.mdb_put(txn.pointer(), ptr, txn.kv().pointerKey(), txn.kv().pointerVal(), mask);
     if (rc == MDB_KEYEXIST) {
       if (isSet(mask, MDB_NOOVERWRITE)) {
         txn.kv().valOut(); // marked as in,out in LMDB C docs
@@ -403,24 +386,21 @@ public boolean put(final Txn<T> txn, final T key, final T val,
   }
 
   /**
-   * Reserve space for data of the given size, but don't copy the given val.
-   * Instead, return a pointer to the reserved space, which the caller can fill
-   * in later - before the next update operation or the transaction ends. This
-   * saves an extra memcpy if the data is being generated later. LMDB does
-   * nothing else with this memory, the caller is expected to modify all of the
+   * Reserve space for data of the given size, but don't copy the given val. Instead, return a
+   * pointer to the reserved space, which the caller can fill in later - before the next update
+   * operation or the transaction ends. This saves an extra memcpy if the data is being generated
+   * later. LMDB does nothing else with this memory, the caller is expected to modify all of the
    * space requested.
    *
-   * <p>
-   * This flag must not be specified if the database was opened with MDB_DUPSORT
+   * <p>This flag must not be specified if the database was opened with MDB_DUPSORT
    *
-   * @param txn  transaction handle (not null; not committed; must be R-W)
-   * @param key  key to store in the database (not null)
+   * @param txn transaction handle (not null; not committed; must be R-W)
+   * @param key key to store in the database (not null)
    * @param size size of the value to be stored in the database
-   * @param op   options for this operation
+   * @param op options for this operation
    * @return a buffer that can be used to modify the value
    */
-  public T reserve(final Txn<T> txn, final T key, final int size,
-                   final PutFlags... op) {
+  public T reserve(final Txn<T> txn, final T key, final int size, final PutFlags... op) {
     if (SHOULD_CHECK) {
       requireNonNull(txn);
       requireNonNull(key);
@@ -431,8 +411,7 @@ public T reserve(final Txn<T> txn, final T key, final int size,
     txn.kv().keyIn(key);
     txn.kv().valIn(size);
     final int flags = mask(true, op) | MDB_RESERVE.getMask();
-    checkRc(LIB.mdb_put(txn.pointer(), ptr, txn.kv().pointerKey(), txn.kv()
-                        .pointerVal(), flags));
+    checkRc(LIB.mdb_put(txn.pointer(), ptr, txn.kv().pointerKey(), txn.kv().pointerVal(), flags));
     txn.kv().valOut(); // marked as in,out in LMDB C docs
     ReferenceUtil.reachabilityFence0(key);
     return txn.val();
@@ -468,9 +447,7 @@ private void clean() {
     cleaned = true;
   }
 
-  /**
-   * The specified DBI was changed unexpectedly.
-   */
+  /** The specified DBI was changed unexpectedly. */
   public static final class BadDbiException extends LmdbNativeException {
 
     static final int MDB_BAD_DBI = -30_780;
@@ -481,23 +458,18 @@ public static final class BadDbiException extends LmdbNativeException {
     }
   }
 
-  /**
-   * Unsupported size of key/DB name/data, or wrong DUPFIXED size.
-   */
+  /** Unsupported size of key/DB name/data, or wrong DUPFIXED size. */
   public static final class BadValueSizeException extends LmdbNativeException {
 
     static final int MDB_BAD_VALSIZE = -30_781;
     private static final long serialVersionUID = 1L;
 
     BadValueSizeException() {
-      super(MDB_BAD_VALSIZE,
-            "Unsupported size of key/DB name/data, or wrong DUPFIXED size");
+      super(MDB_BAD_VALSIZE, "Unsupported size of key/DB name/data, or wrong DUPFIXED size");
     }
   }
 
-  /**
-   * Environment maxdbs reached.
-   */
+  /** Environment maxdbs reached. */
   public static final class DbFullException extends LmdbNativeException {
 
     static final int MDB_DBS_FULL = -30_791;
@@ -511,14 +483,13 @@ public static final class DbFullException extends LmdbNativeException {
   /**
    * Operation and DB incompatible, or DB type changed.
    *
-   * <p>
-   * This can mean:
+   * <p>This can mean:
+   *
    * <ul>
-   * <li>The operation expects an MDB_DUPSORT / MDB_DUPFIXED database.</li>
-   * <li>Opening a named DB when the unnamed DB has MDB_DUPSORT /
-   * MDB_INTEGERKEY.</li>
-   * <li>Accessing a data record as a database, or vice versa.</li>
-   * <li>The database was dropped and recreated with different flags.</li>
+   *   <li>The operation expects an MDB_DUPSORT / MDB_DUPFIXED database.
+   *   <li>Opening a named DB when the unnamed DB has MDB_DUPSORT / MDB_INTEGERKEY.
+   *   <li>Accessing a data record as a database, or vice versa.
+   *   <li>The database was dropped and recreated with different flags.
    * </ul>
    */
   public static final class IncompatibleException extends LmdbNativeException {
@@ -527,14 +498,11 @@ public static final class IncompatibleException extends LmdbNativeException {
     private static final long serialVersionUID = 1L;
 
     IncompatibleException() {
-      super(MDB_INCOMPATIBLE,
-            "Operation and DB incompatible, or DB type changed");
+      super(MDB_INCOMPATIBLE, "Operation and DB incompatible, or DB type changed");
     }
   }
 
-  /**
-   * Key/data pair already exists.
-   */
+  /** Key/data pair already exists. */
   public static final class KeyExistsException extends LmdbNativeException {
 
     static final int MDB_KEYEXIST = -30_799;
@@ -545,9 +513,7 @@ public static final class KeyExistsException extends LmdbNativeException {
     }
   }
 
-  /**
-   * Key/data pair not found (EOF).
-   */
+  /** Key/data pair not found (EOF). */
   public static final class KeyNotFoundException extends LmdbNativeException {
 
     static final int MDB_NOTFOUND = -30_798;
@@ -558,9 +524,7 @@ public static final class KeyNotFoundException extends LmdbNativeException {
     }
   }
 
-  /**
-   * Database contents grew beyond environment mapsize.
-   */
+  /** Database contents grew beyond environment mapsize. */
   public static final class MapResizedException extends LmdbNativeException {
 
     static final int MDB_MAP_RESIZED = -30_785;
diff --git a/src/main/java/org/lmdbjava/DbiFlags.java b/src/main/java/org/lmdbjava/DbiFlags.java
index 7277b55b..123ec9fd 100644
--- a/src/main/java/org/lmdbjava/DbiFlags.java
+++ b/src/main/java/org/lmdbjava/DbiFlags.java
@@ -1,96 +1,79 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
-/**
- * Flags for use when opening a {@link Dbi}.
- */
+/** Flags for use when opening a {@link Dbi}. */
 public enum DbiFlags implements MaskedFlag {
 
   /**
    * Use reverse string keys.
    *
-   * <p>
-   * Keys are strings to be compared in reverse order, from the end of the
-   * strings to the beginning. By default, keys are treated as strings and
-   * compared from beginning to end.
+   * <p>Keys are strings to be compared in reverse order, from the end of the strings to the
+   * beginning. By default, keys are treated as strings and compared from beginning to end.
    */
   MDB_REVERSEKEY(0x02),
   /**
    * Use sorted duplicates.
    *
-   * <p>
-   * Duplicate keys may be used in the database. Or, from another perspective,
-   * keys may have multiple data items, stored in sorted order. By default keys
-   * must be unique and may have only a single data item.
+   * <p>Duplicate keys may be used in the database. Or, from another perspective, keys may have
+   * multiple data items, stored in sorted order. By default keys must be unique and may have only a
+   * single data item.
    */
   MDB_DUPSORT(0x04),
   /**
-   * Numeric keys in native byte order: either unsigned int or size_t. The keys
-   * must all be of the same size.
+   * Numeric keys in native byte order: either unsigned int or size_t. The keys must all be of the
+   * same size.
    */
   MDB_INTEGERKEY(0x08),
   /**
    * With {@link #MDB_DUPSORT}, sorted dup items have fixed size.
    *
-   * <p>
-   * This flag may only be used in combination with {@link #MDB_DUPSORT}. This
-   * option tells the library that the data items for this database are all the
-   * same size, which allows further optimizations in storage and retrieval.
-   * When all data items are the same size, the {@link SeekOp#MDB_GET_MULTIPLE}
-   * and {@link SeekOp#MDB_NEXT_MULTIPLE} cursor operations may be used to
+   * <p>This flag may only be used in combination with {@link #MDB_DUPSORT}. This option tells the
+   * library that the data items for this database are all the same size, which allows further
+   * optimizations in storage and retrieval. When all data items are the same size, the {@link
+   * SeekOp#MDB_GET_MULTIPLE} and {@link SeekOp#MDB_NEXT_MULTIPLE} cursor operations may be used to
    * retrieve multiple items at once.
    */
   MDB_DUPFIXED(0x10),
   /**
    * With {@link #MDB_DUPSORT}, dups are {@link #MDB_INTEGERKEY}-style integers.
    *
-   * <p>
-   * This option specifies that duplicate data items are binary integers,
-   * similar to {@link #MDB_INTEGERKEY} keys.
+   * <p>This option specifies that duplicate data items are binary integers, similar to {@link
+   * #MDB_INTEGERKEY} keys.
    */
   MDB_INTEGERDUP(0x20),
   /**
    * Compare the <b>numeric</b> keys in native byte order and as unsigned.
    *
-   * <p>
-   * This option is applied only to {@link java.nio.ByteBuffer}, {@link org.agrona.DirectBuffer} and byte array keys.
-   * {@link io.netty.buffer.ByteBuf} keys are always compared in native byte order and as unsigned.
-   * </p>
+   * <p>This option is applied only to {@link java.nio.ByteBuffer}, {@link org.agrona.DirectBuffer}
+   * and byte array keys. {@link io.netty.buffer.ByteBuf} keys are always compared in native byte
+   * order and as unsigned.
    */
   MDB_UNSIGNEDKEY(0x30, false),
   /**
    * With {@link #MDB_DUPSORT}, use reverse string dups.
    *
-   * <p>
-   * This option specifies that duplicate data items should be compared as
-   * strings in reverse order.
+   * <p>This option specifies that duplicate data items should be compared as strings in reverse
+   * order.
    */
   MDB_REVERSEDUP(0x40),
   /**
    * Create the named database if it doesn't exist.
    *
-   * <p>
-   * This option is not allowed in a read-only transaction or a read-only
-   * environment.
+   * <p>This option is not allowed in a read-only transaction or a read-only environment.
    */
   MDB_CREATE(0x4_0000);
 
diff --git a/src/main/java/org/lmdbjava/DirectBufferProxy.java b/src/main/java/org/lmdbjava/DirectBufferProxy.java
index 3bde81ec..156e60e9 100644
--- a/src/main/java/org/lmdbjava/DirectBufferProxy.java
+++ b/src/main/java/org/lmdbjava/DirectBufferProxy.java
@@ -1,73 +1,64 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
-import jnr.ffi.Pointer;
-import org.agrona.DirectBuffer;
-import org.agrona.MutableDirectBuffer;
-import org.agrona.concurrent.UnsafeBuffer;
-
-import java.nio.ByteBuffer;
-import java.util.ArrayDeque;
-import java.util.Comparator;
-
 import static java.lang.ThreadLocal.withInitial;
 import static java.nio.ByteBuffer.allocateDirect;
 import static java.nio.ByteOrder.BIG_ENDIAN;
 import static java.util.Objects.requireNonNull;
 import static org.lmdbjava.UnsafeAccess.UNSAFE;
 
+import java.nio.ByteBuffer;
+import java.util.ArrayDeque;
+import java.util.Comparator;
+import jnr.ffi.Pointer;
+import org.agrona.DirectBuffer;
+import org.agrona.MutableDirectBuffer;
+import org.agrona.concurrent.UnsafeBuffer;
+
 /**
  * A buffer proxy backed by Agrona's {@link DirectBuffer}.
  *
- * <p>
- * This class requires {@link UnsafeAccess} and Agrona must be in the classpath.
+ * <p>This class requires {@link UnsafeAccess} and Agrona must be in the classpath.
  */
 public final class DirectBufferProxy extends BufferProxy<DirectBuffer> {
-  private static final Comparator<DirectBuffer> signedComparator = (o1, o2) -> {
-    requireNonNull(o1);
-    requireNonNull(o2);
+  private static final Comparator<DirectBuffer> signedComparator =
+      (o1, o2) -> {
+        requireNonNull(o1);
+        requireNonNull(o2);
 
-    return o1.compareTo(o2);
-  };
+        return o1.compareTo(o2);
+      };
   private static final Comparator<DirectBuffer> unsignedComparator = DirectBufferProxy::compareBuff;
 
   /**
-   * The {@link MutableDirectBuffer} proxy. Guaranteed to never be null,
-   * although a class initialization exception will occur if an attempt is made
-   * to access this field when unsafe or Agrona is unavailable.
+   * The {@link MutableDirectBuffer} proxy. Guaranteed to never be null, although a class
+   * initialization exception will occur if an attempt is made to access this field when unsafe or
+   * Agrona is unavailable.
    */
-  public static final BufferProxy<DirectBuffer> PROXY_DB
-      = new DirectBufferProxy();
+  public static final BufferProxy<DirectBuffer> PROXY_DB = new DirectBufferProxy();
 
   /**
-   * A thread-safe pool for a given length. If the buffer found is valid (ie not
-   * of a negative length) then that buffer is used. If no valid buffer is
-   * found, a new buffer is created.
+   * A thread-safe pool for a given length. If the buffer found is valid (ie not of a negative
+   * length) then that buffer is used. If no valid buffer is found, a new buffer is created.
    */
-  private static final ThreadLocal<ArrayDeque<DirectBuffer>> BUFFERS
-      = withInitial(() -> new ArrayDeque<>(16));
+  private static final ThreadLocal<ArrayDeque<DirectBuffer>> BUFFERS =
+      withInitial(() -> new ArrayDeque<>(16));
 
-  private DirectBufferProxy() {
-  }
+  private DirectBufferProxy() {}
 
   /**
    * Lexicographically compare two buffers.
@@ -143,8 +134,7 @@ protected byte[] getBytes(final DirectBuffer buffer) {
   }
 
   @Override
-  protected void in(final DirectBuffer buffer, final Pointer ptr,
-                    final long ptrAddr) {
+  protected void in(final DirectBuffer buffer, final Pointer ptr, final long ptrAddr) {
     final long addr = buffer.addressOffset();
     final long size = buffer.capacity();
     UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_DATA, addr);
@@ -152,20 +142,18 @@ protected void in(final DirectBuffer buffer, final Pointer ptr,
   }
 
   @Override
-  protected void in(final DirectBuffer buffer, final int size, final Pointer ptr,
-                    final long ptrAddr) {
+  protected void in(
+      final DirectBuffer buffer, final int size, final Pointer ptr, final long ptrAddr) {
     final long addr = buffer.addressOffset();
     UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_DATA, addr);
     UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_SIZE, size);
   }
 
   @Override
-  protected DirectBuffer out(final DirectBuffer buffer, final Pointer ptr,
-                             final long ptrAddr) {
+  protected DirectBuffer out(final DirectBuffer buffer, final Pointer ptr, final long ptrAddr) {
     final long addr = UNSAFE.getLong(ptrAddr + STRUCT_FIELD_OFFSET_DATA);
     final long size = UNSAFE.getLong(ptrAddr + STRUCT_FIELD_OFFSET_SIZE);
     buffer.wrap(addr, (int) size);
     return buffer;
   }
-
 }
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index ae7e46c9..3db16119 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -1,38 +1,20 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
-import jnr.ffi.Pointer;
-import jnr.ffi.byref.IntByReference;
-import jnr.ffi.byref.PointerByReference;
-import org.lmdbjava.Library.MDB_envinfo;
-import org.lmdbjava.Library.MDB_stat;
-
-import java.io.File;
-import java.nio.ByteBuffer;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.List;
-
 import static java.lang.Boolean.getBoolean;
 import static java.nio.charset.StandardCharsets.UTF_8;
 import static java.util.Objects.requireNonNull;
@@ -46,24 +28,32 @@
 import static org.lmdbjava.ResultCodeMapper.checkRc;
 import static org.lmdbjava.TxnFlags.MDB_RDONLY_TXN;
 
+import java.io.File;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import jnr.ffi.Pointer;
+import jnr.ffi.byref.IntByReference;
+import jnr.ffi.byref.PointerByReference;
+import org.lmdbjava.Library.MDB_envinfo;
+import org.lmdbjava.Library.MDB_stat;
+
 /**
  * LMDB environment.
  *
  * @param <T> buffer type
  */
-@SuppressWarnings("PMD.GodClass")
 public final class Env<T> implements AutoCloseable {
 
-  /**
-   * Java system property name that can be set to disable optional checks.
-   */
+  /** Java system property name that can be set to disable optional checks. */
   public static final String DISABLE_CHECKS_PROP = "lmdbjava.disable.checks";
 
   /**
-   * Indicates whether optional checks should be applied in LmdbJava. Optional
-   * checks are only disabled in critical paths (see package-level JavaDocs).
-   * Non-critical paths have optional checks performed at all times, regardless
-   * of this property.
+   * Indicates whether optional checks should be applied in LmdbJava. Optional checks are only
+   * disabled in critical paths (see package-level JavaDocs). Non-critical paths have optional
+   * checks performed at all times, regardless of this property.
    */
   public static final boolean SHOULD_CHECK = !getBoolean(DISABLE_CHECKS_PROP);
 
@@ -74,8 +64,11 @@ public final class Env<T> implements AutoCloseable {
   private final Pointer ptr;
   private final boolean readOnly;
 
-  private Env(final BufferProxy<T> proxy, final Pointer ptr,
-              final boolean readOnly, final boolean noSubDir) {
+  private Env(
+      final BufferProxy<T> proxy,
+      final Pointer ptr,
+      final boolean readOnly,
+      final boolean noSubDir) {
     this.proxy = proxy;
     this.readOnly = readOnly;
     this.noSubDir = noSubDir;
@@ -96,7 +89,7 @@ public static Builder<ByteBuffer> create() {
   /**
    * Create an {@link Env} using the passed {@link BufferProxy}.
    *
-   * @param <T>   buffer type
+   * @param <T> buffer type
    * @param proxy the proxy to use (required)
    * @return the environment (never null)
    */
@@ -105,26 +98,22 @@ public static <T> Builder<T> create(final BufferProxy<T> proxy) {
   }
 
   /**
-   * Opens an environment with a single default database in 0664 mode using the
-   * {@link ByteBufferProxy#PROXY_OPTIMAL}.
+   * Opens an environment with a single default database in 0664 mode using the {@link
+   * ByteBufferProxy#PROXY_OPTIMAL}.
    *
-   * @param path  file system destination
-   * @param size  size in megabytes
+   * @param path file system destination
+   * @param size size in megabytes
    * @param flags the flags for this new environment
    * @return env the environment (never null)
    */
-  public static Env<ByteBuffer> open(final File path, final int size,
-                                     final EnvFlags... flags) {
-    return new Builder<>(PROXY_OPTIMAL)
-        .setMapSize(size * 1_024L * 1_024L)
-        .open(path, flags);
+  public static Env<ByteBuffer> open(final File path, final int size, final EnvFlags... flags) {
+    return new Builder<>(PROXY_OPTIMAL).setMapSize(size * 1_024L * 1_024L).open(path, flags);
   }
 
   /**
    * Close the handle.
    *
-   * <p>
-   * Will silently return if already closed or never opened.
+   * <p>Will silently return if already closed or never opened.
    */
   @Override
   public void close() {
@@ -138,22 +127,19 @@ public void close() {
   /**
    * Copies an LMDB environment to the specified destination path.
    *
-   * <p>
-   * This function may be used to make a backup of an existing environment. No
-   * lockfile is created, since it gets recreated at need.
+   * <p>This function may be used to make a backup of an existing environment. No lockfile is
+   * created, since it gets recreated at need.
    *
-   * <p>
-   * If this environment was created using {@link EnvFlags#MDB_NOSUBDIR}, the
-   * destination path must be a directory that exists but contains no files. If
-   * {@link EnvFlags#MDB_NOSUBDIR} was used, the destination path must not
-   * exist, but it must be possible to create a file at the provided path.
+   * <p>If this environment was created using {@link EnvFlags#MDB_NOSUBDIR}, the destination path
+   * must be a directory that exists but contains no files. If {@link EnvFlags#MDB_NOSUBDIR} was
+   * used, the destination path must not exist, but it must be possible to create a file at the
+   * provided path.
    *
-   * <p>
-   * Note: This call can trigger significant file size growth if run in parallel
-   * with write transactions, because it employs a read-only transaction. See
-   * long-lived transactions under "Caveats" in the LMDB native documentation.
+   * <p>Note: This call can trigger significant file size growth if run in parallel with write
+   * transactions, because it employs a read-only transaction. See long-lived transactions under
+   * "Caveats" in the LMDB native documentation.
    *
-   * @param path  writable destination path as described above
+   * @param path writable destination path as described above
    * @param flags special options for this copy
    */
   public void copy(final File path, final CopyFlags... flags) {
@@ -166,13 +152,11 @@ public void copy(final File path, final CopyFlags... flags) {
   /**
    * Obtain the DBI names.
    *
-   * <p>
-   * This method is only compatible with {@link Env}s that use named databases.
-   * If an unnamed {@link Dbi} is being used to store data, this method will
-   * attempt to return all such keys from the unnamed database.
+   * <p>This method is only compatible with {@link Env}s that use named databases. If an unnamed
+   * {@link Dbi} is being used to store data, this method will attempt to return all such keys from
+   * the unnamed database.
    *
-   * <p>
-   * This method must not be called from concurrent threads.
+   * <p>This method must not be called from concurrent threads.
    *
    * @return a list of DBI names (never null)
    */
@@ -180,7 +164,7 @@ public List<byte[]> getDbiNames() {
     final List<byte[]> result = new ArrayList<>();
     final Dbi<T> names = openDbi((byte[]) null);
     try (Txn<T> txn = txnRead();
-         Cursor<T> cursor = names.openCursor(txn)) {
+        Cursor<T> cursor = names.openCursor(txn)) {
       if (!cursor.first()) {
         return Collections.emptyList();
       }
@@ -249,8 +233,7 @@ public boolean isClosed() {
   }
 
   /**
-   * Indicates if this environment was opened with
-   * {@link EnvFlags#MDB_RDONLY_ENV}.
+   * Indicates if this environment was opened with {@link EnvFlags#MDB_RDONLY_ENV}.
    *
    * @return true if read-only
    */
@@ -259,10 +242,10 @@ public boolean isReadOnly() {
   }
 
   /**
-   * Convenience method that opens a {@link Dbi} with a UTF-8 database name and
-   * default {@link Comparator} that is not invoked from native code.
+   * Convenience method that opens a {@link Dbi} with a UTF-8 database name and default {@link
+   * Comparator} that is not invoked from native code.
    *
-   * @param name  name of the database (or null if no name is required)
+   * @param name name of the database (or null if no name is required)
    * @param flags to open the database with
    * @return a database that is ready to use
    */
@@ -272,42 +255,44 @@ public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
   }
 
   /**
-   * Convenience method that opens a {@link Dbi} with a UTF-8 database name and
-   * associated {@link Comparator} that is not invoked from native code.
+   * Convenience method that opens a {@link Dbi} with a UTF-8 database name and associated {@link
+   * Comparator} that is not invoked from native code.
    *
-   * @param name       name of the database (or null if no name is required)
+   * @param name name of the database (or null if no name is required)
    * @param comparator custom comparator callback (or null to use default)
-   * @param flags      to open the database with
+   * @param flags to open the database with
    * @return a database that is ready to use
    */
-  public Dbi<T> openDbi(final String name, final Comparator<T> comparator,
-                        final DbiFlags... flags) {
+  public Dbi<T> openDbi(
+      final String name, final Comparator<T> comparator, final DbiFlags... flags) {
     final byte[] nameBytes = name == null ? null : name.getBytes(UTF_8);
     return openDbi(nameBytes, comparator, false, flags);
   }
 
   /**
-   * Convenience method that opens a {@link Dbi} with a UTF-8 database name and
-   * associated {@link Comparator} that may be invoked from native code if
-   * specified.
+   * Convenience method that opens a {@link Dbi} with a UTF-8 database name and associated {@link
+   * Comparator} that may be invoked from native code if specified.
    *
-   * @param name       name of the database (or null if no name is required)
+   * @param name name of the database (or null if no name is required)
    * @param comparator custom comparator callback (or null to use default)
-   * @param nativeCb   whether native code calls back to the Java comparator
-   * @param flags      to open the database with
+   * @param nativeCb whether native code calls back to the Java comparator
+   * @param flags to open the database with
    * @return a database that is ready to use
    */
-  public Dbi<T> openDbi(final String name, final Comparator<T> comparator,
-                        final boolean nativeCb, final DbiFlags... flags) {
+  public Dbi<T> openDbi(
+      final String name,
+      final Comparator<T> comparator,
+      final boolean nativeCb,
+      final DbiFlags... flags) {
     final byte[] nameBytes = name == null ? null : name.getBytes(UTF_8);
     return openDbi(nameBytes, comparator, nativeCb, flags);
   }
 
   /**
-   * Convenience method that opens a {@link Dbi} with a default
-   * {@link Comparator} that is not invoked from native code.
+   * Convenience method that opens a {@link Dbi} with a default {@link Comparator} that is not
+   * invoked from native code.
    *
-   * @param name  name of the database (or null if no name is required)
+   * @param name name of the database (or null if no name is required)
    * @param flags to open the database with
    * @return a database that is ready to use
    */
@@ -316,36 +301,37 @@ public Dbi<T> openDbi(final byte[] name, final DbiFlags... flags) {
   }
 
   /**
-   * Convenience method that opens a {@link Dbi} with an associated
-   * {@link Comparator} that is not invoked from native code.
+   * Convenience method that opens a {@link Dbi} with an associated {@link Comparator} that is not
+   * invoked from native code.
    *
-   * @param name       name of the database (or null if no name is required)
+   * @param name name of the database (or null if no name is required)
    * @param comparator custom comparator callback (or null to use LMDB default)
-   * @param flags      to open the database with
+   * @param flags to open the database with
    * @return a database that is ready to use
    */
-  public Dbi<T> openDbi(final byte[] name, final Comparator<T> comparator,
-                        final DbiFlags... flags) {
+  public Dbi<T> openDbi(
+      final byte[] name, final Comparator<T> comparator, final DbiFlags... flags) {
     return openDbi(name, comparator, false, flags);
   }
 
   /**
-   * Convenience method that opens a {@link Dbi} with an associated
-   * {@link Comparator} that may be invoked from native code if specified.
+   * Convenience method that opens a {@link Dbi} with an associated {@link Comparator} that may be
+   * invoked from native code if specified.
    *
-   * <p>
-   * This method will automatically commit the private transaction before
-   * returning. This ensures the <code>Dbi</code> is available in the
-   * <code>Env</code>.
+   * <p>This method will automatically commit the private transaction before returning. This ensures
+   * the <code>Dbi</code> is available in the <code>Env</code>.
    *
-   * @param name       name of the database (or null if no name is required)
+   * @param name name of the database (or null if no name is required)
    * @param comparator custom comparator callback (or null to use LMDB default)
-   * @param nativeCb   whether native code calls back to the Java comparator
-   * @param flags      to open the database with
+   * @param nativeCb whether native code calls back to the Java comparator
+   * @param flags to open the database with
    * @return a database that is ready to use
    */
-  public Dbi<T> openDbi(final byte[] name, final Comparator<T> comparator,
-                        final boolean nativeCb, final DbiFlags... flags) {
+  public Dbi<T> openDbi(
+      final byte[] name,
+      final Comparator<T> comparator,
+      final boolean nativeCb,
+      final DbiFlags... flags) {
     try (Txn<T> txn = readOnly ? txnRead() : txnWrite()) {
       final Dbi<T> dbi = openDbi(txn, name, comparator, nativeCb, flags);
       txn.commit(); // even RO Txns require a commit to retain Dbi in Env
@@ -356,38 +342,36 @@ public Dbi<T> openDbi(final byte[] name, final Comparator<T> comparator,
   /**
    * Open the {@link Dbi} using the passed {@link Txn}.
    *
-   * <p>
-   * The caller must commit the transaction after this method returns in order
-   * to retain the <code>Dbi</code> in the <code>Env</code>.
-   *
-   * <p>
-   * A {@link Comparator} may be provided when calling this method. Such
-   * comparator is primarily used by {@link CursorIterable} instances. A
-   * secondary (but uncommon) use of the comparator is to act as a callback from
-   * the native library if <code>nativeCb</code> is <code>true</code>. This is
-   * usually avoided due to the overhead of native code calling back into Java.
-   * It is instead highly recommended to set the correct {@link DbiFlags} to
-   * allow the native library to correctly order the intended keys.
-   *
-   * <p>
-   * A default comparator will be provided if <code>null</code> is passed as the
-   * comparator. If a custom comparator is provided, it must strictly match the
-   * lexicographical order of keys in the native LMDB database.
-   *
-   * <p>
-   * This method (and its overloaded convenience variants) must not be called
-   * from concurrent threads.
-   *
-   * @param txn        transaction to use (required; not closed)
-   * @param name       name of the database (or null if no name is required)
+   * <p>The caller must commit the transaction after this method returns in order to retain the
+   * <code>Dbi</code> in the <code>Env</code>.
+   *
+   * <p>A {@link Comparator} may be provided when calling this method. Such comparator is primarily
+   * used by {@link CursorIterable} instances. A secondary (but uncommon) use of the comparator is
+   * to act as a callback from the native library if <code>nativeCb</code> is <code>true</code>.
+   * This is usually avoided due to the overhead of native code calling back into Java. It is
+   * instead highly recommended to set the correct {@link DbiFlags} to allow the native library to
+   * correctly order the intended keys.
+   *
+   * <p>A default comparator will be provided if <code>null</code> is passed as the comparator. If a
+   * custom comparator is provided, it must strictly match the lexicographical order of keys in the
+   * native LMDB database.
+   *
+   * <p>This method (and its overloaded convenience variants) must not be called from concurrent
+   * threads.
+   *
+   * @param txn transaction to use (required; not closed)
+   * @param name name of the database (or null if no name is required)
    * @param comparator custom comparator callback (or null to use LMDB default)
-   * @param nativeCb   whether native code should call back to the comparator
-   * @param flags      to open the database with
+   * @param nativeCb whether native code should call back to the comparator
+   * @param flags to open the database with
    * @return a database that is ready to use
    */
-  public Dbi<T> openDbi(final Txn<T> txn, final byte[] name,
-                        final Comparator<T> comparator, final boolean nativeCb,
-                        final DbiFlags... flags) {
+  public Dbi<T> openDbi(
+      final Txn<T> txn,
+      final byte[] name,
+      final Comparator<T> comparator,
+      final boolean nativeCb,
+      final DbiFlags... flags) {
     return new Dbi<>(this, txn, name, comparator, nativeCb, proxy, flags);
   }
 
@@ -414,9 +398,8 @@ public Stat stat() {
   /**
    * Flushes the data buffers to disk.
    *
-   * @param force force a synchronous flush (otherwise if the environment has
-   *              the MDB_NOSYNC flag set the flushes will be omitted, and with
-   *              MDB_MAPASYNC they will be asynchronous)
+   * @param force force a synchronous flush (otherwise if the environment has the MDB_NOSYNC flag
+   *     set the flushes will be omitted, and with MDB_MAPASYNC they will be asynchronous)
    */
   public void sync(final boolean force) {
     if (closed) {
@@ -430,7 +413,7 @@ public void sync(final boolean force) {
    * Obtain a transaction with the requested parent and flags.
    *
    * @param parent parent transaction (may be null if no parent)
-   * @param flags  applicable flags (eg for a reusable, read-only transaction)
+   * @param flags applicable flags (eg for a reusable, read-only transaction)
    * @return a transaction (never null)
    */
   public Txn<T> txn(final Txn<T> parent, final TxnFlags... flags) {
@@ -491,46 +474,39 @@ private void validatePath(final File path) {
     validateDirectoryEmpty(path);
   }
 
-  
-  /* Check for stale entries in the reader lock table. */
+  /**
+   * Check for stale entries in the reader lock table.
+   *
+   * @return 0 on success, non-zero on failure
+   */
   public int readerCheck() {
     final IntByReference resultPtr = new IntByReference();
     checkRc(LIB.mdb_reader_check(ptr, resultPtr));
     return resultPtr.intValue();
   }
-  
-  
-  /**
-   * Object has already been closed and the operation is therefore prohibited.
-   */
+
+  /** Object has already been closed and the operation is therefore prohibited. */
   public static final class AlreadyClosedException extends LmdbException {
 
     private static final long serialVersionUID = 1L;
 
-    /**
-     * Creates a new instance.
-     */
+    /** Creates a new instance. */
     public AlreadyClosedException() {
       super("Environment has already been closed");
     }
   }
 
-  /**
-   * Object has already been opened and the operation is therefore prohibited.
-   */
+  /** Object has already been opened and the operation is therefore prohibited. */
   public static final class AlreadyOpenException extends LmdbException {
 
     private static final long serialVersionUID = 1L;
 
-    /**
-     * Creates a new instance.
-     */
+    /** Creates a new instance. */
     public AlreadyOpenException() {
       super("Environment has already been opened");
     }
   }
 
- 
   /**
    * Builder for configuring and opening Env.
    *
@@ -553,14 +529,12 @@ public static final class Builder<T> {
     /**
      * Opens the environment.
      *
-     * @param path  file system destination
-     * @param mode  Unix permissions to set on created files and semaphores
+     * @param path file system destination
+     * @param mode Unix permissions to set on created files and semaphores
      * @param flags the flags for this new environment
      * @return an environment ready for use
      */
-    @SuppressWarnings("PMD.AccessorClassGeneration")
-    public Env<T> open(final File path, final int mode,
-                       final EnvFlags... flags) {
+    public Env<T> open(final File path, final int mode, final EnvFlags... flags) {
       requireNonNull(path);
       if (opened) {
         throw new AlreadyOpenException();
@@ -587,16 +561,14 @@ public Env<T> open(final File path, final int mode,
     /**
      * Opens the environment with 0664 mode.
      *
-     * @param path  file system destination
+     * @param path file system destination
      * @param flags the flags for this new environment
      * @return an environment ready for use
      */
-    @SuppressWarnings("PMD.AvoidUsingOctalValues")
     public Env<T> open(final File path, final EnvFlags... flags) {
       return open(path, 0664, flags);
     }
 
-
     /**
      * Sets the map size.
      *
@@ -643,9 +615,7 @@ public Builder<T> setMaxReaders(final int readers) {
     }
   }
 
-  /**
-   * File is not a valid LMDB file.
-   */
+  /** File is not a valid LMDB file. */
   public static final class FileInvalidException extends LmdbNativeException {
 
     static final int MDB_INVALID = -30_793;
@@ -656,9 +626,7 @@ public static final class FileInvalidException extends LmdbNativeException {
     }
   }
 
-  /**
-   * The specified copy destination is invalid.
-   */
+  /** The specified copy destination is invalid. */
   public static final class InvalidCopyDestination extends LmdbException {
 
     private static final long serialVersionUID = 1L;
@@ -673,9 +641,7 @@ public InvalidCopyDestination(final String message) {
     }
   }
 
-  /**
-   * Environment mapsize reached.
-   */
+  /** Environment mapsize reached. */
   public static final class MapFullException extends LmdbNativeException {
 
     static final int MDB_MAP_FULL = -30_792;
@@ -686,9 +652,7 @@ public static final class MapFullException extends LmdbNativeException {
     }
   }
 
-  /**
-   * Environment maxreaders reached.
-   */
+  /** Environment maxreaders reached. */
   public static final class ReadersFullException extends LmdbNativeException {
 
     static final int MDB_READERS_FULL = -30_790;
@@ -699,9 +663,7 @@ public static final class ReadersFullException extends LmdbNativeException {
     }
   }
 
-  /**
-   * Environment version mismatch.
-   */
+  /** Environment version mismatch. */
   public static final class VersionMismatchException extends LmdbNativeException {
 
     static final int MDB_VERSION_MISMATCH = -30_794;
@@ -711,5 +673,4 @@ public static final class VersionMismatchException extends LmdbNativeException {
       super(MDB_VERSION_MISMATCH, "Environment version mismatch");
     }
   }
-
 }
diff --git a/src/main/java/org/lmdbjava/EnvFlags.java b/src/main/java/org/lmdbjava/EnvFlags.java
index ab54917a..4ce555a8 100644
--- a/src/main/java/org/lmdbjava/EnvFlags.java
+++ b/src/main/java/org/lmdbjava/EnvFlags.java
@@ -1,169 +1,136 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
-/**
- * Flags for use when opening the {@link Env}.
- */
+/** Flags for use when opening the {@link Env}. */
 public enum EnvFlags implements MaskedFlag {
 
   /**
    * Mmap at a fixed address (experimental).
    *
-   * <p>
-   * Use a fixed address for the mmap region. This flag must be specified when
-   * creating the environment, and is stored persistently in the environment. If
-   * successful, the memory map will always reside at the same virtual address
-   * and pointers used to reference data items in the database will be constant
-   * across multiple invocations. This option may not always work, depending on
-   * how the operating system has allocated memory to shared libraries and other
-   * uses. The feature is highly experimental.
+   * <p>Use a fixed address for the mmap region. This flag must be specified when creating the
+   * environment, and is stored persistently in the environment. If successful, the memory map will
+   * always reside at the same virtual address and pointers used to reference data items in the
+   * database will be constant across multiple invocations. This option may not always work,
+   * depending on how the operating system has allocated memory to shared libraries and other uses.
+   * The feature is highly experimental.
    */
   MDB_FIXEDMAP(0x01),
   /**
    * No environment directory.
    *
-   * <p>
-   * By default, LMDB creates its environment in a directory whose pathname is
-   * given in path, and creates its data and lock files under that directory.
-   * With this option, path is used as-is for the database main data file. The
-   * database lock file is the path with "-lock" appended.
+   * <p>By default, LMDB creates its environment in a directory whose pathname is given in path, and
+   * creates its data and lock files under that directory. With this option, path is used as-is for
+   * the database main data file. The database lock file is the path with "-lock" appended.
    */
   MDB_NOSUBDIR(0x4000),
   /**
    * Open the environment in read-only mode.
    *
-   * <p>
-   * No write operations will be allowed. LMDB will still modify the lock file -
-   * except on read-only filesystems, where LMDB does not use locks.
+   * <p>No write operations will be allowed. LMDB will still modify the lock file - except on
+   * read-only filesystems, where LMDB does not use locks.
    */
   MDB_RDONLY_ENV(0x2_0000),
   /**
    * Use a writeable memory map unless {@link #MDB_RDONLY_ENV} is set.
    *
-   * <p>
-   * This is faster and uses fewer mallocs, but loses protection from
-   * application bugs like wild pointer writes and other bad updates into the
-   * database. Incompatible with nested transactions. Do not mix processes with
-   * and without {@link #MDB_WRITEMAP} on the same environment. This can defeat
-   * durability ({@link Env#sync(boolean)} etc).
+   * <p>This is faster and uses fewer mallocs, but loses protection from application bugs like wild
+   * pointer writes and other bad updates into the database. Incompatible with nested transactions.
+   * Do not mix processes with and without {@link #MDB_WRITEMAP} on the same environment. This can
+   * defeat durability ({@link Env#sync(boolean)} etc).
    */
   MDB_WRITEMAP(0x8_0000),
   /**
    * Don't fsync metapage after commit.
    *
-   * <p>
-   * Flush system buffers to disk only once per transaction, omit the metadata
-   * flush. Defer that until the system flushes files to disk, or next
-   * non-{@link #MDB_RDONLY_ENV} commit or {@link Env#sync(boolean)}. This
-   * optimization* maintains database integrity, but a system crash may undo the
-   * last* committed transaction. I.e. it preserves the ACI (atomicity,
-   * consistency, isolation) but not D (durability) database property.
+   * <p>Flush system buffers to disk only once per transaction, omit the metadata flush. Defer that
+   * until the system flushes files to disk, or next non-{@link #MDB_RDONLY_ENV} commit or {@link
+   * Env#sync(boolean)}. This optimization* maintains database integrity, but a system crash may
+   * undo the last* committed transaction. I.e. it preserves the ACI (atomicity, consistency,
+   * isolation) but not D (durability) database property.
    */
   MDB_NOMETASYNC(0x4_0000),
   /**
    * Don't fsync after commit.
    *
-   * <p>
-   * Don't flush system buffers to disk when committing a transaction. This
-   * optimization means a system crash can corrupt the database or lose the last
-   * transactions if buffers are not yet flushed to disk. The risk is governed
-   * by how often the system flushes dirty buffers to disk and how often
-   * {@link Env#sync(boolean)} is called. However, if the filesystem preserves
-   * write order and the {@link #MDB_WRITEMAP} flag is not used, transactions
-   * exhibit ACI (atomicity, consistency, isolation) properties and only lose D
-   * (durability). I.e. database integrity is maintained, but a system crash may
-   * undo the final transactions. Note that
-   * ({@link #MDB_NOSYNC} | {@link #MDB_WRITEMAP}) leaves the system with no
-   * hint for when to write transactions to disk, unless
-   * {@link Env#sync(boolean)} is called.
-   * ({@link #MDB_MAPASYNC} | {@link #MDB_WRITEMAP}) may be preferable.
+   * <p>Don't flush system buffers to disk when committing a transaction. This optimization means a
+   * system crash can corrupt the database or lose the last transactions if buffers are not yet
+   * flushed to disk. The risk is governed by how often the system flushes dirty buffers to disk and
+   * how often {@link Env#sync(boolean)} is called. However, if the filesystem preserves write order
+   * and the {@link #MDB_WRITEMAP} flag is not used, transactions exhibit ACI (atomicity,
+   * consistency, isolation) properties and only lose D (durability). I.e. database integrity is
+   * maintained, but a system crash may undo the final transactions. Note that ({@link #MDB_NOSYNC}
+   * | {@link #MDB_WRITEMAP}) leaves the system with no hint for when to write transactions to disk,
+   * unless {@link Env#sync(boolean)} is called. ({@link #MDB_MAPASYNC} | {@link #MDB_WRITEMAP}) may
+   * be preferable.
    */
   MDB_NOSYNC(0x1_0000),
   /**
    * Use asynchronous msync when {@link #MDB_WRITEMAP} is used.
    *
-   * <p>
-   * When using {@link #MDB_WRITEMAP}, use asynchronous flushes to disk.
-   * As with {@link #MDB_NOSYNC}, a system crash can then corrupt the database
-   * or lose the last transactions. Calling {@link Env#sync(boolean)} ensures
-   * on-disk database integrity until next commit.
+   * <p>When using {@link #MDB_WRITEMAP}, use asynchronous flushes to disk. As with {@link
+   * #MDB_NOSYNC}, a system crash can then corrupt the database or lose the last transactions.
+   * Calling {@link Env#sync(boolean)} ensures on-disk database integrity until next commit.
    */
   MDB_MAPASYNC(0x10_0000),
   /**
    * Tie reader locktable slots to {@link Txn} objects instead of to threads.
    *
-   * <p>
-   * Don't use Thread-Local Storage. Tie reader locktable slots to {@link Txn}
-   * objects instead of to threads. I.e. {@link Txn#reset()} keeps the slot
-   * reseved for the {@link Txn} object. A thread may use parallel read-only
-   * transactions. A read-only transaction may span threads if the user
-   * synchronizes its use. Applications that multiplex many user threads over
-   * individual OS threads need this option. Such an application must also
-   * serialize the write transactions in an OS thread, since LMDB's write
-   * locking is unaware of the user threads.
+   * <p>Don't use Thread-Local Storage. Tie reader locktable slots to {@link Txn} objects instead of
+   * to threads. I.e. {@link Txn#reset()} keeps the slot reseved for the {@link Txn} object. A
+   * thread may use parallel read-only transactions. A read-only transaction may span threads if the
+   * user synchronizes its use. Applications that multiplex many user threads over individual OS
+   * threads need this option. Such an application must also serialize the write transactions in an
+   * OS thread, since LMDB's write locking is unaware of the user threads.
    */
   MDB_NOTLS(0x20_0000),
   /**
    * Don't do any locking, caller must manage their own locks.
    *
-   * <p>
-   * Don't do any locking. If concurrent access is anticipated, the caller must
-   * manage all concurrency itself. For proper operation the caller must enforce
-   * single-writer semantics, and must ensure that no readers are using old
-   * transactions while a writer is active. The simplest approach is to use an
-   * exclusive lock so that no readers may be active at all when a writer
+   * <p>Don't do any locking. If concurrent access is anticipated, the caller must manage all
+   * concurrency itself. For proper operation the caller must enforce single-writer semantics, and
+   * must ensure that no readers are using old transactions while a writer is active. The simplest
+   * approach is to use an exclusive lock so that no readers may be active at all when a writer
    * begins.
    */
   MDB_NOLOCK(0x40_0000),
   /**
    * Don't do readahead (no effect on Windows).
    *
-   * <p>
-   * Turn off readahead. Most operating systems perform readahead on read
-   * requests by default. This option turns it off if the OS supports it.
-   * Turning it off may help random read performance when the DB is larger than
-   * RAM and system RAM is full. The option is not implemented on Windows.
+   * <p>Turn off readahead. Most operating systems perform readahead on read requests by default.
+   * This option turns it off if the OS supports it. Turning it off may help random read performance
+   * when the DB is larger than RAM and system RAM is full. The option is not implemented on
+   * Windows.
    */
   MDB_NORDAHEAD(0x80_0000),
   /**
    * Don't initialize malloc'd memory before writing to datafile.
    *
-   * <p>
-   * Don't initialize malloc'd memory before writing to unused spaces in the
-   * data file. By default, memory for pages written to the data file is
-   * obtained using malloc. While these pages may be reused in subsequent
-   * transactions, freshly malloc'd pages will be initialized to zeroes before
-   * use. This avoids persisting leftover data from other code (that used the
-   * heap and subsequently freed the memory) into the data file. Note that many
-   * other system libraries may allocate and free memory from the heap for
-   * arbitrary uses. E.g., stdio may use the heap for file I/O buffers. This
-   * initialization step has a modest performance cost so some applications may
-   * want to disable it using this flag. This option can be a problem for
-   * applications which handle sensitive data like passwords, and it makes
-   * memory checkers like Valgrind noisy. This flag is not needed with
-   * {@link #MDB_WRITEMAP}, which writes directly to the mmap instead of using
-   * malloc for pages. The initialization is also skipped if
-   * {@link PutFlags#MDB_RESERVE} is used; the caller is expected to overwrite
-   * all of the memory that was reserved in that case.
+   * <p>Don't initialize malloc'd memory before writing to unused spaces in the data file. By
+   * default, memory for pages written to the data file is obtained using malloc. While these pages
+   * may be reused in subsequent transactions, freshly malloc'd pages will be initialized to zeroes
+   * before use. This avoids persisting leftover data from other code (that used the heap and
+   * subsequently freed the memory) into the data file. Note that many other system libraries may
+   * allocate and free memory from the heap for arbitrary uses. E.g., stdio may use the heap for
+   * file I/O buffers. This initialization step has a modest performance cost so some applications
+   * may want to disable it using this flag. This option can be a problem for applications which
+   * handle sensitive data like passwords, and it makes memory checkers like Valgrind noisy. This
+   * flag is not needed with {@link #MDB_WRITEMAP}, which writes directly to the mmap instead of
+   * using malloc for pages. The initialization is also skipped if {@link PutFlags#MDB_RESERVE} is
+   * used; the caller is expected to overwrite all of the memory that was reserved in that case.
    */
   MDB_NOMEMINIT(0x100_0000);
 
@@ -177,5 +144,4 @@ public enum EnvFlags implements MaskedFlag {
   public int getMask() {
     return mask;
   }
-
 }
diff --git a/src/main/java/org/lmdbjava/EnvInfo.java b/src/main/java/org/lmdbjava/EnvInfo.java
index a1ae62ba..71169d90 100644
--- a/src/main/java/org/lmdbjava/EnvInfo.java
+++ b/src/main/java/org/lmdbjava/EnvInfo.java
@@ -1,63 +1,48 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
-/**
- * Environment information, as returned by {@link Env#info()}.
- */
+/** Environment information, as returned by {@link Env#info()}. */
 public final class EnvInfo {
 
-  /**
-   * ID of the last used page.
-   */
+  /** ID of the last used page. */
   public final long lastPageNumber;
 
-  /**
-   * ID of the last committed transaction.
-   */
+  /** ID of the last committed transaction. */
   public final long lastTransactionId;
 
-  /**
-   * Address of map, if fixed.
-   */
+  /** Address of map, if fixed. */
   public final long mapAddress;
 
-  /**
-   * Size of the data memory map.
-   */
+  /** Size of the data memory map. */
   public final long mapSize;
 
-  /**
-   * Max reader slots in the environment.
-   */
+  /** Max reader slots in the environment. */
   public final int maxReaders;
 
-  /**
-   * Max reader slots used in the environment.
-   */
+  /** Max reader slots used in the environment. */
   public final int numReaders;
 
-  EnvInfo(final long mapAddress, final long mapSize, final long lastPageNumber,
-          final long lastTransactionId, final int maxReaders,
-          final int numReaders) {
+  EnvInfo(
+      final long mapAddress,
+      final long mapSize,
+      final long lastPageNumber,
+      final long lastTransactionId,
+      final int maxReaders,
+      final int numReaders) {
     this.mapAddress = mapAddress;
     this.mapSize = mapSize;
     this.lastPageNumber = lastPageNumber;
@@ -68,10 +53,19 @@ public final class EnvInfo {
 
   @Override
   public String toString() {
-    return "EnvInfo{" + "lastPageNumber=" + lastPageNumber
-               + ", lastTransactionId=" + lastTransactionId + ", mapAddress="
-               + mapAddress + ", mapSize=" + mapSize + ", maxReaders="
-               + maxReaders + ", numReaders=" + numReaders + '}';
+    return "EnvInfo{"
+        + "lastPageNumber="
+        + lastPageNumber
+        + ", lastTransactionId="
+        + lastTransactionId
+        + ", mapAddress="
+        + mapAddress
+        + ", mapSize="
+        + mapSize
+        + ", maxReaders="
+        + maxReaders
+        + ", numReaders="
+        + numReaders
+        + '}';
   }
-
 }
diff --git a/src/main/java/org/lmdbjava/GetOp.java b/src/main/java/org/lmdbjava/GetOp.java
index 9d36c204..666f692c 100644
--- a/src/main/java/org/lmdbjava/GetOp.java
+++ b/src/main/java/org/lmdbjava/GetOp.java
@@ -1,45 +1,32 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
 /**
- * Flags for use when performing a
- * {@link Cursor#get(java.lang.Object, org.lmdbjava.GetOp)}.
+ * Flags for use when performing a {@link Cursor#get(java.lang.Object, org.lmdbjava.GetOp)}.
  *
- * <p>
- * Unlike most other LMDB enums, this enum is not bit masked.
+ * <p>Unlike most other LMDB enums, this enum is not bit masked.
  */
 public enum GetOp {
 
-  /**
-   * Position at specified key.
-   */
+  /** Position at specified key. */
   MDB_SET(15),
-  /**
-   * Position at specified key, return key + data.
-   */
+  /** Position at specified key, return key + data. */
   MDB_SET_KEY(16),
-  /**
-   * Position at first key greater than or equal to specified key.
-   */
+  /** Position at first key greater than or equal to specified key. */
   MDB_SET_RANGE(17);
 
   private final int code;
@@ -56,5 +43,4 @@ public enum GetOp {
   public int getCode() {
     return code;
   }
-
 }
diff --git a/src/main/java/org/lmdbjava/KeyRange.java b/src/main/java/org/lmdbjava/KeyRange.java
index d47c444c..553346e6 100644
--- a/src/main/java/org/lmdbjava/KeyRange.java
+++ b/src/main/java/org/lmdbjava/KeyRange.java
@@ -1,23 +1,18 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
 import static java.util.Objects.requireNonNull;
@@ -27,8 +22,7 @@
 /**
  * Limits the range and direction of keys to iterate.
  *
- * <p>
- * Immutable once created (although the buffers themselves may not be).
+ * <p>Immutable once created (although the buffers themselves may not be).
  *
  * @param <T> buffer type
  */
@@ -43,13 +37,12 @@ public final class KeyRange<T> {
   /**
    * Construct a key range.
    *
-   * <p>
-   * End user code may find it more expressive to use one of the static methods
-   * provided on this class.
+   * <p>End user code may find it more expressive to use one of the static methods provided on this
+   * class.
    *
-   * @param type  key type
+   * @param type key type
    * @param start start key (required if applicable for the passed range type)
-   * @param stop  stop key (required if applicable for the passed range type)
+   * @param stop stop key (required if applicable for the passed range type)
    */
   public KeyRange(final KeyRangeType type, final T start, final T stop) {
     requireNonNull(type, "Key range type is required");
@@ -87,7 +80,7 @@ public static <T> KeyRange<T> allBackward() {
   /**
    * Create a {@link KeyRangeType#FORWARD_AT_LEAST} range.
    *
-   * @param <T>   buffer type
+   * @param <T> buffer type
    * @param start start key (required)
    * @return a key range (never null)
    */
@@ -98,7 +91,7 @@ public static <T> KeyRange<T> atLeast(final T start) {
   /**
    * Create a {@link KeyRangeType#BACKWARD_AT_LEAST} range.
    *
-   * @param <T>   buffer type
+   * @param <T> buffer type
    * @param start start key (required)
    * @return a key range (never null)
    */
@@ -109,7 +102,7 @@ public static <T> KeyRange<T> atLeastBackward(final T start) {
   /**
    * Create a {@link KeyRangeType#FORWARD_AT_MOST} range.
    *
-   * @param <T>  buffer type
+   * @param <T> buffer type
    * @param stop stop key (required)
    * @return a key range (never null)
    */
@@ -120,7 +113,7 @@ public static <T> KeyRange<T> atMost(final T stop) {
   /**
    * Create a {@link KeyRangeType#BACKWARD_AT_MOST} range.
    *
-   * @param <T>  buffer type
+   * @param <T> buffer type
    * @param stop stop key (required)
    * @return a key range (never null)
    */
@@ -131,9 +124,9 @@ public static <T> KeyRange<T> atMostBackward(final T stop) {
   /**
    * Create a {@link KeyRangeType#FORWARD_CLOSED} range.
    *
-   * @param <T>   buffer type
+   * @param <T> buffer type
    * @param start start key (required)
-   * @param stop  stop key (required)
+   * @param stop stop key (required)
    * @return a key range (never null)
    */
   public static <T> KeyRange<T> closed(final T start, final T stop) {
@@ -143,9 +136,9 @@ public static <T> KeyRange<T> closed(final T start, final T stop) {
   /**
    * Create a {@link KeyRangeType#BACKWARD_CLOSED} range.
    *
-   * @param <T>   buffer type
+   * @param <T> buffer type
    * @param start start key (required)
-   * @param stop  stop key (required)
+   * @param stop stop key (required)
    * @return a key range (never null)
    */
   public static <T> KeyRange<T> closedBackward(final T start, final T stop) {
@@ -155,9 +148,9 @@ public static <T> KeyRange<T> closedBackward(final T start, final T stop) {
   /**
    * Create a {@link KeyRangeType#FORWARD_CLOSED_OPEN} range.
    *
-   * @param <T>   buffer type
+   * @param <T> buffer type
    * @param start start key (required)
-   * @param stop  stop key (required)
+   * @param stop stop key (required)
    * @return a key range (never null)
    */
   public static <T> KeyRange<T> closedOpen(final T start, final T stop) {
@@ -167,9 +160,9 @@ public static <T> KeyRange<T> closedOpen(final T start, final T stop) {
   /**
    * Create a {@link KeyRangeType#BACKWARD_CLOSED_OPEN} range.
    *
-   * @param <T>   buffer type
+   * @param <T> buffer type
    * @param start start key (required)
-   * @param stop  stop key (required)
+   * @param stop stop key (required)
    * @return a key range (never null)
    */
   public static <T> KeyRange<T> closedOpenBackward(final T start, final T stop) {
@@ -179,7 +172,7 @@ public static <T> KeyRange<T> closedOpenBackward(final T start, final T stop) {
   /**
    * Create a {@link KeyRangeType#FORWARD_GREATER_THAN} range.
    *
-   * @param <T>   buffer type
+   * @param <T> buffer type
    * @param start start key (required)
    * @return a key range (never null)
    */
@@ -190,7 +183,7 @@ public static <T> KeyRange<T> greaterThan(final T start) {
   /**
    * Create a {@link KeyRangeType#BACKWARD_GREATER_THAN} range.
    *
-   * @param <T>   buffer type
+   * @param <T> buffer type
    * @param start start key (required)
    * @return a key range (never null)
    */
@@ -201,7 +194,7 @@ public static <T> KeyRange<T> greaterThanBackward(final T start) {
   /**
    * Create a {@link KeyRangeType#FORWARD_LESS_THAN} range.
    *
-   * @param <T>  buffer type
+   * @param <T> buffer type
    * @param stop stop key (required)
    * @return a key range (never null)
    */
@@ -212,7 +205,7 @@ public static <T> KeyRange<T> lessThan(final T stop) {
   /**
    * Create a {@link KeyRangeType#BACKWARD_LESS_THAN} range.
    *
-   * @param <T>  buffer type
+   * @param <T> buffer type
    * @param stop stop key (required)
    * @return a key range (never null)
    */
@@ -223,9 +216,9 @@ public static <T> KeyRange<T> lessThanBackward(final T stop) {
   /**
    * Create a {@link KeyRangeType#FORWARD_OPEN} range.
    *
-   * @param <T>   buffer type
+   * @param <T> buffer type
    * @param start start key (required)
-   * @param stop  stop key (required)
+   * @param stop stop key (required)
    * @return a key range (never null)
    */
   public static <T> KeyRange<T> open(final T start, final T stop) {
@@ -235,9 +228,9 @@ public static <T> KeyRange<T> open(final T start, final T stop) {
   /**
    * Create a {@link KeyRangeType#BACKWARD_OPEN} range.
    *
-   * @param <T>   buffer type
+   * @param <T> buffer type
    * @param start start key (required)
-   * @param stop  stop key (required)
+   * @param stop stop key (required)
    * @return a key range (never null)
    */
   public static <T> KeyRange<T> openBackward(final T start, final T stop) {
@@ -247,9 +240,9 @@ public static <T> KeyRange<T> openBackward(final T start, final T stop) {
   /**
    * Create a {@link KeyRangeType#FORWARD_OPEN_CLOSED} range.
    *
-   * @param <T>   buffer type
+   * @param <T> buffer type
    * @param start start key (required)
-   * @param stop  stop key (required)
+   * @param stop stop key (required)
    * @return a key range (never null)
    */
   public static <T> KeyRange<T> openClosed(final T start, final T stop) {
@@ -259,9 +252,9 @@ public static <T> KeyRange<T> openClosed(final T start, final T stop) {
   /**
    * Create a {@link KeyRangeType#BACKWARD_OPEN_CLOSED} range.
    *
-   * @param <T>   buffer type
+   * @param <T> buffer type
    * @param start start key (required)
-   * @param stop  stop key (required)
+   * @param stop stop key (required)
    * @return a key range (never null)
    */
   public static <T> KeyRange<T> openClosedBackward(final T start, final T stop) {
@@ -294,5 +287,4 @@ public T getStop() {
   public KeyRangeType getType() {
     return type;
   }
-
 }
diff --git a/src/main/java/org/lmdbjava/KeyRangeType.java b/src/main/java/org/lmdbjava/KeyRangeType.java
index 267e45c8..ad67286d 100644
--- a/src/main/java/org/lmdbjava/KeyRangeType.java
+++ b/src/main/java/org/lmdbjava/KeyRangeType.java
@@ -1,23 +1,18 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
 import static java.util.Objects.requireNonNull;
@@ -36,241 +31,195 @@
 /**
  * Key range type.
  *
- * <p>
- * The terminology used in this class is adapted from Google Guava's ranges.
- * Refer to the <a href="https://github.com/google/guava/wiki/RangesExplained">
- * Ranges Explained</a> wiki page for more information. LmddJava prepends either
- * "FORWARD" or "BACKWARD" to denote the iterator order.
+ * <p>The terminology used in this class is adapted from Google Guava's ranges. Refer to the <a
+ * href="https://github.com/google/guava/wiki/RangesExplained">Ranges Explained</a> wiki page for
+ * more information. LmddJava prepends either "FORWARD" or "BACKWARD" to denote the iterator order.
  *
- * <p>
- * In the examples below, it is assumed the table has keys 2, 4, 6 and 8.
+ * <p>In the examples below, it is assumed the table has keys 2, 4, 6 and 8.
  */
-@SuppressWarnings("PMD.CyclomaticComplexity")
 public enum KeyRangeType {
 
   /**
    * Starting on the first key and iterate forward until no keys remain.
    *
-   * <p>
-   * The "start" and "stop" values are ignored.
+   * <p>The "start" and "stop" values are ignored.
    *
-   * <p>
-   * In our example, the returned keys would be 2, 4, 6 and 8.
+   * <p>In our example, the returned keys would be 2, 4, 6 and 8.
    */
   FORWARD_ALL(true, false, false),
   /**
-   * Start on the passed key (or the first key immediately after it) and
-   * iterate forward until no keys remain.
+   * Start on the passed key (or the first key immediately after it) and iterate forward until no
+   * keys remain.
    *
-   * <p>
-   * The "start" value is required. The "stop" value is ignored.
+   * <p>The "start" value is required. The "stop" value is ignored.
    *
-   * <p>
-   * In our example and with a passed search key of 5, the returned keys would
-   * be 6 and 8. With a passed key of 6, the returned keys would be 6 and 8.
+   * <p>In our example and with a passed search key of 5, the returned keys would be 6 and 8. With a
+   * passed key of 6, the returned keys would be 6 and 8.
    */
   FORWARD_AT_LEAST(true, true, false),
   /**
-   * Start on the first key and iterate forward until a key equal to it (or the
-   * first key immediately after it) is reached.
+   * Start on the first key and iterate forward until a key equal to it (or the first key
+   * immediately after it) is reached.
    *
-   * <p>
-   * The "stop" value is required. The "start" value is ignored.
+   * <p>The "stop" value is required. The "start" value is ignored.
    *
-   * <p>
-   * In our example and with a passed search key of 5, the returned keys would
-   * be 2 and 4. With a passed key of 6, the returned keys would be 2, 4 and 6.
+   * <p>In our example and with a passed search key of 5, the returned keys would be 2 and 4. With a
+   * passed key of 6, the returned keys would be 2, 4 and 6.
    */
   FORWARD_AT_MOST(true, false, true),
   /**
-   * Iterate forward between the passed keys, matching on the first keys
-   * directly equal to the passed key (or immediately following it in the case
-   * of the "start" key, or immediately preceding it in the case of the "stop"
-   * key).
+   * Iterate forward between the passed keys, matching on the first keys directly equal to the
+   * passed key (or immediately following it in the case of the "start" key, or immediately
+   * preceding it in the case of the "stop" key).
    *
-   * <p>
-   * The "start" and "stop" values are both required.
+   * <p>The "start" and "stop" values are both required.
    *
-   * <p>
-   * In our example and with a passed search range of 3 - 7, the returned keys
-   * would be 4 and 6. With a range of 2 - 6, the keys would be 2, 4 and 6.
+   * <p>In our example and with a passed search range of 3 - 7, the returned keys would be 4 and 6.
+   * With a range of 2 - 6, the keys would be 2, 4 and 6.
    */
   FORWARD_CLOSED(true, true, true),
   /**
-   * Iterate forward between the passed keys, matching on the first keys
-   * directly equal to the passed key (or immediately following it in the case
-   * of the "start" key, or immediately preceding it in the case of the "stop"
-   * key). Do not return the "stop" key.
+   * Iterate forward between the passed keys, matching on the first keys directly equal to the
+   * passed key (or immediately following it in the case of the "start" key, or immediately
+   * preceding it in the case of the "stop" key). Do not return the "stop" key.
    *
-   * <p>
-   * The "start" and "stop" values are both required.
+   * <p>The "start" and "stop" values are both required.
    *
-   * <p>
-   * In our example and with a passed search range of 3 - 8, the returned keys
-   * would be 4 and 6. With a range of 2 - 6, the keys would be 2 and 4.
+   * <p>In our example and with a passed search range of 3 - 8, the returned keys would be 4 and 6.
+   * With a range of 2 - 6, the keys would be 2 and 4.
    */
   FORWARD_CLOSED_OPEN(true, true, true),
   /**
-   * Start after the passed key (but not equal to it) and iterate forward until
-   * no keys remain.
+   * Start after the passed key (but not equal to it) and iterate forward until no keys remain.
    *
-   * <p>
-   * The "start" value is required. The "stop" value is ignored.
+   * <p>The "start" value is required. The "stop" value is ignored.
    *
-   * <p>
-   * In our example and with a passed search key of 4, the returned keys would
-   * be 6 and 8. With a passed key of 3, the returned keys would be 4, 6 and 8.
+   * <p>In our example and with a passed search key of 4, the returned keys would be 6 and 8. With a
+   * passed key of 3, the returned keys would be 4, 6 and 8.
    */
   FORWARD_GREATER_THAN(true, true, false),
   /**
-   * Start on the first key and iterate forward until a key the passed key has
-   * been reached (but do not return that key).
+   * Start on the first key and iterate forward until a key the passed key has been reached (but do
+   * not return that key).
    *
-   * <p>
-   * The "stop" value is required. The "start" value is ignored.
+   * <p>The "stop" value is required. The "start" value is ignored.
    *
-   * <p>
-   * In our example and with a passed search key of 5, the returned keys would
-   * be 2 and 4. With a passed key of 8, the returned keys would be 2, 4 and 6.
+   * <p>In our example and with a passed search key of 5, the returned keys would be 2 and 4. With a
+   * passed key of 8, the returned keys would be 2, 4 and 6.
    */
   FORWARD_LESS_THAN(true, false, true),
   /**
    * Iterate forward between the passed keys but not equal to either of them.
    *
-   * <p>
-   * The "start" and "stop" values are both required.
+   * <p>The "start" and "stop" values are both required.
    *
-   * <p>
-   * In our example and with a passed search range of 3 - 7, the returned keys
-   * would be 4 and 6. With a range of 2 - 8, the key would be 4 and 6.
+   * <p>In our example and with a passed search range of 3 - 7, the returned keys would be 4 and 6.
+   * With a range of 2 - 8, the key would be 4 and 6.
    */
   FORWARD_OPEN(true, true, true),
   /**
-   * Iterate forward between the passed keys. Do not return the "start" key, but
-   * do return the "stop" key.
+   * Iterate forward between the passed keys. Do not return the "start" key, but do return the
+   * "stop" key.
    *
-   * <p>
-   * The "start" and "stop" values are both required.
+   * <p>The "start" and "stop" values are both required.
    *
-   * <p>
-   * In our example and with a passed search range of 3 - 8, the returned keys
-   * would be 4, 6 and 8. With a range of 2 - 6, the keys would be 4 and 6.
+   * <p>In our example and with a passed search range of 3 - 8, the returned keys would be 4, 6 and
+   * 8. With a range of 2 - 6, the keys would be 4 and 6.
    */
   FORWARD_OPEN_CLOSED(true, true, true),
   /**
    * Start on the last key and iterate backward until no keys remain.
    *
-   * <p>
-   * The "start" and "stop" values are ignored.
+   * <p>The "start" and "stop" values are ignored.
    *
-   * <p>
-   * In our example, the returned keys would be 8, 6, 4 and 2.
+   * <p>In our example, the returned keys would be 8, 6, 4 and 2.
    */
   BACKWARD_ALL(false, false, false),
   /**
-   * Start on the passed key (or the first key immediately preceding it) and
-   * iterate backward until no keys remain.
+   * Start on the passed key (or the first key immediately preceding it) and iterate backward until
+   * no keys remain.
    *
-   * <p>
-   * The "start" value is required. The "stop" value is ignored.
+   * <p>The "start" value is required. The "stop" value is ignored.
    *
-   * <p>
-   * In our example and with a passed search key of 5, the returned keys would
-   * be 4 and 2. With a passed key of 6, the returned keys would be 6, 4 and 2.
-   * With a passed key of 9, the returned keys would be 8, 6, 4 and 2.
+   * <p>In our example and with a passed search key of 5, the returned keys would be 4 and 2. With a
+   * passed key of 6, the returned keys would be 6, 4 and 2. With a passed key of 9, the returned
+   * keys would be 8, 6, 4 and 2.
    */
   BACKWARD_AT_LEAST(false, true, false),
   /**
-   * Start on the last key and iterate backward until a key equal to it (or the
-   * first key immediately preceding it it) is reached.
+   * Start on the last key and iterate backward until a key equal to it (or the first key
+   * immediately preceding it it) is reached.
    *
-   * <p>
-   * The "stop" value is required. The "start" value is ignored.
+   * <p>The "stop" value is required. The "start" value is ignored.
    *
-   * <p>
-   * In our example and with a passed search key of 5, the returned keys would
-   * be 8 and 6. With a passed key of 6, the returned keys would be 8 and 6.
+   * <p>In our example and with a passed search key of 5, the returned keys would be 8 and 6. With a
+   * passed key of 6, the returned keys would be 8 and 6.
    */
   BACKWARD_AT_MOST(false, false, true),
   /**
-   * Iterate backward between the passed keys, matching on the first keys
-   * directly equal to the passed key (or immediately preceding it in the case
-   * of the "start" key, or immediately following it in the case of the "stop"
-   * key).
-   *
-   * <p>
-   * The "start" and "stop" values are both required.
-   *
-   * <p>
-   * In our example and with a passed search range of 7 - 3, the returned keys
-   * would be 6 and 4. With a range of 6 - 2, the keys would be 6, 4 and 2.
-   * With a range of 9 - 3, the returned keys would be 8, 6 and 4.
+   * Iterate backward between the passed keys, matching on the first keys directly equal to the
+   * passed key (or immediately preceding it in the case of the "start" key, or immediately
+   * following it in the case of the "stop" key).
+   *
+   * <p>The "start" and "stop" values are both required.
+   *
+   * <p>In our example and with a passed search range of 7 - 3, the returned keys would be 6 and 4.
+   * With a range of 6 - 2, the keys would be 6, 4 and 2. With a range of 9 - 3, the returned keys
+   * would be 8, 6 and 4.
    */
   BACKWARD_CLOSED(false, true, true),
   /**
-   * Iterate backward between the passed keys, matching on the first keys
-   * directly equal to the passed key (or immediately preceding it in the case
-   * of the "start" key, or immediately following it in the case of the "stop"
-   * key). Do not return the "stop" key.
-   *
-   * <p>
-   * The "start" and "stop" values are both required.
-   *
-   * <p>
-   * In our example and with a passed search range of 8 - 3, the returned keys
-   * would be 8, 6 and 4. With a range of 7 - 2, the keys would be 6 and 4.
-   * With a range of 9 - 3, the keys would be 8, 6 and 4.
+   * Iterate backward between the passed keys, matching on the first keys directly equal to the
+   * passed key (or immediately preceding it in the case of the "start" key, or immediately
+   * following it in the case of the "stop" key). Do not return the "stop" key.
+   *
+   * <p>The "start" and "stop" values are both required.
+   *
+   * <p>In our example and with a passed search range of 8 - 3, the returned keys would be 8, 6 and
+   * 4. With a range of 7 - 2, the keys would be 6 and 4. With a range of 9 - 3, the keys would be
+   * 8, 6 and 4.
    */
   BACKWARD_CLOSED_OPEN(false, true, true),
   /**
-   * Start immediate prior to the passed key (but not equal to it) and iterate
-   * backward until no keys remain.
+   * Start immediate prior to the passed key (but not equal to it) and iterate backward until no
+   * keys remain.
    *
-   * <p>
-   * The "start" value is required. The "stop" value is ignored.
+   * <p>The "start" value is required. The "stop" value is ignored.
    *
-   * <p>
-   * In our example and with a passed search key of 6, the returned keys would
-   * be 4 and 2. With a passed key of 7, the returned keys would be 6, 4 and 2.
-   * With a passed key of 9, the returned keys would be 8, 6, 4 and 2.
+   * <p>In our example and with a passed search key of 6, the returned keys would be 4 and 2. With a
+   * passed key of 7, the returned keys would be 6, 4 and 2. With a passed key of 9, the returned
+   * keys would be 8, 6, 4 and 2.
    */
   BACKWARD_GREATER_THAN(false, true, false),
   /**
-   * Start on the last key and iterate backward until the last key greater than
-   * the passed "stop" key is reached. Do not return the "stop" key.
+   * Start on the last key and iterate backward until the last key greater than the passed "stop"
+   * key is reached. Do not return the "stop" key.
    *
-   * <p>
-   * The "stop" value is required. The "start" value is ignored.
+   * <p>The "stop" value is required. The "start" value is ignored.
    *
-   * <p>
-   * In our example and with a passed search key of 5, the returned keys would
-   * be 8 and 6. With a passed key of 2, the returned keys would be 8, 6 and 4
+   * <p>In our example and with a passed search key of 5, the returned keys would be 8 and 6. With a
+   * passed key of 2, the returned keys would be 8, 6 and 4
    */
   BACKWARD_LESS_THAN(false, false, true),
   /**
-   * Iterate backward between the passed keys, but do not return the passed
-   * keys.
+   * Iterate backward between the passed keys, but do not return the passed keys.
    *
-   * <p>
-   * The "start" and "stop" values are both required.
+   * <p>The "start" and "stop" values are both required.
    *
-   * <p>
-   * In our example and with a passed search range of 7 - 2, the returned keys
-   * would be 6 and 4. With a range of 8 - 1, the keys would be 6, 4 and 2.
-   * With a range of 9 - 4, the keys would be 8 and 6.
+   * <p>In our example and with a passed search range of 7 - 2, the returned keys would be 6 and 4.
+   * With a range of 8 - 1, the keys would be 6, 4 and 2. With a range of 9 - 4, the keys would be 8
+   * and 6.
    */
   BACKWARD_OPEN(false, true, true),
   /**
-   * Iterate backward between the passed keys. Do not return the "start" key,
-   * but do return the "stop" key.
+   * Iterate backward between the passed keys. Do not return the "start" key, but do return the
+   * "stop" key.
    *
-   * <p>
-   * The "start" and "stop" values are both required.
+   * <p>The "start" and "stop" values are both required.
    *
-   * <p>
-   * In our example and with a passed search range of 7 - 2, the returned keys
-   * would be 6, 4 and 2. With a range of 8 - 4, the keys would be 6 and 4.
-   * With a range of 9 - 4, the keys would be 8, 6 and 4.
+   * <p>In our example and with a passed search range of 7 - 2, the returned keys would be 6, 4 and
+   * 2. With a range of 8 - 4, the keys would be 6 and 4. With a range of 9 - 4, the keys would be
+   * 8, 6 and 4.
    */
   BACKWARD_OPEN_CLOSED(false, true, true);
 
@@ -278,8 +227,10 @@ public enum KeyRangeType {
   private final boolean startKeyRequired;
   private final boolean stopKeyRequired;
 
-  KeyRangeType(final boolean directionForward, final boolean startKeyRequired,
-               final boolean stopKeyRequired) {
+  KeyRangeType(
+      final boolean directionForward,
+      final boolean startKeyRequired,
+      final boolean stopKeyRequired) {
     this.directionForward = directionForward;
     this.startKeyRequired = startKeyRequired;
     this.stopKeyRequired = stopKeyRequired;
@@ -315,9 +266,8 @@ public boolean isStopKeyRequired() {
   /**
    * Determine the iterator action to take when iterator first begins.
    *
-   * <p>
-   * The iterator will perform this action and present the resulting key to
-   * {@link #iteratorOp(java.util.Comparator, java.lang.Object)} for decision.
+   * <p>The iterator will perform this action and present the resulting key to {@link
+   * #iteratorOp(java.util.Comparator, java.lang.Object)} for decision.
    *
    * @return appropriate action in response to this buffer
    */
@@ -367,16 +317,16 @@ CursorOp initialOp() {
   /**
    * Determine the iterator's response to the presented key.
    *
-   * @param <T>    buffer type
-   * @param <C>    comparator for the buffers
-   * @param start  start buffer
-   * @param stop   stop buffer
+   * @param <T> buffer type
+   * @param <C> comparator for the buffers
+   * @param start start buffer
+   * @param stop stop buffer
    * @param buffer current key returned by LMDB (may be null)
-   * @param c      comparator (required)
+   * @param c comparator (required)
    * @return response to this key
    */
-  <T, C extends Comparator<T>> IteratorOp iteratorOp(final T start, final T stop,
-                                                     final T buffer, final C c) {
+  <T, C extends Comparator<T>> IteratorOp iteratorOp(
+      final T start, final T stop, final T buffer, final C c) {
     requireNonNull(c, "Comparator required");
     if (buffer == null) {
       return TERMINATE;
@@ -442,12 +392,11 @@ <T, C extends Comparator<T>> IteratorOp iteratorOp(final T start, final T stop,
   }
 
   /**
-   * Determine the iterator action to take when "next" is called or upon request
-   * of {@link #iteratorOp(java.util.Comparator, java.lang.Object)}.
+   * Determine the iterator action to take when "next" is called or upon request of {@link
+   * #iteratorOp(java.util.Comparator, java.lang.Object)}.
    *
-   * <p>
-   * The iterator will perform this action and present the resulting key to
-   * {@link #iteratorOp(java.util.Comparator, java.lang.Object)} for decision.
+   * <p>The iterator will perform this action and present the resulting key to {@link
+   * #iteratorOp(java.util.Comparator, java.lang.Object)} for decision.
    *
    * @return appropriate action for this key range type
    */
@@ -455,51 +404,29 @@ CursorOp nextOp() {
     return isDirectionForward() ? NEXT : PREV;
   }
 
-  /**
-   * Action now required with the iterator.
-   */
+  /** Action now required with the iterator. */
   enum IteratorOp {
-    /**
-     * Consider iterator completed.
-     */
+    /** Consider iterator completed. */
     TERMINATE,
-    /**
-     * Call {@link KeyRange#nextOp()} again and try again.
-     */
+    /** Call {@link KeyRange#nextOp()} again and try again. */
     CALL_NEXT_OP,
-    /**
-     * Return the key to the user.
-     */
+    /** Return the key to the user. */
     RELEASE
   }
 
-  /**
-   * Action now required with the cursor.
-   */
+  /** Action now required with the cursor. */
   enum CursorOp {
-    /**
-     * Move to first.
-     */
+    /** Move to first. */
     FIRST,
-    /**
-     * Move to last.
-     */
+    /** Move to last. */
     LAST,
-    /**
-     * Get "start" key with {@link GetOp#MDB_SET_RANGE}.
-     */
+    /** Get "start" key with {@link GetOp#MDB_SET_RANGE}. */
     GET_START_KEY,
-    /**
-     * Get "start" key with {@link GetOp#MDB_SET_RANGE}, fall back to LAST.
-     */
+    /** Get "start" key with {@link GetOp#MDB_SET_RANGE}, fall back to LAST. */
     GET_START_KEY_BACKWARD,
-    /**
-     * Move forward.
-     */
+    /** Move forward. */
     NEXT,
-    /**
-     * Move backward.
-     */
+    /** Move backward. */
     PREV
   }
 }
diff --git a/src/main/java/org/lmdbjava/KeyVal.java b/src/main/java/org/lmdbjava/KeyVal.java
index 12b9f9af..c6f2aae5 100644
--- a/src/main/java/org/lmdbjava/KeyVal.java
+++ b/src/main/java/org/lmdbjava/KeyVal.java
@@ -1,23 +1,18 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
 import static java.util.Objects.requireNonNull;
@@ -102,20 +97,19 @@ void valIn(final int size) {
   }
 
   /**
-   * Prepares an array suitable for presentation as the data argument to a
-   * <code>MDB_MULTIPLE</code> put.
+   * Prepares an array suitable for presentation as the data argument to a <code>MDB_MULTIPLE</code>
+   * put.
    *
-   * <p>
-   * The returned array is equivalent of two <code>MDB_val</code>s as follows:
+   * <p>The returned array is equivalent of two <code>MDB_val</code>s as follows:
    *
    * <ul>
-   * <li>ptrVal1.data = pointer to the data address of passed buffer</li>
-   * <li>ptrVal1.size = size of each individual data element</li>
-   * <li>ptrVal2.data = unused</li>
-   * <li>ptrVal2.size = number of data elements (as passed to this method)</li>
+   *   <li>ptrVal1.data = pointer to the data address of passed buffer
+   *   <li>ptrVal1.size = size of each individual data element
+   *   <li>ptrVal2.data = unused
+   *   <li>ptrVal2.size = number of data elements (as passed to this method)
    * </ul>
    *
-   * @param val      a user-provided buffer with data elements (required)
+   * @param val a user-provided buffer with data elements (required)
    * @param elements number of data elements the user has provided
    * @return a properly-prepared pointer to an array for the operation
    */
@@ -134,5 +128,4 @@ T valOut() {
     v = proxy.out(v, ptrVal, ptrValAddr);
     return v;
   }
-
 }
diff --git a/src/main/java/org/lmdbjava/Library.java b/src/main/java/org/lmdbjava/Library.java
index 22308600..ef9b9b35 100644
--- a/src/main/java/org/lmdbjava/Library.java
+++ b/src/main/java/org/lmdbjava/Library.java
@@ -1,23 +1,18 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
 import static java.io.File.createTempFile;
@@ -32,8 +27,6 @@
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.nio.file.Files;
-
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
 import jnr.ffi.Pointer;
 import jnr.ffi.Struct;
 import jnr.ffi.annotations.Delegate;
@@ -47,25 +40,23 @@
 /**
  * JNR-FFI interface to LMDB.
  *
- * <p>
- * For performance reasons pointers are used rather than structs.
+ * <p>For performance reasons pointers are used rather than structs.
  */
 final class Library {
 
   /**
-   * Java system property name that can be set to the path of an existing
-   * directory into which the LMDB system library will be extracted from the
-   * LmdbJava JAR. If unspecified the LMDB system library is extracted to the
-   * <code>java.io.tmpdir</code>. Ignored if the LMDB system library is not
-   * being extracted from the LmdbJava JAR (as would be the case if other
-   * system properties defined in <code>TargetName</code> have been set).
+   * Java system property name that can be set to the path of an existing directory into which the
+   * LMDB system library will be extracted from the LmdbJava JAR. If unspecified the LMDB system
+   * library is extracted to the <code>java.io.tmpdir</code>. Ignored if the LMDB system library is
+   * not being extracted from the LmdbJava JAR (as would be the case if other system properties
+   * defined in <code>TargetName</code> have been set).
    */
   public static final String LMDB_EXTRACT_DIR_PROP = "lmdbjava.extract.dir";
-  /**
-   * Indicates the directory where the LMDB system library will be extracted.
-   */
-  static final String EXTRACT_DIR = getProperty(LMDB_EXTRACT_DIR_PROP,
-                                                getProperty("java.io.tmpdir"));
+
+  /** Indicates the directory where the LMDB system library will be extracted. */
+  static final String EXTRACT_DIR =
+      getProperty(LMDB_EXTRACT_DIR_PROP, getProperty("java.io.tmpdir"));
+
   static final Lmdb LIB;
   static final jnr.ffi.Runtime RUNTIME;
 
@@ -82,10 +73,8 @@ final class Library {
     RUNTIME = getRuntime(LIB);
   }
 
-  private Library() {
-  }
+  private Library() {}
 
-  @SuppressFBWarnings("OBL_UNSATISFIED_OBLIGATION") // Spotbugs issue #432
   private static String extract(final String name) {
     final String suffix = name.substring(name.lastIndexOf('.'));
     final File file;
@@ -98,7 +87,7 @@ private static String extract(final String name) {
       file.deleteOnExit();
       final ClassLoader cl = currentThread().getContextClassLoader();
       try (InputStream in = cl.getResourceAsStream(name);
-           OutputStream out = Files.newOutputStream(file.toPath())) {
+          OutputStream out = Files.newOutputStream(file.toPath())) {
         requireNonNull(in, "Classpath resource not found");
         int bytes;
         final byte[] buffer = new byte[4_096];
@@ -112,11 +101,7 @@ private static String extract(final String name) {
     }
   }
 
-  /**
-   * Structure to wrap a native <code>MDB_envinfo</code>. Not for external use.
-   */
-  @SuppressWarnings({"checkstyle:TypeName", "checkstyle:VisibilityModifier",
-                     "checkstyle:MemberName"})
+  /** Structure to wrap a native <code>MDB_envinfo</code>. Not for external use. */
   public static final class MDB_envinfo extends Struct {
 
     public final Pointer f0_me_mapaddr;
@@ -137,11 +122,7 @@ public static final class MDB_envinfo extends Struct {
     }
   }
 
-  /**
-   * Structure to wrap a native <code>MDB_stat</code>. Not for external use.
-   */
-  @SuppressWarnings({"checkstyle:TypeName", "checkstyle:VisibilityModifier",
-                     "checkstyle:MemberName"})
+  /** Structure to wrap a native <code>MDB_stat</code>. Not for external use. */
   public static final class MDB_stat extends Struct {
 
     public final u_int32_t f0_ms_psize;
@@ -162,20 +143,14 @@ public static final class MDB_stat extends Struct {
     }
   }
 
-  /**
-   * Custom comparator callback used by <code>mdb_set_compare</code>.
-   */
+  /** Custom comparator callback used by <code>mdb_set_compare</code>. */
   public interface ComparatorCallback {
 
     @Delegate
     int compare(@In Pointer keyA, @In Pointer keyB);
-
   }
 
-  /**
-   * JNR API for MDB-defined C functions. Not for external use.
-   */
-  @SuppressWarnings("checkstyle:MethodName")
+  /** JNR API for MDB-defined C functions. Not for external use. */
   public interface Lmdb {
 
     void mdb_cursor_close(@In Pointer cursor);
@@ -184,27 +159,21 @@ public interface Lmdb {
 
     int mdb_cursor_del(@In Pointer cursor, int flags);
 
-    int mdb_cursor_get(@In Pointer cursor, Pointer k, @Out Pointer v,
-                       int cursorOp);
+    int mdb_cursor_get(@In Pointer cursor, Pointer k, @Out Pointer v, int cursorOp);
 
-    int mdb_cursor_open(@In Pointer txn, @In Pointer dbi,
-                        PointerByReference cursorPtr);
+    int mdb_cursor_open(@In Pointer txn, @In Pointer dbi, PointerByReference cursorPtr);
 
-    int mdb_cursor_put(@In Pointer cursor, @In Pointer key, @In Pointer data,
-                       int flags);
+    int mdb_cursor_put(@In Pointer cursor, @In Pointer key, @In Pointer data, int flags);
 
     int mdb_cursor_renew(@In Pointer txn, @In Pointer cursor);
 
     void mdb_dbi_close(@In Pointer env, @In Pointer dbi);
 
-    int mdb_dbi_flags(@In Pointer txn, @In Pointer dbi,
-                      @Out IntByReference flags);
+    int mdb_dbi_flags(@In Pointer txn, @In Pointer dbi, @Out IntByReference flags);
 
-    int mdb_dbi_open(@In Pointer txn, @In byte[] name, int flags,
-                     @In Pointer dbiPtr);
+    int mdb_dbi_open(@In Pointer txn, @In byte[] name, int flags, @In Pointer dbiPtr);
 
-    int mdb_del(@In Pointer txn, @In Pointer dbi, @In Pointer key,
-                @In Pointer data);
+    int mdb_del(@In Pointer txn, @In Pointer dbi, @In Pointer key, @In Pointer data);
 
     int mdb_drop(@In Pointer txn, @In Pointer dbi, int del);
 
@@ -240,12 +209,9 @@ int mdb_del(@In Pointer txn, @In Pointer dbi, @In Pointer key,
 
     int mdb_env_sync(@In Pointer env, int f);
 
-    int mdb_get(@In Pointer txn, @In Pointer dbi, @In Pointer key,
-                @Out Pointer data);
+    int mdb_get(@In Pointer txn, @In Pointer dbi, @In Pointer key, @Out Pointer data);
 
-    int mdb_put(@In Pointer txn, @In Pointer dbi, @In Pointer key,
-                @In Pointer data,
-                int flags);
+    int mdb_put(@In Pointer txn, @In Pointer dbi, @In Pointer key, @In Pointer data, int flags);
 
     int mdb_reader_check(@In Pointer env, @Out IntByReference dead);
 
@@ -257,8 +223,7 @@ int mdb_put(@In Pointer txn, @In Pointer dbi, @In Pointer key,
 
     void mdb_txn_abort(@In Pointer txn);
 
-    int mdb_txn_begin(@In Pointer env, @In Pointer parentTx, int flags,
-                      Pointer txPtr);
+    int mdb_txn_begin(@In Pointer env, @In Pointer parentTx, int flags, Pointer txPtr);
 
     int mdb_txn_commit(@In Pointer txn);
 
@@ -270,8 +235,6 @@ int mdb_txn_begin(@In Pointer env, @In Pointer parentTx, int flags,
 
     void mdb_txn_reset(@In Pointer txn);
 
-    Pointer mdb_version(IntByReference major, IntByReference minor,
-                        IntByReference patch);
-
+    Pointer mdb_version(IntByReference major, IntByReference minor, IntByReference patch);
   }
 }
diff --git a/src/main/java/org/lmdbjava/LmdbException.java b/src/main/java/org/lmdbjava/LmdbException.java
index b3aea56e..c2624f95 100644
--- a/src/main/java/org/lmdbjava/LmdbException.java
+++ b/src/main/java/org/lmdbjava/LmdbException.java
@@ -1,28 +1,21 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
-/**
- * Superclass for all LmdbJava custom exceptions.
- */
+/** Superclass for all LmdbJava custom exceptions. */
 public class LmdbException extends RuntimeException {
 
   private static final long serialVersionUID = 1L;
@@ -40,10 +33,9 @@ public LmdbException(final String message) {
    * Constructs an instance with the provided detailed message and cause.
    *
    * @param message the detail message
-   * @param cause   original cause
+   * @param cause original cause
    */
   public LmdbException(final String message, final Throwable cause) {
     super(message, cause);
   }
-
 }
diff --git a/src/main/java/org/lmdbjava/LmdbNativeException.java b/src/main/java/org/lmdbjava/LmdbNativeException.java
index 3f559806..5c094e77 100644
--- a/src/main/java/org/lmdbjava/LmdbNativeException.java
+++ b/src/main/java/org/lmdbjava/LmdbNativeException.java
@@ -1,44 +1,35 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
 import static java.lang.String.format;
 
-/**
- * Superclass for all exceptions that originate from a native C call.
- */
+/** Superclass for all exceptions that originate from a native C call. */
 public class LmdbNativeException extends LmdbException {
 
   private static final long serialVersionUID = 1L;
 
-  /**
-   * Result code returned by the LMDB C function.
-   */
+  /** Result code returned by the LMDB C function. */
   private final int rc;
 
   /**
    * Constructs an instance with the provided detailed message.
    *
    * @param msg the detail message.
-   * @param rc  the result code.
+   * @param rc the result code.
    */
   LmdbNativeException(final int rc, final String msg) {
     super(format(msg + " (%d)", rc));
@@ -54,9 +45,7 @@ public final int getResultCode() {
     return rc;
   }
 
-  /**
-   * Exception raised from a system constant table lookup.
-   */
+  /** Exception raised from a system constant table lookup. */
   public static final class ConstantDerivedException extends LmdbNativeException {
 
     private static final long serialVersionUID = 1L;
@@ -66,9 +55,7 @@ public static final class ConstantDerivedException extends LmdbNativeException {
     }
   }
 
-  /**
-   * Located page was wrong type.
-   */
+  /** Located page was wrong type. */
   public static final class PageCorruptedException extends LmdbNativeException {
 
     static final int MDB_CORRUPTED = -30_796;
@@ -79,9 +66,7 @@ public static final class PageCorruptedException extends LmdbNativeException {
     }
   }
 
-  /**
-   * Page has not enough space - internal error.
-   */
+  /** Page has not enough space - internal error. */
   public static final class PageFullException extends LmdbNativeException {
 
     static final int MDB_PAGE_FULL = -30_786;
@@ -92,37 +77,29 @@ public static final class PageFullException extends LmdbNativeException {
     }
   }
 
-  /**
-   * Requested page not found - this usually indicates corruption.
-   */
+  /** Requested page not found - this usually indicates corruption. */
   public static final class PageNotFoundException extends LmdbNativeException {
 
     static final int MDB_PAGE_NOTFOUND = -30_797;
     private static final long serialVersionUID = 1L;
 
     PageNotFoundException() {
-      super(MDB_PAGE_NOTFOUND,
-            "Requested page not found - this usually indicates corruption");
+      super(MDB_PAGE_NOTFOUND, "Requested page not found - this usually indicates corruption");
     }
   }
 
-  /**
-   * Update of meta page failed or environment had fatal error.
-   */
+  /** Update of meta page failed or environment had fatal error. */
   public static final class PanicException extends LmdbNativeException {
 
     static final int MDB_PANIC = -30_795;
     private static final long serialVersionUID = 1L;
 
     PanicException() {
-      super(MDB_PANIC,
-            "Update of meta page failed or environment had fatal error");
+      super(MDB_PANIC, "Update of meta page failed or environment had fatal error");
     }
   }
 
-  /**
-   * Too many TLS keys in use - Windows only.
-   */
+  /** Too many TLS keys in use - Windows only. */
   public static final class TlsFullException extends LmdbNativeException {
 
     static final int MDB_TLS_FULL = -30_789;
diff --git a/src/main/java/org/lmdbjava/MaskedFlag.java b/src/main/java/org/lmdbjava/MaskedFlag.java
index 242ca589..00556ecb 100644
--- a/src/main/java/org/lmdbjava/MaskedFlag.java
+++ b/src/main/java/org/lmdbjava/MaskedFlag.java
@@ -1,35 +1,28 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
+import static java.util.Objects.requireNonNull;
+
 import java.util.Arrays;
 import java.util.Objects;
 import java.util.function.Predicate;
 import java.util.stream.Stream;
 
-import static java.util.Objects.requireNonNull;
-
-/**
- * Indicates an enum that can provide integers for each of its values.
- */
+/** Indicates an enum that can provide integers for each of its values. */
 public interface MaskedFlag {
 
   /**
@@ -51,6 +44,7 @@ default boolean isPropagatedToLmdb() {
   /**
    * Fetch the integer mask for all presented flags.
    *
+   * @param <M> flag type
    * @param flags to mask (null or empty returns zero)
    * @return the integer mask for use in C
    */
@@ -62,6 +56,7 @@ static <M extends MaskedFlag> int mask(final M... flags) {
   /**
    * Fetch the integer mask for all presented flags.
    *
+   * @param <M> flag type
    * @param flags to mask (null or empty returns zero)
    * @return the integer mask for use in C
    */
@@ -72,7 +67,9 @@ static <M extends MaskedFlag> int mask(final Stream<M> flags) {
   /**
    * Fetch the integer mask for the presented flags.
    *
-   * @param onlyPropagatedToLmdb if to include only the flags which are also propagate to the C code or all of them
+   * @param <M> flag type
+   * @param onlyPropagatedToLmdb if to include only the flags which are also propagate to the C code
+   *     or all of them
    * @param flags to mask (null or empty returns zero)
    * @return the integer mask for use in C
    */
@@ -84,21 +81,30 @@ static <M extends MaskedFlag> int mask(final boolean onlyPropagatedToLmdb, final
   /**
    * Fetch the integer mask for all presented flags.
    *
-   * @param onlyPropagatedToLmdb if to include only the flags which are also propagate to the C code or all of them
+   * @param <M> flag type
+   * @param onlyPropagatedToLmdb if to include only the flags which are also propagate to the C code
+   *     or all of them
+   * @param flags to mask
    * @return the integer mask for use in C
    */
-  static <M extends MaskedFlag> int mask(final boolean onlyPropagatedToLmdb, final Stream<M> flags) {
+  static <M extends MaskedFlag> int mask(
+      final boolean onlyPropagatedToLmdb, final Stream<M> flags) {
     final Predicate<M> filter = onlyPropagatedToLmdb ? MaskedFlag::isPropagatedToLmdb : f -> true;
 
-    return flags == null ? 0 : flags.filter(Objects::nonNull).filter(filter).map(M::getMask).reduce(0, (f1, f2) -> f1 | f2);
+    return flags == null
+        ? 0
+        : flags
+            .filter(Objects::nonNull)
+            .filter(filter)
+            .map(M::getMask)
+            .reduce(0, (f1, f2) -> f1 | f2);
   }
 
   /**
    * Indicates whether the passed flag has the relevant masked flag high.
    *
-   * @param flags to evaluate (usually produced by
-   *              {@link #mask(org.lmdbjava.MaskedFlag...)}
-   * @param test  the flag being sought (required)
+   * @param flags to evaluate (usually produced by {@link #mask(org.lmdbjava.MaskedFlag...)}
+   * @param test the flag being sought (required)
    * @return true if set.
    */
   static boolean isSet(final int flags, final MaskedFlag test) {
diff --git a/src/main/java/org/lmdbjava/Meta.java b/src/main/java/org/lmdbjava/Meta.java
index 6f392701..9f51e1af 100644
--- a/src/main/java/org/lmdbjava/Meta.java
+++ b/src/main/java/org/lmdbjava/Meta.java
@@ -1,46 +1,36 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
 import static org.lmdbjava.Library.LIB;
 
 import jnr.ffi.byref.IntByReference;
 
-/**
- * LMDB metadata functions.
- */
+/** LMDB metadata functions. */
 public final class Meta {
 
-  private Meta() {
-  }
+  private Meta() {}
 
   /**
    * Fetches the LMDB error code description.
    *
-   * <p>
-   * End users should not need this method, as LmdbJava converts all LMDB
-   * exceptions into a typed Java exception that incorporates the error code.
-   * However it is provided here for verification and troubleshooting (eg if the
-   * user wishes to see the original LMDB description of the error code, or
-   * there is a newer library version etc).
+   * <p>End users should not need this method, as LmdbJava converts all LMDB exceptions into a typed
+   * Java exception that incorporates the error code. However it is provided here for verification
+   * and troubleshooting (eg if the user wishes to see the original LMDB description of the error
+   * code, or there is a newer library version etc).
    *
    * @param err the error code returned from LMDB
    * @return the description
@@ -61,28 +51,19 @@ public static Version version() {
 
     LIB.mdb_version(major, minor, patch);
 
-    return new Version(major.intValue(), minor.intValue(), patch.
-                       intValue());
+    return new Version(major.intValue(), minor.intValue(), patch.intValue());
   }
 
-  /**
-   * Immutable return value from {@link #version()}.
-   */
+  /** Immutable return value from {@link #version()}. */
   public static final class Version {
 
-    /**
-     * LMDC native library major version number.
-     */
+    /** LMDC native library major version number. */
     public final int major;
 
-    /**
-     * LMDC native library patch version number.
-     */
+    /** LMDC native library patch version number. */
     public final int minor;
 
-    /**
-     * LMDC native library patch version number.
-     */
+    /** LMDC native library patch version number. */
     public final int patch;
 
     Version(final int major, final int minor, final int patch) {
@@ -91,5 +72,4 @@ public static final class Version {
       this.patch = patch;
     }
   }
-
 }
diff --git a/src/main/java/org/lmdbjava/PutFlags.java b/src/main/java/org/lmdbjava/PutFlags.java
index 48bc243b..809103de 100644
--- a/src/main/java/org/lmdbjava/PutFlags.java
+++ b/src/main/java/org/lmdbjava/PutFlags.java
@@ -1,33 +1,24 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
-/**
- * Flags for use when performing a "put".
- */
+/** Flags for use when performing a "put". */
 public enum PutFlags implements MaskedFlag {
 
-  /**
-   * For put: Don't write if the key already exists.
-   */
+  /** For put: Don't write if the key already exists. */
   MDB_NOOVERWRITE(0x10),
   /**
    * Only for #MDB_DUPSORT<br>
@@ -35,26 +26,17 @@ public enum PutFlags implements MaskedFlag {
    * For mdb_cursor_del: remove all duplicate data items.
    */
   MDB_NODUPDATA(0x20),
-  /**
-   * For mdb_cursor_put: overwrite the current key/data pair.
-   */
+  /** For mdb_cursor_put: overwrite the current key/data pair. */
   MDB_CURRENT(0x40),
   /**
-   * For put: Just reserve space for data, don't copy it. Return a pointer to
-   * the reserved space.
+   * For put: Just reserve space for data, don't copy it. Return a pointer to the reserved space.
    */
   MDB_RESERVE(0x1_0000),
-  /**
-   * Data is being appended, don't split full pages.
-   */
+  /** Data is being appended, don't split full pages. */
   MDB_APPEND(0x2_0000),
-  /**
-   * Duplicate data is being appended, don't split full pages.
-   */
+  /** Duplicate data is being appended, don't split full pages. */
   MDB_APPENDDUP(0x4_0000),
-  /**
-   * Store multiple data items in one call. Only for #MDB_DUPFIXED.
-   */
+  /** Store multiple data items in one call. Only for #MDB_DUPFIXED. */
   MDB_MULTIPLE(0x8_0000);
 
   private final int mask;
@@ -67,5 +49,4 @@ public enum PutFlags implements MaskedFlag {
   public int getMask() {
     return mask;
   }
-
 }
diff --git a/src/main/java/org/lmdbjava/ReferenceUtil.java b/src/main/java/org/lmdbjava/ReferenceUtil.java
index 36bf9247..2b9f211e 100644
--- a/src/main/java/org/lmdbjava/ReferenceUtil.java
+++ b/src/main/java/org/lmdbjava/ReferenceUtil.java
@@ -1,62 +1,44 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-
-/**
- * Supports creating strong references in manner compatible with Java 8.
- */
+/** Supports creating strong references in manner compatible with Java 8. */
 public final class ReferenceUtil {
 
-  private ReferenceUtil() {
-  }
+  private ReferenceUtil() {}
 
   /**
-   * Ensures that the object referenced by the given reference remains
-   * <em>strongly reachable</em>, regardless of any prior actions of the program
-   * that might otherwise cause the object to become unreachable. Thus, the
-   * referenced object is not reclaimable by garbage collection at least until
-   * after the invocation of this method.
+   * Ensures that the object referenced by the given reference remains <em>strongly reachable</em>,
+   * regardless of any prior actions of the program that might otherwise cause the object to become
+   * unreachable. Thus, the referenced object is not reclaimable by garbage collection at least
+   * until after the invocation of this method.
    *
-   * <p>
-   * Recent versions of the JDK have a nasty habit of prematurely deciding
-   * objects are unreachable (eg
-   * <a href="https://tinyurl.com/so26642153">StackOverflow question
-   * 26642153</a>.
+   * <p>Recent versions of the JDK have a nasty habit of prematurely deciding objects are
+   * unreachable (eg <a href="https://tinyurl.com/so26642153">StackOverflow question 26642153</a>.
    *
-   * <p>
-   * <code>java.lang.ref.Reference.reachabilityFence</code> offers a solution to
-   * this problem, but it was only introduced in Java 9. LmdbJava presently
-   * supports Java 8 and therefore this method provides an alternative.
+   * <p><code>java.lang.ref.Reference.reachabilityFence</code> offers a solution to this problem,
+   * but it was only introduced in Java 9. LmdbJava presently supports Java 8 and therefore this
+   * method provides an alternative.
    *
-   * <p>
-   * This method is always implemented as a synchronization on {@code ref}.
-   * <b>It is the caller's responsibility to ensure that this synchronization
-   * will not cause deadlock.</b>
+   * <p>This method is always implemented as a synchronization on {@code ref}. <b>It is the caller's
+   * responsibility to ensure that this synchronization will not cause deadlock.</b>
    *
    * @param ref the reference (null is acceptable but has no effect)
    * @see <a href="https://github.com/netty/netty/pull/8410">Netty PR 8410</a>
    */
-  @SuppressFBWarnings({"ESync_EMPTY_SYNC", "UC_USELESS_VOID_METHOD"})
   public static void reachabilityFence0(final Object ref) {
     if (ref != null) {
       synchronized (ref) {
diff --git a/src/main/java/org/lmdbjava/ResultCodeMapper.java b/src/main/java/org/lmdbjava/ResultCodeMapper.java
index 809628ac..1e4d841e 100644
--- a/src/main/java/org/lmdbjava/ResultCodeMapper.java
+++ b/src/main/java/org/lmdbjava/ResultCodeMapper.java
@@ -1,23 +1,18 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
 import static jnr.constants.ConstantSet.getConstantSet;
@@ -31,16 +26,12 @@
 /**
  * Maps a LMDB C result code to the equivalent Java exception.
  *
- * <p>
- * The immutable nature of all LMDB exceptions means the mapper internally
- * maintains a table of them.
+ * <p>The immutable nature of all LMDB exceptions means the mapper internally maintains a table of
+ * them.
  */
-@SuppressWarnings("PMD.CyclomaticComplexity")
 final class ResultCodeMapper {
 
-  /**
-   * Successful result.
-   */
+  /** Successful result. */
   static final int MDB_SUCCESS = 0;
 
   private static final ConstantSet CONSTANTS;
@@ -50,8 +41,7 @@ final class ResultCodeMapper {
     CONSTANTS = getConstantSet(POSIX_ERR_NO);
   }
 
-  private ResultCodeMapper() {
-  }
+  private ResultCodeMapper() {}
 
   /**
    * Checks the result code and raises an exception is not {@link #MDB_SUCCESS}.
@@ -113,5 +103,4 @@ static void checkRc(final int rc) {
     final String msg = constant.name() + " " + constant.toString();
     throw new LmdbNativeException.ConstantDerivedException(rc, msg);
   }
-
 }
diff --git a/src/main/java/org/lmdbjava/SeekOp.java b/src/main/java/org/lmdbjava/SeekOp.java
index ed5fb47c..162aef49 100644
--- a/src/main/java/org/lmdbjava/SeekOp.java
+++ b/src/main/java/org/lmdbjava/SeekOp.java
@@ -1,100 +1,62 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
 /**
  * Flags for use when performing a {@link Cursor#seek(org.lmdbjava.SeekOp)}.
  *
- * <p>
- * Unlike most other LMDB enums, this enum is not bit masked.
+ * <p>Unlike most other LMDB enums, this enum is not bit masked.
  */
 public enum SeekOp {
 
-  /**
-   * Position at first key/data item.
-   */
+  /** Position at first key/data item. */
   MDB_FIRST(0),
-  /**
-   * Position at first data item of current key. Only for
-   * {@link DbiFlags#MDB_DUPSORT}.
-   */
+  /** Position at first data item of current key. Only for {@link DbiFlags#MDB_DUPSORT}. */
   MDB_FIRST_DUP(1),
-  /**
-   * Position at key/data pair. Only for {@link DbiFlags#MDB_DUPSORT}.
-   */
+  /** Position at key/data pair. Only for {@link DbiFlags#MDB_DUPSORT}. */
   MDB_GET_BOTH(2),
-  /**
-   * position at key, nearest data. Only for {@link DbiFlags#MDB_DUPSORT}.
-   */
+  /** position at key, nearest data. Only for {@link DbiFlags#MDB_DUPSORT}. */
   MDB_GET_BOTH_RANGE(3),
-  /**
-   * Return key/data at current cursor position.
-   */
+  /** Return key/data at current cursor position. */
   MDB_GET_CURRENT(4),
   /**
-   * Return key and up to a page of duplicate data items from current cursor
-   * position. Move cursor to prepare for {@link #MDB_NEXT_MULTIPLE}. Only for
-   * {@link DbiFlags#MDB_DUPSORT}.
+   * Return key and up to a page of duplicate data items from current cursor position. Move cursor
+   * to prepare for {@link #MDB_NEXT_MULTIPLE}. Only for {@link DbiFlags#MDB_DUPSORT}.
    */
   MDB_GET_MULTIPLE(5),
-  /**
-   * Position at last key/data item.
-   */
+  /** Position at last key/data item. */
   MDB_LAST(6),
-  /**
-   * Position at last data item of current key. Only for
-   * {@link DbiFlags#MDB_DUPSORT}.
-   */
+  /** Position at last data item of current key. Only for {@link DbiFlags#MDB_DUPSORT}. */
   MDB_LAST_DUP(7),
-  /**
-   * Position at next data item.
-   */
+  /** Position at next data item. */
   MDB_NEXT(8),
-  /**
-   * Position at next data item of current key. Only for
-   * {@link DbiFlags#MDB_DUPSORT}.
-   */
+  /** Position at next data item of current key. Only for {@link DbiFlags#MDB_DUPSORT}. */
   MDB_NEXT_DUP(9),
   /**
-   * Return key and up to a page of duplicate data items from next cursor
-   * position. Move cursor to prepare for {@link #MDB_NEXT_MULTIPLE}. Only for
-   * {@link DbiFlags#MDB_DUPSORT}.
+   * Return key and up to a page of duplicate data items from next cursor position. Move cursor to
+   * prepare for {@link #MDB_NEXT_MULTIPLE}. Only for {@link DbiFlags#MDB_DUPSORT}.
    */
   MDB_NEXT_MULTIPLE(10),
-  /**
-   * Position at first data item of next key.
-   */
+  /** Position at first data item of next key. */
   MDB_NEXT_NODUP(11),
-  /**
-   * Position at previous data item.
-   */
+  /** Position at previous data item. */
   MDB_PREV(12),
-  /**
-   * Position at previous data item of current key.
-   * {@link DbiFlags#MDB_DUPSORT}.
-   */
+  /** Position at previous data item of current key. {@link DbiFlags#MDB_DUPSORT}. */
   MDB_PREV_DUP(13),
-  /**
-   * Position at last data item of previous key.
-   */
+  /** Position at last data item of previous key. */
   MDB_PREV_NODUP(14);
 
   private final int code;
@@ -111,5 +73,4 @@ public enum SeekOp {
   public int getCode() {
     return code;
   }
-
 }
diff --git a/src/main/java/org/lmdbjava/Stat.java b/src/main/java/org/lmdbjava/Stat.java
index 42b344fb..d4995324 100644
--- a/src/main/java/org/lmdbjava/Stat.java
+++ b/src/main/java/org/lmdbjava/Stat.java
@@ -1,64 +1,48 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
-/**
- * Statistics, as returned by {@link Env#stat()} and
- * {@link Dbi#stat(org.lmdbjava.Txn)}.
- */
+/** Statistics, as returned by {@link Env#stat()} and {@link Dbi#stat(org.lmdbjava.Txn)}. */
 public final class Stat {
 
-  /**
-   * Number of internal (non-leaf) pages.
-   */
+  /** Number of internal (non-leaf) pages. */
   public final long branchPages;
 
-  /**
-   * Depth (height) of the B-tree.
-   */
+  /** Depth (height) of the B-tree. */
   public final int depth;
 
-  /**
-   * Number of data items.
-   */
+  /** Number of data items. */
   public final long entries;
 
-  /**
-   * Number of leaf pages.
-   */
+  /** Number of leaf pages. */
   public final long leafPages;
 
-  /**
-   * Number of overflow pages.
-   */
+  /** Number of overflow pages. */
   public final long overflowPages;
 
-  /**
-   * Size of a database page. This is currently the same for all databases.
-   */
+  /** Size of a database page. This is currently the same for all databases. */
   public final int pageSize;
 
-  Stat(final int pageSize, final int depth, final long branchPages,
-       final long leafPages,
-       final long overflowPages, final long entries) {
+  Stat(
+      final int pageSize,
+      final int depth,
+      final long branchPages,
+      final long leafPages,
+      final long overflowPages,
+      final long entries) {
     this.pageSize = pageSize;
     this.depth = depth;
     this.branchPages = branchPages;
@@ -69,10 +53,19 @@ public final class Stat {
 
   @Override
   public String toString() {
-    return "Stat{" + "branchPages=" + branchPages + ", depth=" + depth
-               + ", entries=" + entries + ", leafPages=" + leafPages
-               + ", overflowPages=" + overflowPages + ", pageSize=" + pageSize
-               + '}';
+    return "Stat{"
+        + "branchPages="
+        + branchPages
+        + ", depth="
+        + depth
+        + ", entries="
+        + entries
+        + ", leafPages="
+        + leafPages
+        + ", overflowPages="
+        + overflowPages
+        + ", pageSize="
+        + pageSize
+        + '}';
   }
-
 }
diff --git a/src/main/java/org/lmdbjava/TargetName.java b/src/main/java/org/lmdbjava/TargetName.java
index 446ea5b5..023ecba5 100644
--- a/src/main/java/org/lmdbjava/TargetName.java
+++ b/src/main/java/org/lmdbjava/TargetName.java
@@ -1,23 +1,18 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
 import static java.lang.System.getProperty;
@@ -26,44 +21,41 @@
 /**
  * Determines the name of the target LMDB native library.
  *
- * <p>
- * Users will typically use an LMDB native library that is embedded within the
- * LmdbJava JAR. Embedded libraries are built by a Zig cross-compilation step as
- * part of the release process. The naming convention reflects the Zig target
- * name plus a common filename extension. This simplifies support for future Zig
- * targets (eg with different toolchains etc).
+ * <p>Users will typically use an LMDB native library that is embedded within the LmdbJava JAR.
+ * Embedded libraries are built by a Zig cross-compilation step as part of the release process. The
+ * naming convention reflects the Zig target name plus a common filename extension. This simplifies
+ * support for future Zig targets (eg with different toolchains etc).
  *
- * <p>
- * Users can set two system properties to override the automatic resolution of
- * an embedded library. Setting {@link #LMDB_NATIVE_LIB_PROP} will force use of
- * that external LMDB library. Setting {@link #LMDB_EMBEDDED_LIB_PROP} will
- * force use of that embedded LMDB library. If both are set, the former property
- * will take precedence. Most users do not need to set either property.
+ * <p>Users can set two system properties to override the automatic resolution of an embedded
+ * library. Setting {@link #LMDB_NATIVE_LIB_PROP} will force use of that external LMDB library.
+ * Setting {@link #LMDB_EMBEDDED_LIB_PROP} will force use of that embedded LMDB library. If both are
+ * set, the former property will take precedence. Most users do not need to set either property.
  */
 public final class TargetName {
 
   /**
-   * True if the resolved native filename is an external file (conversely false
-   * indicates the file should be considered a classpath resource).
+   * True if the resolved native filename is an external file (conversely false indicates the file
+   * should be considered a classpath resource).
    */
   public static final boolean IS_EXTERNAL;
 
   /**
-   * Java system property name that can be set to override the embedded library
-   * that will be used. This is likely to be required if automatic resolution
-   * fails but the user still prefers to use an LmdbJava-bundled library. This
-   * path must include the classpath prefix (usually <code>org/lmdbjava</code>).
+   * Java system property name that can be set to override the embedded library that will be used.
+   * This is likely to be required if automatic resolution fails but the user still prefers to use
+   * an LmdbJava-bundled library. This path must include the classpath prefix (usually <code>
+   * org/lmdbjava</code>).
    */
   public static final String LMDB_EMBEDDED_LIB_PROP = "lmdbjava.embedded.lib";
+
   /**
-   * Java system property name that can be set to provide a custom path to an
-   * external LMDB system library.
+   * Java system property name that can be set to provide a custom path to an external LMDB system
+   * library.
    */
   public static final String LMDB_NATIVE_LIB_PROP = "lmdbjava.native.lib";
-  /**
-   * Resolved target native filename or fully-qualified classpath location.
-   */
+
+  /** Resolved target native filename or fully-qualified classpath location. */
   public static final String RESOLVED_FILENAME;
+
   private static final String ARCH = getProperty("os.arch");
   private static final String EMBED = getProperty(LMDB_EMBEDDED_LIB_PROP);
   private static final String EXTERNAL = getProperty(LMDB_NATIVE_LIB_PROP);
@@ -74,9 +66,14 @@ public final class TargetName {
     RESOLVED_FILENAME = resolveFilename(EXTERNAL, EMBED, ARCH, OS);
   }
 
-  private TargetName() {
-  }
+  private TargetName() {}
 
+  /**
+   * Resolves the filename extension of the bundled LMDB library for a given operating system.
+   *
+   * @param os typically the <code>os.name</code> system property
+   * @return extension of the LMDB system library bundled with LmdbJava
+   */
   public static String resolveExtension(final String os) {
     return check(os, "Windows") ? "dll" : "so";
   }
@@ -85,8 +82,8 @@ static boolean isExternal(final String external) {
     return external != null && !external.isEmpty();
   }
 
-  static String resolveFilename(final String external, final String embed,
-                                final String arch, final String os) {
+  static String resolveFilename(
+      final String external, final String embed, final String arch, final String os) {
     if (external != null && !external.isEmpty()) {
       return external;
     }
@@ -96,20 +93,25 @@ static String resolveFilename(final String external, final String embed,
     }
 
     final String pkg = TargetName.class.getPackage().getName().replace('.', '/');
-    return pkg + "/" + resolveArch(arch) + "-" + resolveOs(os) + "-"
-               + resolveToolchain(os) + "." + resolveExtension(os);
+    return pkg
+        + "/"
+        + resolveArch(arch)
+        + "-"
+        + resolveOs(os)
+        + "-"
+        + resolveToolchain(os)
+        + "."
+        + resolveExtension(os);
   }
 
   /**
-   * Case insensitively checks whether the passed string starts with any of the
-   * candidate strings.
+   * Case insensitively checks whether the passed string starts with any of the candidate strings.
    *
-   * @param string     the string being checked
+   * @param string the string being checked
    * @param candidates one or more candidate strings
    * @return true if the string starts with any of the candidates
    */
-  private static boolean check(final String string,
-                               final String... candidates) {
+  private static boolean check(final String string, final String... candidates) {
     if (string == null) {
       return false;
     }
@@ -124,10 +126,17 @@ private static boolean check(final String string,
   }
 
   private static String err(final String reason) {
-    return reason + " (please set system property " + LMDB_NATIVE_LIB_PROP
-               + " to the path of an external LMDB native library or property "
-               + LMDB_EMBEDDED_LIB_PROP + " to the name of an LmdbJava embedded"
-               + " library; os.arch='" + ARCH + "' os.name='" + OS + "')";
+    return reason
+        + " (please set system property "
+        + LMDB_NATIVE_LIB_PROP
+        + " to the path of an external LMDB native library or property "
+        + LMDB_EMBEDDED_LIB_PROP
+        + " to the name of an LmdbJava embedded"
+        + " library; os.arch='"
+        + ARCH
+        + "' os.name='"
+        + OS
+        + "')";
   }
 
   private static String resolveArch(final String arch) {
@@ -153,5 +162,4 @@ private static String resolveOs(final String os) {
   private static String resolveToolchain(final String os) {
     return check(os, "Mac OS") ? "none" : "gnu";
   }
-
 }
diff --git a/src/main/java/org/lmdbjava/Txn.java b/src/main/java/org/lmdbjava/Txn.java
index 3092c7c4..05e8ce06 100644
--- a/src/main/java/org/lmdbjava/Txn.java
+++ b/src/main/java/org/lmdbjava/Txn.java
@@ -1,27 +1,20 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
-import jnr.ffi.Pointer;
-
 import static jnr.ffi.Memory.allocateDirect;
 import static jnr.ffi.NativeType.ADDRESS;
 import static org.lmdbjava.Env.SHOULD_CHECK;
@@ -36,6 +29,8 @@
 import static org.lmdbjava.Txn.State.RESET;
 import static org.lmdbjava.TxnFlags.MDB_RDONLY_TXN;
 
+import jnr.ffi.Pointer;
+
 /**
  * LMDB transaction.
  *
@@ -51,8 +46,7 @@ public final class Txn<T> implements AutoCloseable {
   private final Env<T> env;
   private State state;
 
-  Txn(final Env<T> env, final Txn<T> parent, final BufferProxy<T> proxy,
-      final TxnFlags... flags) {
+  Txn(final Env<T> env, final Txn<T> parent, final BufferProxy<T> proxy, final TxnFlags... flags) {
     this.proxy = proxy;
     this.keyVal = proxy.keyVal();
     final int flagsMask = mask(true, flags);
@@ -73,9 +67,7 @@ public final class Txn<T> implements AutoCloseable {
     state = READY;
   }
 
-  /**
-   * Aborts this transaction.
-   */
+  /** Aborts this transaction. */
   public void abort() {
     if (SHOULD_CHECK) {
       env.checkNotClosed();
@@ -88,10 +80,8 @@ public void abort() {
   /**
    * Closes this transaction by aborting if not already committed.
    *
-   * <p>
-   * Closing the transaction will invoke
-   * {@link BufferProxy#deallocate(java.lang.Object)} for each read-only buffer
-   * (ie the key and value).
+   * <p>Closing the transaction will invoke {@link BufferProxy#deallocate(java.lang.Object)} for
+   * each read-only buffer (ie the key and value).
    */
   @Override
   public void close() {
@@ -108,9 +98,7 @@ public void close() {
     state = RELEASED;
   }
 
-  /**
-   * Commits this transaction.
-   */
+  /** Commits this transaction. */
   public void commit() {
     if (SHOULD_CHECK) {
       env.checkNotClosed();
@@ -151,10 +139,10 @@ public boolean isReadOnly() {
   }
 
   /**
-   * Fetch the buffer which holds a read-only view of the LMDI allocated memory.
-   * Any use of this buffer must comply with the standard LMDB C "mdb_get"
-   * contract (ie do not modify, do not attempt to release the memory, do not
-   * use once the transaction or cursor closes, do not use after a write etc).
+   * Fetch the buffer which holds a read-only view of the LMDI allocated memory. Any use of this
+   * buffer must comply with the standard LMDB C "mdb_get" contract (ie do not modify, do not
+   * attempt to release the memory, do not use once the transaction or cursor closes, do not use
+   * after a write etc).
    *
    * @return the key buffer (never null)
    */
@@ -162,9 +150,7 @@ public T key() {
     return keyVal.key();
   }
 
-  /**
-   * Renews a read-only transaction previously released by {@link #reset()}.
-   */
+  /** Renews a read-only transaction previously released by {@link #reset()}. */
   public void renew() {
     if (SHOULD_CHECK) {
       env.checkNotClosed();
@@ -178,8 +164,8 @@ public void renew() {
   }
 
   /**
-   * Aborts this read-only transaction and resets the transaction handle so it
-   * can be reused upon calling {@link #renew()}.
+   * Aborts this read-only transaction and resets the transaction handle so it can be reused upon
+   * calling {@link #renew()}.
    */
   public void reset() {
     if (SHOULD_CHECK) {
@@ -194,10 +180,10 @@ public void reset() {
   }
 
   /**
-   * Fetch the buffer which holds a read-only view of the LMDI allocated memory.
-   * Any use of this buffer must comply with the standard LMDB C "mdb_get"
-   * contract (ie do not modify, do not attempt to release the memory, do not
-   * use once the transaction or cursor closes, do not use after a write etc).
+   * Fetch the buffer which holds a read-only view of the LMDI allocated memory. Any use of this
+   * buffer must comply with the standard LMDB C "mdb_get" contract (ie do not modify, do not
+   * attempt to release the memory, do not use once the transaction or cursor closes, do not use
+   * after a write etc).
    *
    * @return the value buffer (never null)
    */
@@ -244,9 +230,7 @@ Pointer pointer() {
     return ptr;
   }
 
-  /**
-   * Transaction must abort, has a child, or is invalid.
-   */
+  /** Transaction must abort, has a child, or is invalid. */
   public static final class BadException extends LmdbNativeException {
 
     static final int MDB_BAD_TXN = -30_782;
@@ -257,9 +241,7 @@ public static final class BadException extends LmdbNativeException {
     }
   }
 
-  /**
-   * Invalid reuse of reader locktable slot.
-   */
+  /** Invalid reuse of reader locktable slot. */
   public static final class BadReaderLockException extends LmdbNativeException {
 
     static final int MDB_BAD_RSLOT = -30_783;
@@ -270,114 +252,84 @@ public static final class BadReaderLockException extends LmdbNativeException {
     }
   }
 
-  /**
-   * The proposed R-W transaction is incompatible with a R-O Env.
-   */
+  /** The proposed R-W transaction is incompatible with a R-O Env. */
   public static class EnvIsReadOnly extends LmdbException {
 
     private static final long serialVersionUID = 1L;
 
-    /**
-     * Creates a new instance.
-     */
+    /** Creates a new instance. */
     public EnvIsReadOnly() {
       super("Read-write Txn incompatible with read-only Env");
     }
   }
 
-  /**
-   * The proposed transaction is incompatible with its parent transaction.
-   */
+  /** The proposed transaction is incompatible with its parent transaction. */
   public static class IncompatibleParent extends LmdbException {
 
     private static final long serialVersionUID = 1L;
 
-    /**
-     * Creates a new instance.
-     */
+    /** Creates a new instance. */
     public IncompatibleParent() {
       super("Transaction incompatible with its parent transaction");
     }
   }
 
-  /**
-   * Transaction is not in a READY state.
-   */
+  /** Transaction is not in a READY state. */
   public static final class NotReadyException extends LmdbException {
 
     private static final long serialVersionUID = 1L;
 
-    /**
-     * Creates a new instance.
-     */
+    /** Creates a new instance. */
     public NotReadyException() {
       super("Transaction is not in ready state");
     }
   }
 
-  /**
-   * The current transaction has not been reset.
-   */
+  /** The current transaction has not been reset. */
   public static class NotResetException extends LmdbException {
 
     private static final long serialVersionUID = 1L;
 
-    /**
-     * Creates a new instance.
-     */
+    /** Creates a new instance. */
     public NotResetException() {
       super("Transaction has not been reset");
     }
   }
 
-  /**
-   * The current transaction is not a read-only transaction.
-   */
+  /** The current transaction is not a read-only transaction. */
   public static class ReadOnlyRequiredException extends LmdbException {
 
     private static final long serialVersionUID = 1L;
 
-    /**
-     * Creates a new instance.
-     */
+    /** Creates a new instance. */
     public ReadOnlyRequiredException() {
       super("Not a read-only transaction");
     }
   }
 
-  /**
-   * The current transaction is not a read-write transaction.
-   */
+  /** The current transaction is not a read-write transaction. */
   public static class ReadWriteRequiredException extends LmdbException {
 
     private static final long serialVersionUID = 1L;
 
-    /**
-     * Creates a new instance.
-     */
+    /** Creates a new instance. */
     public ReadWriteRequiredException() {
       super("Not a read-write transaction");
     }
   }
 
-  /**
-   * The current transaction has already been reset.
-   */
+  /** The current transaction has already been reset. */
   public static class ResetException extends LmdbException {
 
     private static final long serialVersionUID = 1L;
 
-    /**
-     * Creates a new instance.
-     */
+    /** Creates a new instance. */
     public ResetException() {
       super("Transaction has already been reset");
     }
   }
 
-  /**
-   * Transaction has too many dirty pages.
-   */
+  /** Transaction has too many dirty pages. */
   public static final class TxFullException extends LmdbNativeException {
 
     static final int MDB_TXN_FULL = -30_788;
@@ -388,11 +340,11 @@ public static final class TxFullException extends LmdbNativeException {
     }
   }
 
-  /**
-   * Transaction states.
-   */
+  /** Transaction states. */
   enum State {
-    READY, DONE, RESET, RELEASED
+    READY,
+    DONE,
+    RESET,
+    RELEASED
   }
-
 }
diff --git a/src/main/java/org/lmdbjava/TxnFlags.java b/src/main/java/org/lmdbjava/TxnFlags.java
index 0379bfa7..26caf6f1 100644
--- a/src/main/java/org/lmdbjava/TxnFlags.java
+++ b/src/main/java/org/lmdbjava/TxnFlags.java
@@ -1,32 +1,23 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
-/**
- * Flags for use when creating a {@link Txn}.
- */
+/** Flags for use when creating a {@link Txn}. */
 public enum TxnFlags implements MaskedFlag {
-  /**
-   * Read only.
-   */
+  /** Read only. */
   MDB_RDONLY_TXN(0x2_0000);
 
   private final int mask;
@@ -39,5 +30,4 @@ public enum TxnFlags implements MaskedFlag {
   public int getMask() {
     return mask;
   }
-
 }
diff --git a/src/main/java/org/lmdbjava/UnsafeAccess.java b/src/main/java/org/lmdbjava/UnsafeAccess.java
index 836cda75..5b3da017 100644
--- a/src/main/java/org/lmdbjava/UnsafeAccess.java
+++ b/src/main/java/org/lmdbjava/UnsafeAccess.java
@@ -1,56 +1,42 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
 import static java.lang.Boolean.getBoolean;
 
 import java.lang.reflect.Field;
-
 import sun.misc.Unsafe;
 
-/**
- * Provides access to Unsafe.
- */
+/** Provides access to Unsafe. */
 final class UnsafeAccess {
 
-  /**
-   * Java system property name that can be set to disable unsafe.
-   */
+  /** Java system property name that can be set to disable unsafe. */
   public static final String DISABLE_UNSAFE_PROP = "lmdbjava.disable.unsafe";
 
-  /**
-   * Indicates whether unsafe use is allowed.
-   */
+  /** Indicates whether unsafe use is allowed. */
   public static final boolean ALLOW_UNSAFE = !getBoolean(DISABLE_UNSAFE_PROP);
 
   /**
-   * The actual unsafe. Guaranteed to be non-null if this class can access
-   * unsafe and {@link #ALLOW_UNSAFE} is true. In other words, this entire class
-   * will fail to initialize if unsafe is unavailable. This avoids callers from
-   * needing to deal with null checks.
+   * The actual unsafe. Guaranteed to be non-null if this class can access unsafe and {@link
+   * #ALLOW_UNSAFE} is true. In other words, this entire class will fail to initialize if unsafe is
+   * unavailable. This avoids callers from needing to deal with null checks.
    */
   static final Unsafe UNSAFE;
-  /**
-   * Unsafe field name (used to reflectively obtain the unsafe instance).
-   */
+
+  /** Unsafe field name (used to reflectively obtain the unsafe instance). */
   private static final String FIELD_NAME_THE_UNSAFE = "theUnsafe";
 
   static {
@@ -61,13 +47,13 @@ final class UnsafeAccess {
       final Field field = Unsafe.class.getDeclaredField(FIELD_NAME_THE_UNSAFE);
       field.setAccessible(true);
       UNSAFE = (Unsafe) field.get(null);
-    } catch (final NoSuchFieldException | SecurityException
-                       | IllegalArgumentException | IllegalAccessException e) {
+    } catch (final NoSuchFieldException
+        | SecurityException
+        | IllegalArgumentException
+        | IllegalAccessException e) {
       throw new LmdbException("Unsafe unavailable", e);
     }
   }
 
-  private UnsafeAccess() {
-  }
-
+  private UnsafeAccess() {}
 }
diff --git a/src/main/java/org/lmdbjava/Verifier.java b/src/main/java/org/lmdbjava/Verifier.java
index 9807d0b8..ff9b28f8 100644
--- a/src/main/java/org/lmdbjava/Verifier.java
+++ b/src/main/java/org/lmdbjava/Verifier.java
@@ -1,23 +1,18 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
 import static java.nio.ByteOrder.BIG_ENDIAN;
@@ -37,53 +32,42 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.zip.CRC32;
 
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-
 /**
  * Verifies correct operation of LmdbJava in a given environment.
  *
- * <p>
- * Due to the large variety of operating systems and Java platforms typically
- * used with LmdbJava, this class provides a convenient verification of correct
- * operating behavior through a potentially long duration set of tests that
- * carefully verify correct storage and retrieval of successively larger
- * database entries.
+ * <p>Due to the large variety of operating systems and Java platforms typically used with LmdbJava,
+ * this class provides a convenient verification of correct operating behavior through a potentially
+ * long duration set of tests that carefully verify correct storage and retrieval of successively
+ * larger database entries.
  *
- * <p>
- * The verifier currently operates by incrementing a <code>long</code>
- * identifier that deterministically maps to a given {@link Dbi} and value size.
- * The key is simply the <code>long</code> identifier. The value commences with
- * a CRC that includes the identifier and the random bytes of the value. Each
- * entry is written out, and then the prior entry is retrieved using its key.
- * The prior entry's value is evaluated for accuracy and then deleted.
- * Transactions are committed in batches to ensure successive transactions
- * correctly retrieve the results of earlier transactions.
+ * <p>The verifier currently operates by incrementing a <code>long</code> identifier that
+ * deterministically maps to a given {@link Dbi} and value size. The key is simply the <code>long
+ * </code> identifier. The value commences with a CRC that includes the identifier and the random
+ * bytes of the value. Each entry is written out, and then the prior entry is retrieved using its
+ * key. The prior entry's value is evaluated for accuracy and then deleted. Transactions are
+ * committed in batches to ensure successive transactions correctly retrieve the results of earlier
+ * transactions.
  *
- * <p>
- * Please note the verification approach may be modified in the future.
+ * <p>Please note the verification approach may be modified in the future.
  *
- * <p>
- * If an exception is raised by this class, please:
+ * <p>If an exception is raised by this class, please:
  *
  * <ol>
- * <li>Ensure the {@link Env} passed at construction time complies with the
- * requirements specified at {@link #Verifier(org.lmdbjava.Env)}</li>
- * <li>Attempt to use a different file system to store the database (be
- * especially careful to not use network file systems, remote file systems,
- * read-only file systems etc)</li>
- * <li>Record the full exception message and stack trace, then run the verifier
- * again to see if it fails at the same or a different point</li>
- * <li>Raise a ticket on the LmdbJava Issue Tracker that confirms the above
- * details along with the failing operating system and Java version</li>
+ *   <li>Ensure the {@link Env} passed at construction time complies with the requirements specified
+ *       at {@link #Verifier(org.lmdbjava.Env)}
+ *   <li>Attempt to use a different file system to store the database (be especially careful to not
+ *       use network file systems, remote file systems, read-only file systems etc)
+ *   <li>Record the full exception message and stack trace, then run the verifier again to see if it
+ *       fails at the same or a different point
+ *   <li>Raise a ticket on the LmdbJava Issue Tracker that confirms the above details along with the
+ *       failing operating system and Java version
  * </ol>
- *
  */
 public final class Verifier implements Callable<Long> {
 
-  /**
-   * Number of DBIs the created environment should allow.
-   */
+  /** Number of DBIs the created environment should allow. */
   public static final int DBI_COUNT = 5;
+
   private static final int BATCH_SIZE = 64;
   private static final int BUFFER_LEN = 1_024 * BATCH_SIZE;
   private static final int CRC_LENGTH = Long.BYTES;
@@ -102,19 +86,15 @@ public final class Verifier implements Callable<Long> {
   /**
    * Create an instance of the verifier.
    *
-   * <p>
-   * The caller must provide an {@link Env} configured with a suitable local
-   * storage location, maximum DBIs equal to {@link #DBI_COUNT}, and a
-   * map size large enough to accommodate the intended verification duration.
+   * <p>The caller must provide an {@link Env} configured with a suitable local storage location,
+   * maximum DBIs equal to {@link #DBI_COUNT}, and a map size large enough to accommodate the
+   * intended verification duration.
    *
-   * <p>
-   * ALL EXISTING DATA IN THE DATABASE WILL BE DELETED. The caller must not
-   * interact with the <code>Env</code> in any way (eg querying, transactions
-   * etc) while the verifier is executing.
+   * <p>ALL EXISTING DATA IN THE DATABASE WILL BE DELETED. The caller must not interact with the
+   * <code>Env</code> in any way (eg querying, transactions etc) while the verifier is executing.
    *
    * @param env target that complies with the above requirements (required)
    */
-  @SuppressFBWarnings("EI_EXPOSE_REP2")
   public Verifier(final Env<ByteBuffer> env) {
     requireNonNull(env);
     this.env = env;
@@ -127,10 +107,8 @@ public Verifier(final Env<ByteBuffer> env) {
   /**
    * Run the verifier until {@link #stop()} is called or an exception occurs.
    *
-   * <p>
-   * Successful return of this method indicates no faults were detected. If any
-   * fault was detected the exception message will detail the exact point that
-   * the fault was encountered.
+   * <p>Successful return of this method indicates no faults were detected. If any fault was
+   * detected the exception message will detail the exact point that the fault was encountered.
    *
    * @return number of database rows successfully verified
    */
@@ -159,12 +137,11 @@ public Long call() {
   /**
    * Execute the verifier for the given duration.
    *
-   * <p>
-   * This provides a simple way to execute the verifier for those applications
-   * which do not wish to manage threads directly.
+   * <p>This provides a simple way to execute the verifier for those applications which do not wish
+   * to manage threads directly.
    *
    * @param duration amount of time to execute
-   * @param unit     units used to express the duration
+   * @param unit units used to express the duration
    * @return number of database rows successfully verified
    */
   public long runFor(final long duration, final TimeUnit unit) {
@@ -233,14 +210,11 @@ private Dbi<ByteBuffer> getDbi(final long forId) {
     return dbis.get((int) (forId % dbis.size()));
   }
 
-  /**
-   * Request the verifier to stop execution.
-   */
+  /** Request the verifier to stop execution. */
   private void stop() {
     proceed.set(false);
   }
 
-  @SuppressFBWarnings("DMI_RANDOM_USED_ONLY_ONCE")
   private void transactionControl() {
     if (id % BATCH_SIZE == 0) {
       if (txn != null) {
@@ -282,8 +256,8 @@ private void verifyValue(final long forId, final ByteBuffer bb) {
     final int rndSize = valueSize(forId);
     final int expected = rndSize + CRC_LENGTH;
     if (bb.limit() != expected) {
-      throw new IllegalStateException("Limit error id=" + forId + " exp="
-                                          + expected + " limit=" + bb.limit());
+      throw new IllegalStateException(
+          "Limit error id=" + forId + " exp=" + expected + " limit=" + bb.limit());
     }
 
     final long crcRead = bb.getLong();
@@ -308,5 +282,4 @@ private void write(final long forId) {
       throw new IllegalStateException("DB put id=" + forId, ex);
     }
   }
-
 }
diff --git a/src/main/java/org/lmdbjava/package-info.java b/src/main/java/org/lmdbjava/package-info.java
index 52c8551a..9589c470 100644
--- a/src/main/java/org/lmdbjava/package-info.java
+++ b/src/main/java/org/lmdbjava/package-info.java
@@ -1,63 +1,52 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 /**
  * Lightning Memory Database (LMDB) for Java (LmdbJava).
  *
- * <p>
- * LmdbJava is intended for extremely low latency use cases. Users are required
- * to understand and comply with the LMDB C API contract (eg handle usage
- * patterns, thread binding, process rules).
+ * <p>LmdbJava is intended for extremely low latency use cases. Users are required to understand and
+ * comply with the LMDB C API contract (eg handle usage patterns, thread binding, process rules).
+ *
+ * <p>Priorities:
  *
- * <p>
- * Priorities:
  * <ol>
- * <li>Minimize latency, particularly on any critical path (see below)</li>
- * <li>Preserve the LMDB C API model as far as practical</li>
- * <li>Apply Java idioms only when not in conflict with the above</li>
- * <li>Fully encapsulate (hide) the native call library and patterns</li>
- * <li>Don't require runtime dependencies beyond the native call library</li>
- * <li>Support official JVMs running on typical 64-bit operating systems</li>
- * <li>Prepare for Java 9 (eg Unsafe, native call technology roadmap etc)</li>
+ *   <li>Minimize latency, particularly on any critical path (see below)
+ *   <li>Preserve the LMDB C API model as far as practical
+ *   <li>Apply Java idioms only when not in conflict with the above
+ *   <li>Fully encapsulate (hide) the native call library and patterns
+ *   <li>Don't require runtime dependencies beyond the native call library
+ *   <li>Support official JVMs running on typical 64-bit operating systems
+ *   <li>Prepare for Java 9 (eg Unsafe, native call technology roadmap etc)
  * </ol>
  *
- * <p>
- * Critical paths of special latency focus:
+ * <p>Critical paths of special latency focus:
+ *
  * <ul>
- * <li>Releasing and renewing a read-only transaction</li>
- * <li>Any operation that uses a cursor</li>
+ *   <li>Releasing and renewing a read-only transaction
+ *   <li>Any operation that uses a cursor
  * </ul>
  *
- * <p>
- * The classes in LmdbJava DO NOT provide any concurrency guarantees. Instead
- * you MUST observe LMDB's specific thread rules (eg do not share transactions
- * between threads). LmdbJava does not shield you from these requirements, as
- * doing so would impose locking overhead on use cases that may not require it
- * or have already carefully implemented application threading (as most low
+ * <p>The classes in LmdbJava DO NOT provide any concurrency guarantees. Instead you MUST observe
+ * LMDB's specific thread rules (eg do not share transactions between threads). LmdbJava does not
+ * shield you from these requirements, as doing so would impose locking overhead on use cases that
+ * may not require it or have already carefully implemented application threading (as most low
  * latency applications do to optimize the memory hierarchy, core pinning etc).
  *
- * <p>
- * Most methods in this package will throw a standard Java exception for failing
- * preconditions (eg {@link NullPointerException} if a mandatory argument was
- * missing) or a subclass of {@link LmdbException} for precondition or LMDB C
- * failures. The majority of LMDB exceptions indicate an API usage or
- * {@link Env} configuration issues, and as such are typically unrecoverable.
+ * <p>Most methods in this package will throw a standard Java exception for failing preconditions
+ * (eg {@link NullPointerException} if a mandatory argument was missing) or a subclass of {@link
+ * LmdbException} for precondition or LMDB C failures. The majority of LMDB exceptions indicate an
+ * API usage or {@link Env} configuration issues, and as such are typically unrecoverable.
  */
 package org.lmdbjava;
diff --git a/src/misc/license-template.txt b/src/misc/license-template.txt
new file mode 100644
index 00000000..046ef77f
--- /dev/null
+++ b/src/misc/license-template.txt
@@ -0,0 +1,13 @@
+Copyright © ${license.git.copyrightYears} ${owner}
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
\ No newline at end of file
diff --git a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
index 3daaea5f..8044b9e8 100644
--- a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
+++ b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
@@ -1,23 +1,18 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
 import static java.lang.Integer.BYTES;
@@ -45,7 +40,6 @@
 import java.io.IOException;
 import java.lang.reflect.Field;
 import java.nio.ByteBuffer;
-
 import jnr.ffi.Pointer;
 import jnr.ffi.provider.MemoryManager;
 import org.junit.Rule;
@@ -54,22 +48,17 @@
 import org.lmdbjava.ByteBufferProxy.BufferMustBeDirectException;
 import org.lmdbjava.Env.ReadersFullException;
 
-/**
- * Test {@link ByteBufferProxy}.
- */
+/** Test {@link ByteBufferProxy}. */
 public final class ByteBufferProxyTest {
 
   static final MemoryManager MEM_MGR = RUNTIME.getMemoryManager();
 
-  @Rule
-  public final TemporaryFolder tmp = new TemporaryFolder();
+  @Rule public final TemporaryFolder tmp = new TemporaryFolder();
 
   @Test(expected = BufferMustBeDirectException.class)
   public void buffersMustBeDirect() throws IOException {
     final File path = tmp.newFolder();
-    try (Env<ByteBuffer> env = create()
-        .setMaxReaders(1)
-        .open(path)) {
+    try (Env<ByteBuffer> env = create().setMaxReaders(1).open(path)) {
       final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
       final ByteBuffer key = allocate(100);
       key.putInt(1).flip();
@@ -159,5 +148,4 @@ private void checkInOut(final BufferProxy<ByteBuffer> v) {
     assertThat(bb.getInt(), is(3));
     assertThat(bb.remaining(), is(0));
   }
-
 }
diff --git a/src/test/java/org/lmdbjava/ComparatorTest.java b/src/test/java/org/lmdbjava/ComparatorTest.java
index 8371a1ae..3e265cee 100644
--- a/src/test/java/org/lmdbjava/ComparatorTest.java
+++ b/src/test/java/org/lmdbjava/ComparatorTest.java
@@ -1,23 +1,18 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
 import static io.netty.buffer.PooledByteBufAllocator.DEFAULT;
@@ -33,13 +28,12 @@
 import static org.lmdbjava.ComparatorTest.ComparatorResult.get;
 import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
 
-import java.nio.ByteBuffer;
-import java.util.Arrays;
-import java.util.Comparator;
-
 import com.google.common.primitives.SignedBytes;
 import com.google.common.primitives.UnsignedBytes;
 import io.netty.buffer.ByteBuf;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import java.util.Comparator;
 import org.agrona.DirectBuffer;
 import org.agrona.concurrent.UnsafeBuffer;
 import org.junit.Test;
@@ -48,9 +42,7 @@
 import org.junit.runners.Parameterized.Parameter;
 import org.junit.runners.Parameterized.Parameters;
 
-/**
- * Tests comparator functions are consistent across buffers.
- */
+/** Tests comparator functions are consistent across buffers. */
 @RunWith(Parameterized.class)
 public final class ComparatorTest {
 
@@ -66,11 +58,9 @@ public final class ComparatorTest {
   private static final byte[] LLLLLLLX = buffer(0, 0, 0, 0, 0, 0, 0);
   private static final byte[] LX = buffer(0);
   private static final byte[] XX = buffer();
-  /**
-   * Injected by {@link #data()} with appropriate runner.
-   */
-  @Parameter
-  public ComparatorRunner comparator;
+
+  /** Injected by {@link #data()} with appropriate runner. */
+  @Parameter public ComparatorRunner comparator;
 
   @Parameters(name = "{index}: comparable: {0}")
   public static Object[] data() {
@@ -81,7 +71,7 @@ public static Object[] data() {
     final ComparatorRunner netty = new NettyRunner();
     final ComparatorRunner gub = new GuavaUnsignedBytes();
     final ComparatorRunner gsb = new GuavaSignedBytes();
-    return new Object[]{string, db, ba, bb, netty, gub, gsb};
+    return new Object[] {string, db, ba, bb, netty, gub, gsb};
   }
 
   private static byte[] buffer(final int... bytes) {
@@ -140,9 +130,7 @@ public void equalBuffers() {
     assertThat(get(comparator.compare(LLLLLLLX, LLLLLLLX)), is(EQUAL_TO));
   }
 
-  /**
-   * Tests {@link ByteArrayProxy}.
-   */
+  /** Tests {@link ByteArrayProxy}. */
   private static final class ByteArrayRunner implements ComparatorRunner {
 
     @Override
@@ -152,9 +140,7 @@ public int compare(final byte[] o1, final byte[] o2) {
     }
   }
 
-  /**
-   * Tests {@link ByteBufferProxy}.
-   */
+  /** Tests {@link ByteBufferProxy}. */
   private static final class ByteBufferRunner implements ComparatorRunner {
 
     @Override
@@ -196,9 +182,7 @@ private ByteBuffer arrayToBuffer(final byte[] arr, final int bufferCapacity) {
     }
   }
 
-  /**
-   * Tests {@link DirectBufferProxy}.
-   */
+  /** Tests {@link DirectBufferProxy}. */
   private static final class DirectBufferRunner implements ComparatorRunner {
 
     @Override
@@ -210,9 +194,7 @@ public int compare(final byte[] o1, final byte[] o2) {
     }
   }
 
-  /**
-   * Tests using Guava's {@link SignedBytes} comparator.
-   */
+  /** Tests using Guava's {@link SignedBytes} comparator. */
   private static final class GuavaSignedBytes implements ComparatorRunner {
 
     @Override
@@ -222,9 +204,7 @@ public int compare(final byte[] o1, final byte[] o2) {
     }
   }
 
-  /**
-   * Tests using Guava's {@link UnsignedBytes} comparator.
-   */
+  /** Tests using Guava's {@link UnsignedBytes} comparator. */
   private static final class GuavaUnsignedBytes implements ComparatorRunner {
 
     @Override
@@ -234,9 +214,7 @@ public int compare(final byte[] o1, final byte[] o2) {
     }
   }
 
-  /**
-   * Tests {@link ByteBufProxy}.
-   */
+  /** Tests {@link ByteBufProxy}. */
   private static final class NettyRunner implements ComparatorRunner {
 
     @Override
@@ -251,8 +229,8 @@ public int compare(final byte[] o1, final byte[] o2) {
   }
 
   /**
-   * Tests {@link String} by providing a reference implementation of what a
-   * comparator involving ASCII-encoded bytes should return.
+   * Tests {@link String} by providing a reference implementation of what a comparator involving
+   * ASCII-encoded bytes should return.
    */
   private static final class StringRunner implements ComparatorRunner {
 
@@ -264,9 +242,7 @@ public int compare(final byte[] o1, final byte[] o2) {
     }
   }
 
-  /**
-   * Converts an integer result code into its contractual meaning.
-   */
+  /** Converts an integer result code into its contractual meaning. */
   enum ComparatorResult {
     LESS_THAN,
     EQUAL_TO,
@@ -280,14 +256,12 @@ static ComparatorResult get(final int comparatorResult) {
     }
   }
 
-  /**
-   * Interface that can test a {@link BufferProxy} <code>compare</code> method.
-   */
+  /** Interface that can test a {@link BufferProxy} <code>compare</code> method. */
   private interface ComparatorRunner {
 
     /**
-     * Convert the passed byte arrays into the proxy's relevant buffer type and
-     * then invoke the comparator.
+     * Convert the passed byte arrays into the proxy's relevant buffer type and then invoke the
+     * comparator.
      *
      * @param o1 lhs buffer content
      * @param o2 rhs buffer content
@@ -295,5 +269,4 @@ private interface ComparatorRunner {
      */
     int compare(byte[] o1, byte[] o2);
   }
-
 }
diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index db28405a..bd23bc55 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -1,23 +1,18 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
 import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
@@ -51,6 +46,7 @@
 import static org.lmdbjava.TestUtils.POSIX_MODE;
 import static org.lmdbjava.TestUtils.bb;
 
+import com.google.common.primitives.UnsignedBytes;
 import java.io.File;
 import java.io.IOException;
 import java.nio.ByteBuffer;
@@ -61,8 +57,6 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.NoSuchElementException;
-
-import com.google.common.primitives.UnsignedBytes;
 import org.hamcrest.Matchers;
 import org.junit.After;
 import org.junit.Before;
@@ -71,13 +65,10 @@
 import org.junit.rules.TemporaryFolder;
 import org.lmdbjava.CursorIterable.KeyVal;
 
-/**
- * Test {@link CursorIterable}.
- */
+/** Test {@link CursorIterable}. */
 public final class CursorIterableTest {
 
-  @Rule
-  public final TemporaryFolder tmp = new TemporaryFolder();
+  @Rule public final TemporaryFolder tmp = new TemporaryFolder();
   private Dbi<ByteBuffer> db;
   private Env<ByteBuffer> env;
   private Deque<Integer> list;
@@ -125,11 +116,12 @@ public void atMostTest() {
   @Before
   public void before() throws IOException {
     final File path = tmp.newFile();
-    env = create()
-        .setMapSize(KIBIBYTES.toBytes(256))
-        .setMaxReaders(1)
-        .setMaxDbs(1)
-        .open(path, POSIX_MODE, MDB_NOSUBDIR);
+    env =
+        create()
+            .setMapSize(KIBIBYTES.toBytes(256))
+            .setMaxReaders(1)
+            .setMaxDbs(1)
+            .open(path, POSIX_MODE, MDB_NOSUBDIR);
     db = env.openDbi(DB_1, MDB_CREATE);
     populateDatabase(db);
   }
@@ -190,7 +182,7 @@ public void greaterThanTest() {
   @Test(expected = IllegalStateException.class)
   public void iterableOnlyReturnedOnce() {
     try (Txn<ByteBuffer> txn = env.txnRead();
-         CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+        CursorIterable<ByteBuffer> c = db.iterate(txn)) {
       c.iterator(); // ok
       c.iterator(); // fails
     }
@@ -199,7 +191,7 @@ public void iterableOnlyReturnedOnce() {
   @Test
   public void iterate() {
     try (Txn<ByteBuffer> txn = env.txnRead();
-         CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+        CursorIterable<ByteBuffer> c = db.iterate(txn)) {
       for (final KeyVal<ByteBuffer> kv : c) {
         assertThat(kv.key().getInt(), is(list.pollFirst()));
         assertThat(kv.val().getInt(), is(list.pollFirst()));
@@ -210,7 +202,7 @@ public void iterate() {
   @Test(expected = IllegalStateException.class)
   public void iteratorOnlyReturnedOnce() {
     try (Txn<ByteBuffer> txn = env.txnRead();
-         CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+        CursorIterable<ByteBuffer> c = db.iterate(txn)) {
       c.iterator(); // ok
       c.iterator(); // fails
     }
@@ -231,7 +223,7 @@ public void lessThanTest() {
   @Test(expected = NoSuchElementException.class)
   public void nextThrowsNoSuchElementExceptionIfNoMoreElements() {
     try (Txn<ByteBuffer> txn = env.txnRead();
-         CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+        CursorIterable<ByteBuffer> c = db.iterate(txn)) {
       final Iterator<KeyVal<ByteBuffer>> i = c.iterator();
       while (i.hasNext()) {
         final KeyVal<ByteBuffer> kv = i.next();
@@ -260,17 +252,18 @@ public void openClosedBackwardTest() {
   @Test
   public void openClosedBackwardTestWithGuava() {
     final Comparator<byte[]> guava = UnsignedBytes.lexicographicalComparator();
-    final Comparator<ByteBuffer> comparator = (bb1, bb2) -> {
-      final byte[] array1 = new byte[bb1.remaining()];
-      final byte[] array2 = new byte[bb2.remaining()];
-      bb1.mark();
-      bb2.mark();
-      bb1.get(array1);
-      bb2.get(array2);
-      bb1.reset();
-      bb2.reset();
-      return guava.compare(array1, array2);
-    };
+    final Comparator<ByteBuffer> comparator =
+        (bb1, bb2) -> {
+          final byte[] array1 = new byte[bb1.remaining()];
+          final byte[] array2 = new byte[bb2.remaining()];
+          bb1.mark();
+          bb2.mark();
+          bb1.get(array1);
+          bb2.get(array2);
+          bb1.reset();
+          bb2.reset();
+          return guava.compare(array1, array2);
+        };
     final Dbi<ByteBuffer> guavaDbi = env.openDbi(DB_1, comparator, MDB_CREATE);
     populateDatabase(guavaDbi);
     verify(openClosedBackward(bb(7), bb(2)), guavaDbi, 6, 4, 2);
@@ -355,24 +348,21 @@ public void forEachRemainingWithClosedEnvTest() {
         final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
 
         env.close();
-        c.forEachRemaining(keyVal -> {
-
-        });
+        c.forEachRemaining(keyVal -> {});
       }
     }
   }
 
-  private void verify(final KeyRange<ByteBuffer> range,
-                      final int... expected) {
+  private void verify(final KeyRange<ByteBuffer> range, final int... expected) {
     verify(range, db, expected);
   }
 
-  private void verify(final KeyRange<ByteBuffer> range,
-                      final Dbi<ByteBuffer> dbi, final int... expected) {
+  private void verify(
+      final KeyRange<ByteBuffer> range, final Dbi<ByteBuffer> dbi, final int... expected) {
     final List<Integer> results = new ArrayList<>();
 
     try (Txn<ByteBuffer> txn = env.txnRead();
-         CursorIterable<ByteBuffer> c = dbi.iterate(txn, range)) {
+        CursorIterable<ByteBuffer> c = dbi.iterate(txn, range)) {
       for (final KeyVal<ByteBuffer> kv : c) {
         final int key = kv.key().getInt();
         final int val = kv.val().getInt();
@@ -386,5 +376,4 @@ private void verify(final KeyRange<ByteBuffer> range,
       assertThat(results.get(idx), is(expected[idx]));
     }
   }
-
 }
diff --git a/src/test/java/org/lmdbjava/CursorParamTest.java b/src/test/java/org/lmdbjava/CursorParamTest.java
index b9fd60e3..bd99e709 100644
--- a/src/test/java/org/lmdbjava/CursorParamTest.java
+++ b/src/test/java/org/lmdbjava/CursorParamTest.java
@@ -1,23 +1,18 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
 import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
@@ -48,11 +43,10 @@
 import static org.lmdbjava.TestUtils.mdb;
 import static org.lmdbjava.TestUtils.nb;
 
+import io.netty.buffer.ByteBuf;
 import java.io.File;
 import java.io.IOException;
 import java.nio.ByteBuffer;
-
-import io.netty.buffer.ByteBuf;
 import org.agrona.DirectBuffer;
 import org.agrona.MutableDirectBuffer;
 import org.junit.Rule;
@@ -63,20 +57,14 @@
 import org.junit.runners.Parameterized.Parameter;
 import org.junit.runners.Parameterized.Parameters;
 
-/**
- * Test {@link Cursor} with different buffer implementations.
- */
+/** Test {@link Cursor} with different buffer implementations. */
 @RunWith(Parameterized.class)
 public final class CursorParamTest {
 
-  /**
-   * Injected by {@link #data()} with appropriate runner.
-   */
-  @Parameter
-  public BufferRunner<?> runner;
+  /** Injected by {@link #data()} with appropriate runner. */
+  @Parameter public BufferRunner<?> runner;
 
-  @Rule
-  public final TemporaryFolder tmp = new TemporaryFolder();
+  @Rule public final TemporaryFolder tmp = new TemporaryFolder();
 
   @Parameters(name = "{index}: buffer adapter: {0}")
   public static Object[] data() {
@@ -85,7 +73,7 @@ public static Object[] data() {
     final BufferRunner<byte[]> ba = new ByteArrayRunner(PROXY_BA);
     final BufferRunner<DirectBuffer> db = new DirectBufferRunner();
     final BufferRunner<ByteBuf> netty = new NettyBufferRunner();
-    return new Object[]{bb1, bb2, ba, db, netty};
+    return new Object[] {bb1, bb2, ba, db, netty};
   }
 
   @Test
@@ -98,8 +86,7 @@ public void execute() {
    *
    * @param <T> buffer type
    */
-  private abstract static class AbstractBufferRunner<T> implements
-      BufferRunner<T> {
+  private abstract static class AbstractBufferRunner<T> implements BufferRunner<T> {
 
     final BufferProxy<T> proxy;
 
@@ -114,7 +101,7 @@ public final void execute(final TemporaryFolder tmp) {
         final Dbi<T> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
         assertThat(env.getDbiNames().get(0), is(DB_1.getBytes(UTF_8)));
         try (Txn<T> txn = env.txnWrite();
-             Cursor<T> c = db.openCursor(txn)) {
+            Cursor<T> c = db.openCursor(txn)) {
           // populate data
           c.put(set(1), set(2), MDB_NOOVERWRITE);
           c.put(set(3), set(4));
@@ -192,12 +179,9 @@ private Env<T> env(final TemporaryFolder tmp) {
         throw new LmdbException("IO failure", e);
       }
     }
-
   }
 
-  /**
-   * {@link BufferRunner} for Java byte buffers.
-   */
+  /** {@link BufferRunner} for Java byte buffers. */
   private static class ByteArrayRunner extends AbstractBufferRunner<byte[]> {
 
     ByteArrayRunner(final BufferProxy<byte[]> proxy) {
@@ -207,9 +191,9 @@ private static class ByteArrayRunner extends AbstractBufferRunner<byte[]> {
     @Override
     public int get(final byte[] buff) {
       return (buff[0] & 0xFF) << 24
-                 | (buff[1] & 0xFF) << 16
-                 | (buff[2] & 0xFF) << 8
-                 | (buff[3] & 0xFF);
+          | (buff[1] & 0xFF) << 16
+          | (buff[2] & 0xFF) << 8
+          | (buff[3] & 0xFF);
     }
 
     @Override
@@ -231,9 +215,7 @@ public void set(final byte[] buff, final int val) {
     }
   }
 
-  /**
-   * {@link BufferRunner} for Java byte buffers.
-   */
+  /** {@link BufferRunner} for Java byte buffers. */
   private static class ByteBufferRunner extends AbstractBufferRunner<ByteBuffer> {
 
     ByteBufferRunner(final BufferProxy<ByteBuffer> proxy) {
@@ -254,12 +236,9 @@ public ByteBuffer set(final int val) {
     public void set(final ByteBuffer buff, final int val) {
       buff.putInt(val);
     }
-
   }
 
-  /**
-   * {@link BufferRunner} for Agrona direct buffer.
-   */
+  /** {@link BufferRunner} for Agrona direct buffer. */
   private static class DirectBufferRunner extends AbstractBufferRunner<DirectBuffer> {
 
     DirectBufferRunner() {
@@ -280,12 +259,9 @@ public DirectBuffer set(final int val) {
     public void set(final DirectBuffer buff, final int val) {
       ((MutableDirectBuffer) buff).putInt(0, val);
     }
-
   }
 
-  /**
-   * {@link BufferRunner} for Netty byte buf.
-   */
+  /** {@link BufferRunner} for Netty byte buf. */
   private static class NettyBufferRunner extends AbstractBufferRunner<ByteBuf> {
 
     NettyBufferRunner() {
@@ -306,7 +282,6 @@ public ByteBuf set(final int val) {
     public void set(final ByteBuf buff, final int val) {
       buff.setInt(0, val);
     }
-
   }
 
   /**
@@ -324,5 +299,4 @@ private interface BufferRunner<T> {
 
     int get(T buff);
   }
-
 }
diff --git a/src/test/java/org/lmdbjava/CursorTest.java b/src/test/java/org/lmdbjava/CursorTest.java
index 17fbacc7..cf6e4dea 100644
--- a/src/test/java/org/lmdbjava/CursorTest.java
+++ b/src/test/java/org/lmdbjava/CursorTest.java
@@ -1,23 +1,18 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
 import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
@@ -50,7 +45,6 @@
 import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.util.function.Consumer;
-
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Rule;
@@ -60,13 +54,10 @@
 import org.lmdbjava.Txn.NotReadyException;
 import org.lmdbjava.Txn.ReadOnlyRequiredException;
 
-/**
- * Test {@link Cursor}.
- */
+/** Test {@link Cursor}. */
 public final class CursorTest {
 
-  @Rule
-  public final TemporaryFolder tmp = new TemporaryFolder();
+  @Rule public final TemporaryFolder tmp = new TemporaryFolder();
 
   private Env<ByteBuffer> env;
 
@@ -79,11 +70,12 @@ public void after() {
   public void before() throws IOException {
     try {
       final File path = tmp.newFile();
-      env = create(PROXY_OPTIMAL)
-          .setMapSize(KIBIBYTES.toBytes(1_024))
-          .setMaxReaders(1)
-          .setMaxDbs(1)
-          .open(path, POSIX_MODE, MDB_NOSUBDIR);
+      env =
+          create(PROXY_OPTIMAL)
+              .setMapSize(KIBIBYTES.toBytes(1_024))
+              .setMaxReaders(1)
+              .setMaxDbs(1)
+              .open(path, POSIX_MODE, MDB_NOSUBDIR);
     } catch (final IOException e) {
       throw new LmdbException("IO failure", e);
     }
@@ -132,31 +124,31 @@ public void closedEnvRejectsLastCall() {
   @Test(expected = Env.AlreadyClosedException.class)
   public void closedEnvRejectsPrevCall() {
     doEnvClosedTest(
-            c -> {
-              c.first();
-              assertThat(c.key().getInt(), is(1));
-              assertThat(c.val().getInt(), is(10));
-              c.next();
-            },
-            Cursor::prev);
+        c -> {
+          c.first();
+          assertThat(c.key().getInt(), is(1));
+          assertThat(c.val().getInt(), is(10));
+          c.next();
+        },
+        Cursor::prev);
   }
 
   @Test(expected = Env.AlreadyClosedException.class)
   public void closedEnvRejectsDeleteCall() {
     doEnvClosedTest(
-            c -> {
-              c.first();
-              assertThat(c.key().getInt(), is(1));
-              assertThat(c.val().getInt(), is(10));
-            },
-            Cursor::delete);
+        c -> {
+          c.first();
+          assertThat(c.key().getInt(), is(1));
+          assertThat(c.val().getInt(), is(10));
+        },
+        Cursor::delete);
   }
 
   @Test
   public void count() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
     try (Txn<ByteBuffer> txn = env.txnWrite();
-         Cursor<ByteBuffer> c = db.openCursor(txn)) {
+        Cursor<ByteBuffer> c = db.openCursor(txn)) {
       c.put(bb(1), bb(2), MDB_APPENDDUP);
       assertThat(c.count(), is(1L));
       c.put(bb(1), bb(4), MDB_APPENDDUP);
@@ -172,7 +164,7 @@ public void count() {
   public void cursorCannotCloseIfTransactionCommitted() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      try (Cursor<ByteBuffer> c = db.openCursor(txn);) {
+      try (Cursor<ByteBuffer> c = db.openCursor(txn); ) {
         c.put(bb(1), bb(2), MDB_APPENDDUP);
         assertThat(c.count(), is(1L));
         c.put(bb(1), bb(4), MDB_APPENDDUP);
@@ -186,7 +178,7 @@ public void cursorCannotCloseIfTransactionCommitted() {
   public void cursorFirstLastNextPrev() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
     try (Txn<ByteBuffer> txn = env.txnWrite();
-         Cursor<ByteBuffer> c = db.openCursor(txn)) {
+        Cursor<ByteBuffer> c = db.openCursor(txn)) {
       c.put(bb(1), bb(2), MDB_NOOVERWRITE);
       c.put(bb(3), bb(4));
       c.put(bb(5), bb(6));
@@ -215,7 +207,7 @@ public void cursorFirstLastNextPrev() {
   public void delete() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
     try (Txn<ByteBuffer> txn = env.txnWrite();
-         Cursor<ByteBuffer> c = db.openCursor(txn)) {
+        Cursor<ByteBuffer> c = db.openCursor(txn)) {
       c.put(bb(1), bb(2), MDB_NOOVERWRITE);
       c.put(bb(3), bb(4));
       assertThat(c.seek(MDB_FIRST), is(true));
@@ -234,7 +226,7 @@ public void delete() {
   public void getKeyVal() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
     try (Txn<ByteBuffer> txn = env.txnWrite();
-         Cursor<ByteBuffer> c = db.openCursor(txn)) {
+        Cursor<ByteBuffer> c = db.openCursor(txn)) {
       c.put(bb(1), bb(2), MDB_APPENDDUP);
       c.put(bb(1), bb(4), MDB_APPENDDUP);
       c.put(bb(1), bb(6), MDB_APPENDDUP);
@@ -253,8 +245,7 @@ public void getKeyVal() {
 
   @Test
   public void putMultiple() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT,
-                                           MDB_DUPFIXED);
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT, MDB_DUPFIXED);
     final int elemCount = 20;
 
     final ByteBuffer values = allocateDirect(Integer.BYTES * elemCount);
@@ -266,7 +257,7 @@ public void putMultiple() {
     final int key = 100;
     final ByteBuffer k = bb(key);
     try (Txn<ByteBuffer> txn = env.txnWrite();
-         Cursor<ByteBuffer> c = db.openCursor(txn)) {
+        Cursor<ByteBuffer> c = db.openCursor(txn)) {
       c.putMultiple(k, values, elemCount, MDB_MULTIPLE);
       assertThat(c.count(), is((long) elemCount));
     }
@@ -276,7 +267,7 @@ public void putMultiple() {
   public void putMultipleWithoutMdbMultipleFlag() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
     try (Txn<ByteBuffer> txn = env.txnWrite();
-         Cursor<ByteBuffer> c = db.openCursor(txn)) {
+        Cursor<ByteBuffer> c = db.openCursor(txn)) {
       c.putMultiple(bb(100), bb(1), 1);
     }
   }
@@ -345,7 +336,7 @@ public void reserve() {
   public void returnValueForNoDupData() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
     try (Txn<ByteBuffer> txn = env.txnWrite();
-         Cursor<ByteBuffer> c = db.openCursor(txn)) {
+        Cursor<ByteBuffer> c = db.openCursor(txn)) {
       // ok
       assertThat(c.put(bb(5), bb(6), MDB_NODUPDATA), is(true));
       assertThat(c.put(bb(5), bb(7), MDB_NODUPDATA), is(true));
@@ -357,7 +348,7 @@ public void returnValueForNoDupData() {
   public void returnValueForNoOverwrite() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
     try (Txn<ByteBuffer> txn = env.txnWrite();
-         Cursor<ByteBuffer> c = db.openCursor(txn)) {
+        Cursor<ByteBuffer> c = db.openCursor(txn)) {
       // ok
       assertThat(c.put(bb(5), bb(6), MDB_NOOVERWRITE), is(true));
       // fails, but gets exist val
@@ -395,8 +386,9 @@ public void testCursorByteBufferDuplicate() {
     }
   }
 
-  private void doEnvClosedTest(final Consumer<Cursor<ByteBuffer>> workBeforeEnvClosed,
-                               final Consumer<Cursor<ByteBuffer>> workAfterEnvClose) {
+  private void doEnvClosedTest(
+      final Consumer<Cursor<ByteBuffer>> workBeforeEnvClosed,
+      final Consumer<Cursor<ByteBuffer>> workAfterEnvClose) {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
 
     db.put(bb(1), bb(10));
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 5a8cf549..1fa80f6e 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -1,23 +1,18 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
 import static com.jakewharton.byteunits.BinaryByteUnit.MEBIBYTES;
@@ -69,7 +64,6 @@
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.BiConsumer;
-
 import org.agrona.concurrent.UnsafeBuffer;
 import org.hamcrest.Matchers;
 import org.junit.After;
@@ -83,13 +77,10 @@
 import org.lmdbjava.Env.MapFullException;
 import org.lmdbjava.LmdbNativeException.ConstantDerivedException;
 
-/**
- * Test {@link Dbi}.
- */
+/** Test {@link Dbi}. */
 public final class DbiTest {
 
-  @Rule
-  public final TemporaryFolder tmp = new TemporaryFolder();
+  @Rule public final TemporaryFolder tmp = new TemporaryFolder();
   private Env<ByteBuffer> env;
 
   @After
@@ -100,11 +91,12 @@ public void after() {
   @Before
   public void before() throws IOException {
     final File path = tmp.newFile();
-    env = create()
-        .setMapSize(MEBIBYTES.toBytes(64))
-        .setMaxReaders(2)
-        .setMaxDbs(2)
-        .open(path, MDB_NOSUBDIR);
+    env =
+        create()
+            .setMapSize(MEBIBYTES.toBytes(64))
+            .setMaxReaders(2)
+            .setMaxDbs(2)
+            .open(path, MDB_NOSUBDIR);
   }
 
   @Test(expected = ConstantDerivedException.class)
@@ -117,13 +109,14 @@ public void close() {
 
   @Test
   public void customComparator() {
-    final Comparator<ByteBuffer> reverseOrder = (o1, o2) -> {
-      final int lexical = PROXY_OPTIMAL.getComparator().compare(o1, o2);
-      if (lexical == 0) {
-        return 0;
-      }
-      return lexical * -1;
-    };
+    final Comparator<ByteBuffer> reverseOrder =
+        (o1, o2) -> {
+          final int lexical = PROXY_OPTIMAL.getComparator().compare(o1, o2);
+          if (lexical == 0) {
+            return 0;
+          }
+          return lexical * -1;
+        };
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, reverseOrder, true, MDB_CREATE);
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       assertThat(db.put(txn, bb(2), bb(3)), is(true));
@@ -133,7 +126,7 @@ public void customComparator() {
       txn.commit();
     }
     try (Txn<ByteBuffer> txn = env.txnRead();
-         CursorIterable<ByteBuffer> ci = db.iterate(txn, atMost(bb(4)))) {
+        CursorIterable<ByteBuffer> ci = db.iterate(txn, atMost(bb(4)))) {
       final Iterator<KeyVal<ByteBuffer>> iter = ci.iterator();
       assertThat(iter.next().key().getInt(), is(8));
       assertThat(iter.next().key().getInt(), is(6));
@@ -142,7 +135,6 @@ public void customComparator() {
   }
 
   @Test(expected = DbFullException.class)
-  @SuppressWarnings("ResultOfObjectAllocationIgnored")
   public void dbOpenMaxDatabases() {
     env.openDbi("db1 is OK", MDB_CREATE);
     env.openDbi("db2 is OK", MDB_CREATE);
@@ -159,13 +151,15 @@ public void dbiWithComparatorThreadSafety() {
 
     final ExecutorService pool = Executors.newCachedThreadPool();
     final AtomicBoolean proceed = new AtomicBoolean(true);
-    final Future<?> reader = pool.submit(() -> {
-      while (proceed.get()) {
-        try (Txn<ByteBuffer> txn = env.txnRead()) {
-          db.get(txn, bb(50));
-        }
-      }
-    });
+    final Future<?> reader =
+        pool.submit(
+            () -> {
+              while (proceed.get()) {
+                try (Txn<ByteBuffer> txn = env.txnRead()) {
+                  db.get(txn, bb(50));
+                }
+              }
+            });
 
     for (final Integer key : keys) {
       try (Txn<ByteBuffer> txn = env.txnWrite()) {
@@ -175,7 +169,7 @@ public void dbiWithComparatorThreadSafety() {
     }
 
     try (Txn<ByteBuffer> txn = env.txnRead();
-         CursorIterable<ByteBuffer> ci = db.iterate(txn)) {
+        CursorIterable<ByteBuffer> ci = db.iterate(txn)) {
       final Iterator<KeyVal<ByteBuffer>> iter = ci.iterator();
       final List<Integer> result = new ArrayList<>();
       while (iter.hasNext()) {
@@ -255,8 +249,8 @@ public void getName() {
 
   @Test
   public void getNamesWhenDbisPresent() {
-    final byte[] dbHello = new byte[]{'h', 'e', 'l', 'l', 'o'};
-    final byte[] dbWorld = new byte[]{'w', 'o', 'r', 'l', 'd'};
+    final byte[] dbHello = new byte[] {'h', 'e', 'l', 'l', 'o'};
+    final byte[] dbWorld = new byte[] {'w', 'o', 'r', 'l', 'd'};
     env.openDbi(dbHello, MDB_CREATE);
     env.openDbi(dbWorld, MDB_CREATE);
     final List<byte[]> dbiNames = env.getDbiNames();
@@ -273,8 +267,7 @@ public void getNamesWhenEmpty() {
 
   @Test
   public void listsFlags() {
-    final Dbi<ByteBuffer> dbi = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT,
-                                            MDB_REVERSEKEY);
+    final Dbi<ByteBuffer> dbi = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT, MDB_REVERSEKEY);
 
     try (Txn<ByteBuffer> txn = env.txnRead()) {
       final List<DbiFlags> flags = dbi.listFlags(txn);
@@ -332,11 +325,12 @@ public void putCommitGet() {
   @Test
   public void putCommitGetByteArray() throws IOException {
     final File path = tmp.newFile();
-    try (Env<byte[]> envBa = create(PROXY_BA)
-        .setMapSize(MEBIBYTES.toBytes(64))
-        .setMaxReaders(1)
-        .setMaxDbs(2)
-        .open(path, MDB_NOSUBDIR)) {
+    try (Env<byte[]> envBa =
+        create(PROXY_BA)
+            .setMapSize(MEBIBYTES.toBytes(64))
+            .setMaxReaders(1)
+            .setMaxDbs(2)
+            .open(path, MDB_NOSUBDIR)) {
       final Dbi<byte[]> db = envBa.openDbi(DB_1, MDB_CREATE);
       try (Txn<byte[]> txn = envBa.txnWrite()) {
         db.put(txn, ba(5), ba(5));
@@ -464,7 +458,6 @@ public void stats() {
   }
 
   @Test(expected = MapFullException.class)
-  @SuppressWarnings("PMD.PreserveStackTrace")
   public void testMapFullException() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
@@ -489,11 +482,12 @@ public void testParallelWritesStress() {
 
     // Travis CI has 1.5 cores for legacy builds
     nCopies(2, null).parallelStream()
-        .forEach(ignored -> {
-          for (int i = 0; i < 15_000; i++) {
-            db.put(bb(i), bb(i));
-          }
-        });
+        .forEach(
+            ignored -> {
+              for (int i = 0; i < 15_000; i++) {
+                db.put(bb(i), bb(i));
+              }
+            });
   }
 
   @Test(expected = AlreadyClosedException.class)
@@ -504,26 +498,22 @@ public void closedEnvRejectsOpenCall() {
 
   @Test(expected = AlreadyClosedException.class)
   public void closedEnvRejectsCloseCall() {
-    doEnvClosedTest(
-        null,
-        (db, txn) -> db.close());
+    doEnvClosedTest(null, (db, txn) -> db.close());
   }
 
   @Test(expected = AlreadyClosedException.class)
   public void closedEnvRejectsGetCall() {
     doEnvClosedTest(
         (db, txn) -> {
-        final ByteBuffer valBuf = db.get(txn, bb(1));
-        assertThat(valBuf.getInt(), is(10));
-      },
+          final ByteBuffer valBuf = db.get(txn, bb(1));
+          assertThat(valBuf.getInt(), is(10));
+        },
         (db, txn) -> db.get(txn, bb(2)));
   }
 
   @Test(expected = AlreadyClosedException.class)
   public void closedEnvRejectsPutCall() {
-    doEnvClosedTest(
-        null,
-        (db, txn) -> db.put(bb(5), bb(50)));
+    doEnvClosedTest(null, (db, txn) -> db.put(bb(5), bb(50)));
   }
 
   @Test(expected = AlreadyClosedException.class)
@@ -531,8 +521,8 @@ public void closedEnvRejectsPutWithTxnCall() {
     doEnvClosedTest(
         null,
         (db, txn) -> {
-        db.put(txn, bb(5), bb(50));
-      });
+          db.put(txn, bb(5), bb(50));
+        });
   }
 
   @Test(expected = AlreadyClosedException.class)
@@ -542,30 +532,22 @@ public void closedEnvRejectsIterateCall() {
 
   @Test(expected = AlreadyClosedException.class)
   public void closedEnvRejectsDropCall() {
-    doEnvClosedTest(
-        null,
-        Dbi::drop);
+    doEnvClosedTest(null, Dbi::drop);
   }
 
   @Test(expected = AlreadyClosedException.class)
   public void closedEnvRejectsDropAndDeleteCall() {
-    doEnvClosedTest(
-        null,
-        (db, txn) -> db.drop(txn, true));
+    doEnvClosedTest(null, (db, txn) -> db.drop(txn, true));
   }
 
   @Test(expected = AlreadyClosedException.class)
   public void closedEnvRejectsOpenCursorCall() {
-    doEnvClosedTest(
-        null,
-        Dbi::openCursor);
+    doEnvClosedTest(null, Dbi::openCursor);
   }
 
   @Test(expected = AlreadyClosedException.class)
   public void closedEnvRejectsReserveCall() {
-    doEnvClosedTest(
-        null,
-        (db, txn) -> db.reserve(txn, bb(1), 32, MDB_NOOVERWRITE));
+    doEnvClosedTest(null, (db, txn) -> db.reserve(txn, bb(1), 32, MDB_NOOVERWRITE));
   }
 
   @Test(expected = AlreadyClosedException.class)
@@ -596,5 +578,4 @@ private void doEnvClosedTest(
       }
     }
   }
-
 }
diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index 46d8766f..e71c6ae9 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -1,23 +1,18 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
 import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
@@ -42,8 +37,6 @@
 import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.util.Random;
-
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
@@ -54,21 +47,16 @@
 import org.lmdbjava.Env.MapFullException;
 import org.lmdbjava.Txn.BadReaderLockException;
 
-/**
- * Test {@link Env}.
- */
+/** Test {@link Env}. */
 public final class EnvTest {
 
-  @Rule
-  public final TemporaryFolder tmp = new TemporaryFolder();
+  @Rule public final TemporaryFolder tmp = new TemporaryFolder();
 
   @Test
   public void byteUnit() throws IOException {
     final File path = tmp.newFile();
-    try (Env<ByteBuffer> env = create()
-        .setMaxReaders(1)
-        .setMapSize(MEBIBYTES.toBytes(1))
-        .open(path, MDB_NOSUBDIR)) {
+    try (Env<ByteBuffer> env =
+        create().setMaxReaders(1).setMapSize(MEBIBYTES.toBytes(1)).open(path, MDB_NOSUBDIR)) {
       final EnvInfo info = env.info();
       assertThat(info.mapSize, is(MEBIBYTES.toBytes(1)));
     }
@@ -77,8 +65,7 @@ public void byteUnit() throws IOException {
   @Test(expected = AlreadyOpenException.class)
   public void cannotChangeMapSizeAfterOpen() throws IOException {
     final File path = tmp.newFile();
-    final Builder<ByteBuffer> builder = create()
-        .setMaxReaders(1);
+    final Builder<ByteBuffer> builder = create().setMaxReaders(1);
     try (Env<ByteBuffer> env = builder.open(path, MDB_NOSUBDIR)) {
       builder.setMapSize(1);
     }
@@ -87,8 +74,7 @@ public void cannotChangeMapSizeAfterOpen() throws IOException {
   @Test(expected = AlreadyOpenException.class)
   public void cannotChangeMaxDbsAfterOpen() throws IOException {
     final File path = tmp.newFile();
-    final Builder<ByteBuffer> builder = create()
-        .setMaxReaders(1);
+    final Builder<ByteBuffer> builder = create().setMaxReaders(1);
     try (Env<ByteBuffer> env = builder.open(path, MDB_NOSUBDIR)) {
       builder.setMaxDbs(1);
     }
@@ -97,8 +83,7 @@ public void cannotChangeMaxDbsAfterOpen() throws IOException {
   @Test(expected = AlreadyOpenException.class)
   public void cannotChangeMaxReadersAfterOpen() throws IOException {
     final File path = tmp.newFile();
-    final Builder<ByteBuffer> builder = create()
-        .setMaxReaders(1);
+    final Builder<ByteBuffer> builder = create().setMaxReaders(1);
     try (Env<ByteBuffer> env = builder.open(path, MDB_NOSUBDIR)) {
       builder.setMaxReaders(1);
     }
@@ -107,9 +92,7 @@ public void cannotChangeMaxReadersAfterOpen() throws IOException {
   @Test(expected = AlreadyClosedException.class)
   public void cannotInfoOnceClosed() throws IOException {
     final File path = tmp.newFile();
-    final Env<ByteBuffer> env = create()
-        .setMaxReaders(1)
-        .open(path, MDB_NOSUBDIR);
+    final Env<ByteBuffer> env = create().setMaxReaders(1).open(path, MDB_NOSUBDIR);
     env.close();
     env.info();
   }
@@ -117,8 +100,7 @@ public void cannotInfoOnceClosed() throws IOException {
   @Test(expected = AlreadyOpenException.class)
   public void cannotOpenTwice() throws IOException {
     final File path = tmp.newFile();
-    final Builder<ByteBuffer> builder = create()
-        .setMaxReaders(1);
+    final Builder<ByteBuffer> builder = create().setMaxReaders(1);
 
     builder.open(path, MDB_NOSUBDIR).close();
     builder.open(path, MDB_NOSUBDIR);
@@ -126,8 +108,7 @@ public void cannotOpenTwice() throws IOException {
 
   @Test(expected = IllegalArgumentException.class)
   public void cannotOverflowMapSize() {
-    final Builder<ByteBuffer> builder = create()
-        .setMaxReaders(1);
+    final Builder<ByteBuffer> builder = create().setMaxReaders(1);
     final int mb = 1_024 * 1_024;
     final int size = mb * 2_048; // as per issue 18
     builder.setMapSize(size);
@@ -136,9 +117,7 @@ public void cannotOverflowMapSize() {
   @Test(expected = AlreadyClosedException.class)
   public void cannotStatOnceClosed() throws IOException {
     final File path = tmp.newFile();
-    final Env<ByteBuffer> env = create()
-        .setMaxReaders(1)
-        .open(path, MDB_NOSUBDIR);
+    final Env<ByteBuffer> env = create().setMaxReaders(1).open(path, MDB_NOSUBDIR);
     env.close();
     env.stat();
   }
@@ -146,9 +125,7 @@ public void cannotStatOnceClosed() throws IOException {
   @Test(expected = AlreadyClosedException.class)
   public void cannotSyncOnceClosed() throws IOException {
     final File path = tmp.newFile();
-    final Env<ByteBuffer> env = create()
-        .setMaxReaders(1)
-        .open(path, MDB_NOSUBDIR);
+    final Env<ByteBuffer> env = create().setMaxReaders(1).open(path, MDB_NOSUBDIR);
     env.close();
     env.sync(false);
   }
@@ -160,9 +137,7 @@ public void copyDirectoryBased() throws IOException {
     assertThat(dest.isDirectory(), is(true));
     assertThat(dest.list().length, is(0));
     final File src = tmp.newFolder();
-    try (Env<ByteBuffer> env = create()
-        .setMaxReaders(1)
-        .open(src)) {
+    try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src)) {
       env.copy(dest, MDB_CP_COMPACT);
       assertThat(dest.list().length, is(1));
     }
@@ -172,9 +147,7 @@ public void copyDirectoryBased() throws IOException {
   public void copyDirectoryRejectsFileDestination() throws IOException {
     final File dest = tmp.newFile();
     final File src = tmp.newFolder();
-    try (Env<ByteBuffer> env = create()
-        .setMaxReaders(1)
-        .open(src)) {
+    try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src)) {
       env.copy(dest, MDB_CP_COMPACT);
     }
   }
@@ -184,9 +157,7 @@ public void copyDirectoryRejectsMissingDestination() throws IOException {
     final File dest = tmp.newFolder();
     assertThat(dest.delete(), is(true));
     final File src = tmp.newFolder();
-    try (Env<ByteBuffer> env = create()
-        .setMaxReaders(1)
-        .open(src)) {
+    try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src)) {
       env.copy(dest, MDB_CP_COMPACT);
     }
   }
@@ -197,9 +168,7 @@ public void copyDirectoryRejectsNonEmptyDestination() throws IOException {
     final File subDir = new File(dest, "hello");
     assertThat(subDir.mkdir(), is(true));
     final File src = tmp.newFolder();
-    try (Env<ByteBuffer> env = create()
-        .setMaxReaders(1)
-        .open(src)) {
+    try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src)) {
       env.copy(dest, MDB_CP_COMPACT);
     }
   }
@@ -210,9 +179,7 @@ public void copyFileBased() throws IOException {
     assertThat(dest.delete(), is(true));
     assertThat(dest.exists(), is(false));
     final File src = tmp.newFile();
-    try (Env<ByteBuffer> env = create()
-        .setMaxReaders(1)
-        .open(src, MDB_NOSUBDIR)) {
+    try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src, MDB_NOSUBDIR)) {
       env.copy(dest, MDB_CP_COMPACT);
     }
     assertThat(dest.length(), greaterThan(0L));
@@ -223,9 +190,7 @@ public void copyFileRejectsExistingDestination() throws IOException {
     final File dest = tmp.newFile();
     assertThat(dest.exists(), is(true));
     final File src = tmp.newFile();
-    try (Env<ByteBuffer> env = create()
-        .setMaxReaders(1)
-        .open(src, MDB_NOSUBDIR)) {
+    try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src, MDB_NOSUBDIR)) {
       env.copy(dest, MDB_CP_COMPACT);
     }
   }
@@ -233,9 +198,7 @@ public void copyFileRejectsExistingDestination() throws IOException {
   @Test
   public void createAsDirectory() throws IOException {
     final File path = tmp.newFolder();
-    final Env<ByteBuffer> env = create()
-        .setMaxReaders(1)
-        .open(path);
+    final Env<ByteBuffer> env = create().setMaxReaders(1).open(path);
     assertThat(path.isDirectory(), is(true));
     env.sync(false);
     env.close();
@@ -246,11 +209,8 @@ public void createAsDirectory() throws IOException {
   @Test
   public void createAsFile() throws IOException {
     final File path = tmp.newFile();
-    try (Env<ByteBuffer> env = create()
-        .setMapSize(1_024 * 1_024)
-        .setMaxDbs(1)
-        .setMaxReaders(1)
-        .open(path, MDB_NOSUBDIR)) {
+    try (Env<ByteBuffer> env =
+        create().setMapSize(1_024 * 1_024).setMaxDbs(1).setMaxReaders(1).open(path, MDB_NOSUBDIR)) {
       env.sync(true);
       assertThat(path.isFile(), is(true));
     }
@@ -259,9 +219,7 @@ public void createAsFile() throws IOException {
   @Test(expected = BadReaderLockException.class)
   public void detectTransactionThreadViolation() throws IOException {
     final File path = tmp.newFile();
-    try (Env<ByteBuffer> env = create()
-        .setMaxReaders(1)
-        .open(path, MDB_NOSUBDIR)) {
+    try (Env<ByteBuffer> env = create().setMaxReaders(1).open(path, MDB_NOSUBDIR)) {
       env.txnRead();
       env.txnRead();
     }
@@ -270,10 +228,8 @@ public void detectTransactionThreadViolation() throws IOException {
   @Test
   public void info() throws IOException {
     final File path = tmp.newFile();
-    try (Env<ByteBuffer> env = create()
-        .setMaxReaders(4)
-        .setMapSize(123_456)
-        .open(path, MDB_NOSUBDIR)) {
+    try (Env<ByteBuffer> env =
+        create().setMaxReaders(4).setMapSize(123_456).open(path, MDB_NOSUBDIR)) {
       final EnvInfo info = env.info();
       assertThat(info, is(notNullValue()));
       assertThat(info.lastPageNumber, is(1L));
@@ -288,19 +244,16 @@ public void info() throws IOException {
   }
 
   @Test(expected = MapFullException.class)
-  @SuppressFBWarnings("DMI_RANDOM_USED_ONLY_ONCE")
   public void mapFull() throws IOException {
     final File path = tmp.newFolder();
     final byte[] k = new byte[500];
     final ByteBuffer key = allocateDirect(500);
     final ByteBuffer val = allocateDirect(1_024);
     final Random rnd = new Random();
-    try (Env<ByteBuffer> env = create()
-        .setMaxReaders(1)
-        .setMapSize(MEBIBYTES.toBytes(8))
-        .setMaxDbs(1).open(path)) {
+    try (Env<ByteBuffer> env =
+        create().setMaxReaders(1).setMapSize(MEBIBYTES.toBytes(8)).setMaxDbs(1).open(path)) {
       final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
-      for (;;) {
+      for (; ; ) {
         rnd.nextBytes(k);
         key.clear();
         key.put(k).flip();
@@ -313,15 +266,11 @@ public void mapFull() throws IOException {
   @Test
   public void readOnlySupported() throws IOException {
     final File path = tmp.newFolder();
-    try (Env<ByteBuffer> rwEnv = create()
-        .setMaxReaders(1)
-        .open(path)) {
+    try (Env<ByteBuffer> rwEnv = create().setMaxReaders(1).open(path)) {
       final Dbi<ByteBuffer> rwDb = rwEnv.openDbi(DB_1, MDB_CREATE);
       rwDb.put(bb(1), bb(42));
     }
-    try (Env<ByteBuffer> roEnv = create()
-        .setMaxReaders(1)
-        .open(path, MDB_RDONLY_ENV)) {
+    try (Env<ByteBuffer> roEnv = create().setMaxReaders(1).open(path, MDB_RDONLY_ENV)) {
       final Dbi<ByteBuffer> roDb = roEnv.openDbi(DB_1);
       try (Txn<ByteBuffer> roTxn = roEnv.txnRead()) {
         assertThat(roDb.get(roTxn, bb(1)), notNullValue());
@@ -330,18 +279,14 @@ public void readOnlySupported() throws IOException {
   }
 
   @Test
-  @SuppressFBWarnings("DMI_RANDOM_USED_ONLY_ONCE")
   public void setMapSize() throws IOException {
     final File path = tmp.newFolder();
     final byte[] k = new byte[500];
     final ByteBuffer key = allocateDirect(500);
     final ByteBuffer val = allocateDirect(1_024);
     final Random rnd = new Random();
-    try (Env<ByteBuffer> env = create()
-        .setMaxReaders(1)
-        .setMapSize(KIBIBYTES.toBytes(256))
-        .setMaxDbs(1)
-        .open(path)) {
+    try (Env<ByteBuffer> env =
+        create().setMaxReaders(1).setMapSize(KIBIBYTES.toBytes(256)).setMaxDbs(1).open(path)) {
       final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
 
       db.put(bb(1), bb(42));
@@ -359,7 +304,7 @@ public void setMapSize() throws IOException {
       }
       assertThat(mapFullExThrown, is(true));
 
-      env.setMapSize(KIBIBYTES.toBytes(512));
+      env.setMapSize(KIBIBYTES.toBytes(1024));
 
       try (Txn<ByteBuffer> roTxn = env.txnRead()) {
         assertThat(db.get(roTxn, bb(1)).getInt(), is(42));
@@ -384,9 +329,7 @@ public void setMapSize() throws IOException {
   @Test
   public void stats() throws IOException {
     final File path = tmp.newFile();
-    try (Env<ByteBuffer> env = create()
-        .setMaxReaders(1)
-        .open(path, MDB_NOSUBDIR)) {
+    try (Env<ByteBuffer> env = create().setMaxReaders(1).open(path, MDB_NOSUBDIR)) {
       final Stat stat = env.stat();
       assertThat(stat, is(notNullValue()));
       assertThat(stat.branchPages, is(0L));
@@ -409,5 +352,4 @@ public void testDefaultOpen() throws IOException {
       db.put(allocateDirect(1), allocateDirect(1));
     }
   }
-
 }
diff --git a/src/test/java/org/lmdbjava/GarbageCollectionTest.java b/src/test/java/org/lmdbjava/GarbageCollectionTest.java
index 49d56b1d..7615f7f0 100644
--- a/src/test/java/org/lmdbjava/GarbageCollectionTest.java
+++ b/src/test/java/org/lmdbjava/GarbageCollectionTest.java
@@ -1,23 +1,18 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
 import static java.nio.ByteBuffer.allocateDirect;
@@ -29,32 +24,24 @@
 import java.io.File;
 import java.io.IOException;
 import java.nio.ByteBuffer;
-
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
 import org.mockito.MockedStatic;
 import org.mockito.Mockito;
 
-@SuppressFBWarnings({"DM_GC", "RV_RETURN_VALUE_IGNORED_NO_SIDE_EFFECT"})
-@SuppressWarnings("PMD.DoNotCallGarbageCollectionExplicitly")
 public class GarbageCollectionTest {
 
   private static final String DB_NAME = "my DB";
   private static final String KEY_PREFIX = "Uncorruptedkey";
   private static final String VAL_PREFIX = "Uncorruptedval";
 
-  @Rule
-  public final TemporaryFolder tmp = new TemporaryFolder();
+  @Rule public final TemporaryFolder tmp = new TemporaryFolder();
 
   @Test
   public void buffersNotGarbageCollectedTest() throws IOException {
     final File path = tmp.newFolder();
-    try (Env<ByteBuffer> env = create()
-        .setMapSize(2_085_760_999)
-        .setMaxDbs(1)
-        .open(path)) {
+    try (Env<ByteBuffer> env = create().setMapSize(2_085_760_999).setMaxDbs(1).open(path)) {
       final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
 
       try (Txn<ByteBuffer> txn = env.txnWrite()) {
@@ -66,12 +53,14 @@ public void buffersNotGarbageCollectedTest() throws IOException {
 
       // Call GC before writing to LMDB and after last reference to buffer by
       // changing the behavior of mask
-      try (MockedStatic<MaskedFlag> mockedStatic = Mockito.mockStatic(
-          MaskedFlag.class)) {
-        mockedStatic.when(MaskedFlag::mask).thenAnswer(invocationOnMock -> {
-          System.gc();
-          return 0;
-        });
+      try (MockedStatic<MaskedFlag> mockedStatic = Mockito.mockStatic(MaskedFlag.class)) {
+        mockedStatic
+            .when(MaskedFlag::mask)
+            .thenAnswer(
+                invocationOnMock -> {
+                  System.gc();
+                  return 0;
+                });
         final int gcRecordWrites = Integer.getInteger("gcRecordWrites", 50);
         try (Txn<ByteBuffer> txn = env.txnWrite()) {
           for (int i = 0; i < gcRecordWrites; i++) {
@@ -105,13 +94,11 @@ public void buffersNotGarbageCollectedTest() throws IOException {
     }
   }
 
-  private void putBuffer(final Dbi<ByteBuffer> db, final Txn<ByteBuffer> txn,
-                         final int i) {
+  private void putBuffer(final Dbi<ByteBuffer> db, final Txn<ByteBuffer> txn, final int i) {
     final ByteBuffer key = allocateDirect(24);
     final ByteBuffer val = allocateDirect(24);
     key.put((KEY_PREFIX + i).getBytes(UTF_8)).flip();
     val.put((VAL_PREFIX + i).getBytes(UTF_8)).flip();
     db.put(txn, key, val);
   }
-
 }
diff --git a/src/test/java/org/lmdbjava/KeyRangeTest.java b/src/test/java/org/lmdbjava/KeyRangeTest.java
index 3ea8c146..6e104bbf 100644
--- a/src/test/java/org/lmdbjava/KeyRangeTest.java
+++ b/src/test/java/org/lmdbjava/KeyRangeTest.java
@@ -1,23 +1,18 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
 import static org.hamcrest.CoreMatchers.is;
@@ -45,7 +40,6 @@
 
 import java.util.ArrayList;
 import java.util.List;
-
 import org.junit.Before;
 import org.junit.Test;
 import org.lmdbjava.KeyRangeType.CursorOp;
@@ -54,10 +48,8 @@
 /**
  * Test {@link KeyRange}.
  *
- * <p>
- * This test case focuses on the contractual correctness detailed in
- * {@link KeyRangeType}. It does this using integers as per the JavaDoc
- * examples.
+ * <p>This test case focuses on the contractual correctness detailed in {@link KeyRangeType}. It
+ * does this using integers as per the JavaDoc examples.
  */
 public final class KeyRangeTest {
 
@@ -203,8 +195,7 @@ private void verify(final KeyRange<Integer> range, final int... expected) {
 
     IteratorOp op;
     do {
-      op = range.getType().iteratorOp(range.getStart(), range.getStop(), buff,
-                                      Integer::compare);
+      op = range.getType().iteratorOp(range.getStart(), range.getStop(), buff, Integer::compare);
       switch (op) {
         case CALL_NEXT_OP:
           buff = cursor.apply(range.getType().nextOp(), range.getStart());
@@ -229,13 +220,12 @@ private void verify(final KeyRange<Integer> range, final int... expected) {
   /**
    * Cursor that behaves like an LMDB cursor would.
    *
-   * <p>
-   * We use <code>Integer</code> rather than the primitive to represent a
-   * <code>null</code> buffer.
+   * <p>We use <code>Integer</code> rather than the primitive to represent a <code>null</code>
+   * buffer.
    */
   private static final class FakeCursor {
 
-    private static final int[] KEYS = new int[]{2, 4, 6, 8};
+    private static final int[] KEYS = new int[] {2, 4, 6, 8};
     private int position;
 
     Integer apply(final CursorOp op, final Integer startKey) {
@@ -302,7 +292,5 @@ Integer prev() {
     void reset() {
       position = 0;
     }
-
   }
-
 }
diff --git a/src/test/java/org/lmdbjava/LibraryTest.java b/src/test/java/org/lmdbjava/LibraryTest.java
index df5ae89d..6dcfcee9 100644
--- a/src/test/java/org/lmdbjava/LibraryTest.java
+++ b/src/test/java/org/lmdbjava/LibraryTest.java
@@ -1,23 +1,18 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
 import static java.lang.Long.BYTES;
@@ -29,9 +24,7 @@
 import org.junit.Test;
 import org.lmdbjava.Library.MDB_envinfo;
 
-/**
- * Test {@link Library}.
- */
+/** Test {@link Library}. */
 public final class LibraryTest {
 
   @Test
diff --git a/src/test/java/org/lmdbjava/MaskedFlagTest.java b/src/test/java/org/lmdbjava/MaskedFlagTest.java
index 0dbc8b62..918bf922 100644
--- a/src/test/java/org/lmdbjava/MaskedFlagTest.java
+++ b/src/test/java/org/lmdbjava/MaskedFlagTest.java
@@ -1,23 +1,18 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
 import static org.hamcrest.CoreMatchers.is;
@@ -31,9 +26,7 @@
 
 import org.junit.Test;
 
-/**
- * Test {@link MaskedFlag}.
- */
+/** Test {@link MaskedFlag}. */
 public final class MaskedFlagTest {
 
   @Test
@@ -61,10 +54,10 @@ public void masking() {
     final EnvFlags[] nullFlags = null;
     assertThat(mask(nullFlags), is(0));
 
-    final EnvFlags[] emptyFlags = new EnvFlags[]{};
+    final EnvFlags[] emptyFlags = new EnvFlags[] {};
     assertThat(mask(emptyFlags), is(0));
 
-    final EnvFlags[] nullElementZero = new EnvFlags[]{null};
+    final EnvFlags[] nullElementZero = new EnvFlags[] {null};
     assertThat(nullElementZero, is(arrayWithSize(1)));
     assertThat(mask(nullElementZero), is(0));
 
diff --git a/src/test/java/org/lmdbjava/MetaTest.java b/src/test/java/org/lmdbjava/MetaTest.java
index 922c4368..be0faa87 100644
--- a/src/test/java/org/lmdbjava/MetaTest.java
+++ b/src/test/java/org/lmdbjava/MetaTest.java
@@ -1,23 +1,18 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
 import static org.hamcrest.CoreMatchers.is;
@@ -31,9 +26,7 @@
 import org.junit.Test;
 import org.lmdbjava.Meta.Version;
 
-/**
- * Test {@link Meta}.
- */
+/** Test {@link Meta}. */
 public final class MetaTest {
 
   @Test
@@ -43,8 +36,7 @@ public void coverPrivateConstructors() {
 
   @Test
   public void errCode() {
-    assertThat(error(MDB_CORRUPTED), is(
-               "MDB_CORRUPTED: Located page was wrong type"));
+    assertThat(error(MDB_CORRUPTED), is("MDB_CORRUPTED: Located page was wrong type"));
   }
 
   @Test
@@ -54,5 +46,4 @@ public void version() {
     assertThat(v.major, is(0));
     assertThat(v.minor, is(9));
   }
-
 }
diff --git a/src/test/java/org/lmdbjava/ResultCodeMapperTest.java b/src/test/java/org/lmdbjava/ResultCodeMapperTest.java
index 723c22ca..7a3764ed 100644
--- a/src/test/java/org/lmdbjava/ResultCodeMapperTest.java
+++ b/src/test/java/org/lmdbjava/ResultCodeMapperTest.java
@@ -1,23 +1,18 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
 import static java.lang.Integer.MAX_VALUE;
@@ -33,7 +28,6 @@
 
 import java.util.HashSet;
 import java.util.Set;
-
 import org.junit.Test;
 import org.lmdbjava.Cursor.FullException;
 import org.lmdbjava.Dbi.BadDbiException;
@@ -57,9 +51,7 @@
 import org.lmdbjava.Txn.BadReaderLockException;
 import org.lmdbjava.Txn.TxFullException;
 
-/**
- * Test {@link ResultCodeMapper} and {@link LmdbException}.
- */
+/** Test {@link ResultCodeMapper} and {@link LmdbException}. */
 public final class ResultCodeMapperTest {
 
   private static final Set<LmdbNativeException> EXCEPTIONS = new HashSet<>();
@@ -161,5 +153,4 @@ public void mapperReturnsUnique() {
   public void noDuplicateResultCodes() {
     assertThat(RESULT_CODES.size(), is(EXCEPTIONS.size()));
   }
-
 }
diff --git a/src/test/java/org/lmdbjava/TargetNameTest.java b/src/test/java/org/lmdbjava/TargetNameTest.java
index eec38233..b598be55 100644
--- a/src/test/java/org/lmdbjava/TargetNameTest.java
+++ b/src/test/java/org/lmdbjava/TargetNameTest.java
@@ -1,23 +1,18 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
 import static org.hamcrest.CoreMatchers.is;
@@ -28,9 +23,7 @@
 
 import org.junit.Test;
 
-/**
- * Test {@link TargetName}.
- */
+/** Test {@link TargetName}. */
 public final class TargetNameTest {
 
   private static final String NONE = "";
diff --git a/src/test/java/org/lmdbjava/TestUtils.java b/src/test/java/org/lmdbjava/TestUtils.java
index 05dfb0cc..42dcf052 100644
--- a/src/test/java/org/lmdbjava/TestUtils.java
+++ b/src/test/java/org/lmdbjava/TestUtils.java
@@ -1,50 +1,39 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
 import static io.netty.buffer.PooledByteBufAllocator.DEFAULT;
 import static java.lang.Integer.BYTES;
 import static java.nio.ByteBuffer.allocateDirect;
 
+import io.netty.buffer.ByteBuf;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
 import java.nio.ByteBuffer;
-
-import io.netty.buffer.ByteBuf;
 import org.agrona.MutableDirectBuffer;
 import org.agrona.concurrent.UnsafeBuffer;
 
-/**
- * Static constants and methods that are convenient when writing LMDB-related
- * tests.
- */
+/** Static constants and methods that are convenient when writing LMDB-related tests. */
 final class TestUtils {
 
   public static final String DB_1 = "test-db-1";
 
-  @SuppressWarnings("PMD.AvoidUsingOctalValues")
   public static final int POSIX_MODE = 0664;
 
-  private TestUtils() {
-  }
+  private TestUtils() {}
 
   static byte[] ba(final int value) {
     final MutableDirectBuffer b = new UnsafeBuffer(new byte[4]);
@@ -63,9 +52,11 @@ static void invokePrivateConstructor(final Class<?> clazz) {
       final Constructor<?> c = clazz.getDeclaredConstructor();
       c.setAccessible(true);
       c.newInstance();
-    } catch (final NoSuchMethodException | InstantiationException
-                       | IllegalAccessException | IllegalArgumentException
-                       | InvocationTargetException e) {
+    } catch (final NoSuchMethodException
+        | InstantiationException
+        | IllegalAccessException
+        | IllegalArgumentException
+        | InvocationTargetException e) {
       throw new LmdbException("Private construction failed", e);
     }
   }
@@ -81,5 +72,4 @@ static ByteBuf nb(final int value) {
     b.writeInt(value);
     return b;
   }
-
 }
diff --git a/src/test/java/org/lmdbjava/TutorialTest.java b/src/test/java/org/lmdbjava/TutorialTest.java
index 0385d952..b86c1d2a 100644
--- a/src/test/java/org/lmdbjava/TutorialTest.java
+++ b/src/test/java/org/lmdbjava/TutorialTest.java
@@ -1,23 +1,18 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
 import static java.nio.ByteBuffer.allocateDirect;
@@ -44,7 +39,6 @@
 import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.util.concurrent.ExecutorService;
-
 import org.agrona.DirectBuffer;
 import org.agrona.MutableDirectBuffer;
 import org.agrona.concurrent.UnsafeBuffer;
@@ -56,25 +50,20 @@
 /**
  * Welcome to LmdbJava!
  *
- * <p>
- * This short tutorial will walk you through using LmdbJava step-by-step.
+ * <p>This short tutorial will walk you through using LmdbJava step-by-step.
  *
- * <p>
- * If you are using a 64-bit Windows, Linux or OS X machine, you can simply run
- * this tutorial by adding the LmdbJava JAR to your classpath. It includes the
- * required system libraries. If you are using another 64-bit platform, you'll
- * need to install the LMDB system library yourself. 32-bit platforms are not
- * supported.
+ * <p>If you are using a 64-bit Windows, Linux or OS X machine, you can simply run this tutorial by
+ * adding the LmdbJava JAR to your classpath. It includes the required system libraries. If you are
+ * using another 64-bit platform, you'll need to install the LMDB system library yourself. 32-bit
+ * platforms are not supported.
  *
- * <p>
- * Start the JVM with arguments <code>--add-opens java.base/java.nio=ALL-UNNAMED
+ * <p>Start the JVM with arguments <code>--add-opens java.base/java.nio=ALL-UNNAMED
  * --add-opens java.base/sun.nio.ch=ALL-UNNAMED</code> to suppress JVM warnings.
  */
 public final class TutorialTest {
 
   private static final String DB_NAME = "my DB";
-  @Rule
-  public final TemporaryFolder tmp = new TemporaryFolder();
+  @Rule public final TemporaryFolder tmp = new TemporaryFolder();
 
   /**
    * In this first tutorial we will use LmdbJava with some basic defaults.
@@ -82,7 +71,6 @@ public final class TutorialTest {
    * @throws IOException if a path was unavailable for memory mapping
    */
   @Test
-  @SuppressWarnings("ConvertToTryWithResources")
   public void tutorial1() throws IOException {
     // We need a storage directory first.
     // The path cannot be on a remote file system.
@@ -90,15 +78,16 @@ public void tutorial1() throws IOException {
 
     // We always need an Env. An Env owns a physical on-disk storage file. One
     // Env can store many different databases (ie sorted maps).
-    final Env<ByteBuffer> env = create()
-        // LMDB also needs to know how large our DB might be. Over-estimating is OK.
-        .setMapSize(10_485_760)
-        // LMDB also needs to know how many DBs (Dbi) we want to store in this Env.
-        .setMaxDbs(1)
-        // Now let's open the Env. The same path can be concurrently opened and
-        // used in different processes, but do not open the same path twice in
-        // the same process at the same time.
-        .open(path);
+    final Env<ByteBuffer> env =
+        create()
+            // LMDB also needs to know how large our DB might be. Over-estimating is OK.
+            .setMapSize(10_485_760)
+            // LMDB also needs to know how many DBs (Dbi) we want to store in this Env.
+            .setMaxDbs(1)
+            // Now let's open the Env. The same path can be concurrently opened and
+            // used in different processes, but do not open the same path twice in
+            // the same process at the same time.
+            .open(path);
 
     // We need a Dbi for each DB. A Dbi roughly equates to a sorted map. The
     // MDB_CREATE flag causes the DB to be created if it doesn't already exist.
@@ -149,11 +138,10 @@ public void tutorial1() throws IOException {
   /**
    * In this second tutorial we'll learn more about LMDB's ACID Txns.
    *
-   * @throws IOException          if a path was unavailable for memory mapping
+   * @throws IOException if a path was unavailable for memory mapping
    * @throws InterruptedException if executor shutdown interrupted
    */
   @Test
-  @SuppressWarnings("ConvertToTryWithResources")
   public void tutorial2() throws IOException, InterruptedException {
     final Env<ByteBuffer> env = createSimpleEnv(tmp.newFolder());
     final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
@@ -188,14 +176,15 @@ public void tutorial2() throws IOException, InterruptedException {
     //
     // Let's write out a "key2" via a new write Txn in a different thread.
     final ExecutorService es = newCachedThreadPool();
-    es.execute(() -> {
-      try (Txn<ByteBuffer> txn = env.txnWrite()) {
-        key.clear();
-        key.put("key2".getBytes(UTF_8)).flip();
-        db.put(txn, key, val);
-        txn.commit();
-      }
-    });
+    es.execute(
+        () -> {
+          try (Txn<ByteBuffer> txn = env.txnWrite()) {
+            key.clear();
+            key.put("key2".getBytes(UTF_8)).flip();
+            db.put(txn, key, val);
+            txn.commit();
+          }
+        });
     es.shutdown();
     es.awaitTermination(10, SECONDS);
 
@@ -220,14 +209,13 @@ public void tutorial2() throws IOException, InterruptedException {
   }
 
   /**
-   * In this third tutorial we'll have a look at the Cursor. Up until now we've
-   * just used Dbi, which is good enough for simple cases but unsuitable if you
-   * don't know the key to fetch, or want to iterate over all the data etc.
+   * In this third tutorial we'll have a look at the Cursor. Up until now we've just used Dbi, which
+   * is good enough for simple cases but unsuitable if you don't know the key to fetch, or want to
+   * iterate over all the data etc.
    *
    * @throws IOException if a path was unavailable for memory mapping
    */
   @Test
-  @SuppressWarnings("ConvertToTryWithResources")
   public void tutorial3() throws IOException {
     final Env<ByteBuffer> env = createSimpleEnv(tmp.newFolder());
     final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
@@ -296,13 +284,12 @@ public void tutorial3() throws IOException {
   }
 
   /**
-   * In this fourth tutorial we'll take a quick look at the iterators. These are
-   * a more Java idiomatic form of using the Cursors we looked at in tutorial 3.
+   * In this fourth tutorial we'll take a quick look at the iterators. These are a more Java
+   * idiomatic form of using the Cursors we looked at in tutorial 3.
    *
    * @throws IOException if a path was unavailable for memory mapping
    */
   @Test
-  @SuppressWarnings("ConvertToTryWithResources")
   public void tutorial4() throws IOException {
     final Env<ByteBuffer> env = createSimpleEnv(tmp.newFolder());
     final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
@@ -332,8 +319,7 @@ public void tutorial4() throws IOException {
       }
 
       // Iterate backward in terms of key ordering starting with the last key.
-      try (CursorIterable<ByteBuffer> ci = db.iterate(txn,
-                                                      KeyRange.allBackward())) {
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.allBackward())) {
         for (final KeyVal<ByteBuffer> kv : ci) {
           assertThat(kv.key(), notNullValue());
           assertThat(kv.val(), notNullValue());
@@ -362,7 +348,6 @@ public void tutorial4() throws IOException {
    * @throws IOException if a path was unavailable for memory mapping
    */
   @Test
-  @SuppressWarnings("ConvertToTryWithResources")
   public void tutorial5() throws IOException {
     final Env<ByteBuffer> env = createSimpleEnv(tmp.newFolder());
 
@@ -410,20 +395,19 @@ public void tutorial5() throws IOException {
   }
 
   /**
-   * Next up we'll show you how to easily check your platform (operating system
-   * and Java version) is working properly with LmdbJava and the embedded LMDB
-   * native library.
+   * Next up we'll show you how to easily check your platform (operating system and Java version) is
+   * working properly with LmdbJava and the embedded LMDB native library.
    *
    * @throws IOException if a path was unavailable for memory mapping
    */
   @Test
-  @SuppressWarnings("ConvertToTryWithResources")
   public void tutorial6() throws IOException {
     // Note we need to specify the Verifier's DBI_COUNT for the Env.
-    final Env<ByteBuffer> env = create(PROXY_OPTIMAL)
-        .setMapSize(10_485_760)
-        .setMaxDbs(Verifier.DBI_COUNT)
-        .open(tmp.newFolder());
+    final Env<ByteBuffer> env =
+        create(PROXY_OPTIMAL)
+            .setMapSize(10_485_760)
+            .setMaxDbs(Verifier.DBI_COUNT)
+            .open(tmp.newFolder());
 
     // Create a Verifier (it's a Callable<Long> for those needing full control).
     final Verifier v = new Verifier(env);
@@ -441,15 +425,12 @@ public void tutorial6() throws IOException {
    * @throws IOException if a path was unavailable for memory mapping
    */
   @Test
-  @SuppressWarnings("ConvertToTryWithResources")
   public void tutorial7() throws IOException {
     // The critical difference is we pass the PROXY_DB field to Env.create().
     // There's also a PROXY_SAFE if you want to stop ByteBuffer's Unsafe use.
     // Aside from that and a different type argument, it's the same as usual...
-    final Env<DirectBuffer> env = create(PROXY_DB)
-        .setMapSize(10_485_760)
-        .setMaxDbs(1)
-        .open(tmp.newFolder());
+    final Env<DirectBuffer> env =
+        create(PROXY_DB).setMapSize(10_485_760).setMaxDbs(1).open(tmp.newFolder());
 
     final Dbi<DirectBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
 
@@ -468,12 +449,10 @@ public void tutorial7() throws IOException {
         c.put(key, val);
 
         c.seek(MDB_FIRST);
-        assertThat(c.key().getStringWithoutLengthUtf8(0, env.getMaxKeySize()),
-                   startsWith("ggg"));
+        assertThat(c.key().getStringWithoutLengthUtf8(0, env.getMaxKeySize()), startsWith("ggg"));
 
         c.seek(MDB_LAST);
-        assertThat(c.key().getStringWithoutLengthUtf8(0, env.getMaxKeySize()),
-                   startsWith("yyy"));
+        assertThat(c.key().getStringWithoutLengthUtf8(0, env.getMaxKeySize()), startsWith("yyy"));
 
         // DirectBuffer has no position concept. Often you don't want to store
         // the unnecessary bytes of a varying-size buffer. Let's have a look...
@@ -487,8 +466,7 @@ public void tutorial7() throws IOException {
         c.put(key, val);
         c.seek(MDB_FIRST);
         assertThat(c.key().capacity(), is(keyLen));
-        assertThat(c.key().getStringWithoutLengthUtf8(0, c.key().capacity()),
-                   is("12characters"));
+        assertThat(c.key().getStringWithoutLengthUtf8(0, c.key().capacity()), is("12characters"));
 
         // To store bigger values again, just wrap the original buffer.
         key.wrap(keyBb);
@@ -505,11 +483,6 @@ public void tutorial7() throws IOException {
   // or reverse ordered keys, using Env.DISABLE_CHECKS_PROP etc), but you now
   // know enough to tackle the JavaDocs with confidence. Have fun!
   private Env<ByteBuffer> createSimpleEnv(final File path) {
-    return create()
-        .setMapSize(10_485_760)
-        .setMaxDbs(1)
-        .setMaxReaders(1)
-        .open(path);
+    return create().setMapSize(10_485_760).setMaxDbs(1).setMaxReaders(1).open(path);
   }
-
 }
diff --git a/src/test/java/org/lmdbjava/TxnTest.java b/src/test/java/org/lmdbjava/TxnTest.java
index 775a10a6..e768e424 100644
--- a/src/test/java/org/lmdbjava/TxnTest.java
+++ b/src/test/java/org/lmdbjava/TxnTest.java
@@ -1,23 +1,18 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
 import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
@@ -49,7 +44,6 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicLong;
-
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Rule;
@@ -65,13 +59,10 @@
 import org.lmdbjava.Txn.ReadWriteRequiredException;
 import org.lmdbjava.Txn.ResetException;
 
-/**
- * Test {@link Txn}.
- */
+/** Test {@link Txn}. */
 public final class TxnTest {
 
-  @Rule
-  public final TemporaryFolder tmp = new TemporaryFolder();
+  @Rule public final TemporaryFolder tmp = new TemporaryFolder();
   private Env<ByteBuffer> env;
   private File path;
 
@@ -83,11 +74,12 @@ public void after() {
   @Before
   public void before() throws IOException {
     path = tmp.newFile();
-    env = create()
-        .setMapSize(KIBIBYTES.toBytes(256))
-        .setMaxReaders(1)
-        .setMaxDbs(2)
-        .open(path, POSIX_MODE, MDB_NOSUBDIR);
+    env =
+        create()
+            .setMapSize(KIBIBYTES.toBytes(256))
+            .setMaxReaders(1)
+            .setMaxDbs(2)
+            .open(path, POSIX_MODE, MDB_NOSUBDIR);
   }
 
   @Test(expected = BadValueSizeException.class)
@@ -129,16 +121,14 @@ public void rangeSearch() {
       }
 
       assertEquals(3, keysFound.size());
-
     }
   }
 
   @Test
   public void readOnlyTxnAllowedInReadOnlyEnv() {
     env.openDbi(DB_1, MDB_CREATE);
-    try (Env<ByteBuffer> roEnv = create()
-        .setMaxReaders(1)
-        .open(path, MDB_NOSUBDIR, MDB_RDONLY_ENV)) {
+    try (Env<ByteBuffer> roEnv =
+        create().setMaxReaders(1).open(path, MDB_NOSUBDIR, MDB_RDONLY_ENV)) {
       assertThat(roEnv.txnRead(), is(notNullValue()));
     }
   }
@@ -147,9 +137,8 @@ public void readOnlyTxnAllowedInReadOnlyEnv() {
   public void readWriteTxnDeniedInReadOnlyEnv() {
     env.openDbi(DB_1, MDB_CREATE);
     env.close();
-    try (Env<ByteBuffer> roEnv = create()
-        .setMaxReaders(1)
-        .open(path, MDB_NOSUBDIR, MDB_RDONLY_ENV)) {
+    try (Env<ByteBuffer> roEnv =
+        create().setMaxReaders(1).open(path, MDB_NOSUBDIR, MDB_RDONLY_ENV)) {
       roEnv.txnWrite(); // error
     }
   }
@@ -224,7 +213,6 @@ public void txCannotCommitTwice() {
   }
 
   @Test(expected = AlreadyClosedException.class)
-  @SuppressWarnings("ResultOfObjectAllocationIgnored")
   public void txConstructionDeniedIfEnvClosed() {
     env.close();
     env.txnRead();
@@ -269,7 +257,7 @@ public void txResetDeniedIfEnvClosed() {
   @Test
   public void txParent() {
     try (Txn<ByteBuffer> txRoot = env.txnWrite();
-         Txn<ByteBuffer> txChild = env.txn(txRoot)) {
+        Txn<ByteBuffer> txChild = env.txn(txRoot)) {
       assertThat(txRoot.getParent(), is(nullValue()));
       assertThat(txChild.getParent(), is(txRoot));
     }
@@ -278,7 +266,7 @@ public void txParent() {
   @Test(expected = AlreadyClosedException.class)
   public void txParentDeniedIfEnvClosed() {
     try (Txn<ByteBuffer> txRoot = env.txnWrite();
-         Txn<ByteBuffer> txChild = env.txn(txRoot)) {
+        Txn<ByteBuffer> txChild = env.txn(txRoot)) {
       env.close();
       assertThat(txChild.getParent(), is(txRoot));
     }
@@ -363,5 +351,4 @@ public void zeroByteKeysRejected() throws IOException {
     assertThat(key.remaining(), is(0)); // because key.flip() skipped
     dbi.put(key, bb(2));
   }
-
 }
diff --git a/src/test/java/org/lmdbjava/VerifierTest.java b/src/test/java/org/lmdbjava/VerifierTest.java
index 41f4e774..c57e26dc 100644
--- a/src/test/java/org/lmdbjava/VerifierTest.java
+++ b/src/test/java/org/lmdbjava/VerifierTest.java
@@ -1,23 +1,18 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
  */
-
 package org.lmdbjava;
 
 import static com.jakewharton.byteunits.BinaryByteUnit.MEBIBYTES;
@@ -30,31 +25,27 @@
 import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.util.concurrent.TimeUnit;
-
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
 
-/**
- * Test {@link Verifier}.
- */
+/** Test {@link Verifier}. */
 public final class VerifierTest {
 
-  @Rule
-  public final TemporaryFolder tmp = new TemporaryFolder();
+  @Rule public final TemporaryFolder tmp = new TemporaryFolder();
 
   @Test
   public void verification() throws IOException {
     final File path = tmp.newFile();
-    try (Env<ByteBuffer> env = create()
-        .setMaxReaders(1)
-        .setMaxDbs(Verifier.DBI_COUNT)
-        .setMapSize(MEBIBYTES.toBytes(10))
-        .open(path, MDB_NOSUBDIR)) {
+    try (Env<ByteBuffer> env =
+        create()
+            .setMaxReaders(1)
+            .setMaxDbs(Verifier.DBI_COUNT)
+            .setMapSize(MEBIBYTES.toBytes(10))
+            .open(path, MDB_NOSUBDIR)) {
       final Verifier v = new Verifier(env);
       final int seconds = Integer.getInteger("verificationSeconds", 2);
       assertThat(v.runFor(seconds, TimeUnit.SECONDS), greaterThan(1L));
     }
   }
-
 }
diff --git a/src/test/java/org/lmdbjava/package-info.java b/src/test/java/org/lmdbjava/package-info.java
index baaacbe8..950fc2db 100644
--- a/src/test/java/org/lmdbjava/package-info.java
+++ b/src/test/java/org/lmdbjava/package-info.java
@@ -1,24 +1,16 @@
-/*-
- * #%L
- * LmdbJava
- * %%
- * Copyright (C) 2016 - 2023 The LmdbJava Open Source Project
- * %%
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- * #L%
- */
-
-/**
- * Lightning Memory Database (LMDB) for Java (LmdbJava) tests.
  */
 package org.lmdbjava;

From bdde404e16f6b2324b2d2f9043e3cd9fe5f6676b Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 17 Feb 2025 14:20:15 +1100
Subject: [PATCH 188/322] Update to CodeQL v3

---
 .github/workflows/codeql.yml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml
index dd93488f..b503370a 100644
--- a/.github/workflows/codeql.yml
+++ b/.github/workflows/codeql.yml
@@ -27,15 +27,15 @@ jobs:
         uses: actions/checkout@v3
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v2
+        uses: github/codeql-action/init@v3
         with:
           languages: ${{ matrix.language }}
           queries: +security-and-quality
 
       - name: Autobuild
-        uses: github/codeql-action/autobuild@v2
+        uses: github/codeql-action/autobuild@v3
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v2
+        uses: github/codeql-action/analyze@v3
         with:
           category: "/language:${{ matrix.language }}"

From 27123765132331540e60adbaadb4d06f63516f1d Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 17 Feb 2025 15:03:45 +1100
Subject: [PATCH 189/322] Update contributor docs to reflect build system
 configuration

---
 CONTRIBUTING.md | 10 ++++++----
 README.md       |  5 -----
 2 files changed, 6 insertions(+), 9 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 53a6b14e..c37bf055 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -7,11 +7,13 @@ This will run:
 
 * Tests
 * Initial Test Coverage
-* Checkstyle
-* PMD
-* FindBugs
-* XML Formatting
+* Source Code Formatting
 * License Header Management
 
 `mvn clean verify` is also run by CI, but it's quicker and easier to run
 before submitting.
+
+### Releasing
+
+GitHub Actions will perform an official release whenever a developer executes
+`mvn release:clean release:prepare`.
diff --git a/README.md b/README.md
index 62c5abe1..048e57bc 100644
--- a/README.md
+++ b/README.md
@@ -73,11 +73,6 @@ system package managers, running `cross-compile.sh` on a supported system, or
 copying it from the `org/lmdbjava` directory of any recent, officially released
 LmdbJava JAR.
 
-### Releasing
-
-GitHub Actions will perform an official release whenever a developer executes
-`mvn release:clean release:prepare`.
-
 ### Contributing
 
 Contributions are welcome! Please see the [Contributing Guidelines](CONTRIBUTING.md).

From 6ca74b9f71695057991d9940564345e0074f0fc0 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 17 Feb 2025 15:14:22 +1100
Subject: [PATCH 190/322] Update to Guava 33.4.0-jre

---
 pom.xml | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/pom.xml b/pom.xml
index 9e695d0f..8eb9523d 100644
--- a/pom.xml
+++ b/pom.xml
@@ -47,14 +47,8 @@
     <dependency>
       <groupId>com.google.guava</groupId>
       <artifactId>guava</artifactId>
-      <version>32.1.3-jre</version>
+      <version>33.4.0-jre</version>
       <scope>test</scope>
-      <exclusions>
-        <exclusion>
-          <groupId>com.google.code.findbugs</groupId>
-          <artifactId>jsr305</artifactId>
-        </exclusion>
-      </exclusions>
     </dependency>
     <dependency>
       <groupId>com.jakewharton.byteunits</groupId>

From f0d61735382c37674826bebeacf3a6d3486d668d Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 17 Feb 2025 15:14:31 +1100
Subject: [PATCH 191/322] Update to Netty 4.1.118.Final

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 8eb9523d..616ea85d 100644
--- a/pom.xml
+++ b/pom.xml
@@ -59,7 +59,7 @@
     <dependency>
       <groupId>io.netty</groupId>
       <artifactId>netty-buffer</artifactId>
-      <version>4.1.101.Final</version>
+      <version>4.1.118.Final</version>
       <optional>true</optional>
     </dependency>
     <dependency>

From ce6451f8e1087ebd1165d3576d553b86d596fb14 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 17 Feb 2025 15:14:42 +1100
Subject: [PATCH 192/322] Update to Agrona 2.0.1

---
 pom.xml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pom.xml b/pom.xml
index 616ea85d..4dd7cd61 100644
--- a/pom.xml
+++ b/pom.xml
@@ -77,7 +77,7 @@
     <dependency>
       <groupId>org.agrona</groupId>
       <artifactId>agrona</artifactId>
-      <version>1.20.0</version>
+      <version>2.0.1</version>
       <optional>true</optional>
     </dependency>
     <dependency>
@@ -397,7 +397,7 @@
             <groupId>org.apache.maven.plugins</groupId>
             <artifactId>maven-surefire-plugin</artifactId>
             <configuration>
-              <argLine>@{argLine} --add-opens java.base/java.nio=ALL-UNNAMED --add-opens java.base/sun.nio.ch=ALL-UNNAMED</argLine>
+              <argLine>@{argLine} --add-opens java.base/java.nio=ALL-UNNAMED --add-opens java.base/sun.nio.ch=ALL-UNNAMED --add-opens java.base/jdk.internal.misc=ALL-UNNAMED</argLine>
               <forkCount>1</forkCount>
               <reuseForks>false</reuseForks>
             </configuration>

From 9cd5c42ae0d51948cd12cc914fc448243dff314c Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Mon, 17 Feb 2025 15:23:28 +1100
Subject: [PATCH 193/322] Update to Agrona 1.22.0 and note JDK 17+ for later
 versions

---
 pom.xml | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/pom.xml b/pom.xml
index 4dd7cd61..6f53c90e 100644
--- a/pom.xml
+++ b/pom.xml
@@ -77,7 +77,8 @@
     <dependency>
       <groupId>org.agrona</groupId>
       <artifactId>agrona</artifactId>
-      <version>2.0.1</version>
+      <!-- 1.23.0 requires Java 17+ -->
+      <version>1.22.0</version>
       <optional>true</optional>
     </dependency>
     <dependency>
@@ -397,7 +398,7 @@
             <groupId>org.apache.maven.plugins</groupId>
             <artifactId>maven-surefire-plugin</artifactId>
             <configuration>
-              <argLine>@{argLine} --add-opens java.base/java.nio=ALL-UNNAMED --add-opens java.base/sun.nio.ch=ALL-UNNAMED --add-opens java.base/jdk.internal.misc=ALL-UNNAMED</argLine>
+              <argLine>@{argLine} --add-opens java.base/java.nio=ALL-UNNAMED --add-opens java.base/sun.nio.ch=ALL-UNNAMED</argLine>
               <forkCount>1</forkCount>
               <reuseForks>false</reuseForks>
             </configuration>

From 928cf7baaabf40914a43a137ebc7d47797ead695 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Thu, 20 Feb 2025 12:26:13 +1100
Subject: [PATCH 194/322] Add url element to pom.xml to satisfy OSSRH
 deployment rules

---
 pom.xml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/pom.xml b/pom.xml
index 6f53c90e..e71e2271 100644
--- a/pom.xml
+++ b/pom.xml
@@ -333,6 +333,7 @@
       </plugin>
     </plugins>
   </build>
+  <url>https://github.com/lmdbjava/lmdbjava</url>
   <inceptionYear>2016</inceptionYear>
   <organization>
     <name>The LmdbJava Open Source Project</name>

From 0025a4875c2b08645e93c8acc6f2225b2a7c4046 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Thu, 20 Feb 2025 12:28:16 +1100
Subject: [PATCH 195/322] [maven-release-plugin] prepare release lmdbjava-0.9.1

---
 pom.xml | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/pom.xml b/pom.xml
index e71e2271..e7d1d298 100644
--- a/pom.xml
+++ b/pom.xml
@@ -20,7 +20,7 @@
   <modelVersion>4.0.0</modelVersion>
   <groupId>org.lmdbjava</groupId>
   <artifactId>lmdbjava</artifactId>
-  <version>0.9.1-SNAPSHOT</version>
+  <version>0.9.1</version>
   <packaging>jar</packaging>
   <name>LmdbJava</name>
   <description>Low latency Java API for the ultra-fast, embedded Symas Lightning Database (LMDB)</description>
@@ -184,19 +184,19 @@
             </goals>
             <configuration>
               <rules>
-                <dependencyConvergence/>
+                <dependencyConvergence />
                 <requireMavenVersion>
                   <version>[${maven.enforcer.mvn},)</version>
                 </requireMavenVersion>
                 <requireJavaVersion>
                   <version>[${maven.enforcer.java},)</version>
                 </requireJavaVersion>
-                <requireNoRepositories/>
-                <requirePluginVersions/>
+                <requireNoRepositories />
+                <requirePluginVersions />
                 <requireReleaseDeps>
                   <onlyWhenRelease>true</onlyWhenRelease>
                 </requireReleaseDeps>
-                <requireUpperBoundDeps/>
+                <requireUpperBoundDeps />
               </rules>
             </configuration>
           </execution>
@@ -351,7 +351,7 @@
       <name>Kristoffer Sjogren</name>
       <email>stoffe -at- gmail.com</email>
       <url>http://stoffe.deephacks.org/</url>
-      <organization/>
+      <organization />
       <timezone>+1</timezone>
     </developer>
     <developer>
@@ -367,7 +367,7 @@
     <connection>scm:git:git@github.com:lmdbjava/lmdbjava.git</connection>
     <developerConnection>scm:git:git@github.com:lmdbjava/lmdbjava.git</developerConnection>
     <url>git@github.com:lmdbjava/lmdbjava.git</url>
-    <tag>HEAD</tag>
+    <tag>lmdbjava-0.9.1</tag>
   </scm>
   <issueManagement>
     <system>GitHub Issues</system>

From 154df33aa6b196a96e8abe7a3e145b62cc08f382 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Thu, 20 Feb 2025 12:28:23 +1100
Subject: [PATCH 196/322] [maven-release-plugin] prepare for next development
 iteration

---
 pom.xml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pom.xml b/pom.xml
index e7d1d298..b3012729 100644
--- a/pom.xml
+++ b/pom.xml
@@ -20,7 +20,7 @@
   <modelVersion>4.0.0</modelVersion>
   <groupId>org.lmdbjava</groupId>
   <artifactId>lmdbjava</artifactId>
-  <version>0.9.1</version>
+  <version>0.9.2-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>LmdbJava</name>
   <description>Low latency Java API for the ultra-fast, embedded Symas Lightning Database (LMDB)</description>
@@ -367,7 +367,7 @@
     <connection>scm:git:git@github.com:lmdbjava/lmdbjava.git</connection>
     <developerConnection>scm:git:git@github.com:lmdbjava/lmdbjava.git</developerConnection>
     <url>git@github.com:lmdbjava/lmdbjava.git</url>
-    <tag>lmdbjava-0.9.1</tag>
+    <tag>HEAD</tag>
   </scm>
   <issueManagement>
     <system>GitHub Issues</system>

From 480e984417c17915b31e33de193ff08e118fcec9 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Thu, 6 Mar 2025 16:04:06 +0000
Subject: [PATCH 197/322] gh-249 Remove MDB_UNSIGNEDKEY, let CursorIterable
 call mdb_cmp

There are now essentially three ways of configuring comparators
when creating a Dbi.

**null comparator**
LMDB will use its own comparator & CursorIterable will call down
to mdb_cmp for comparisons between the current cursor key and the
range start/stop key.

**provided comparator**
LMDB will use its own comparator & CursorIterable will use the
provided comparator for comparisons between the current cursor
key and the range start/stop key.

**provided comparator with nativeCb==true**
LMDB will call back to java for all comparator duties.
CursorIterable will use the same provided comparator for
comparisons between the current cursor key and the range
start/stop key.

The methods `getSignedComparator()` and `getUnsignedComparator()`
have been made public so users of this library can access them.
---
 src/main/java/org/lmdbjava/BufferProxy.java   |  40 +-
 .../java/org/lmdbjava/ByteArrayProxy.java     |   4 +-
 src/main/java/org/lmdbjava/ByteBufProxy.java  |   4 +-
 .../java/org/lmdbjava/ByteBufferProxy.java    |   4 +-
 src/main/java/org/lmdbjava/Cursor.java        |   4 +
 .../java/org/lmdbjava/CursorIterable.java     | 403 +++++++++++-------
 src/main/java/org/lmdbjava/Dbi.java           |  15 +-
 src/main/java/org/lmdbjava/DbiFlags.java      |  21 +-
 .../java/org/lmdbjava/DirectBufferProxy.java  |   4 +-
 src/main/java/org/lmdbjava/Env.java           |  21 +-
 src/main/java/org/lmdbjava/Key.java           |  74 ++++
 src/main/java/org/lmdbjava/KeyRangeType.java  |  48 +--
 src/main/java/org/lmdbjava/Library.java       |   2 +
 .../java/org/lmdbjava/RangeComparator.java    |  19 +
 .../java/org/lmdbjava/ComparatorTest.java     |   8 +-
 .../org/lmdbjava/CursorIterablePerfTest.java  | 163 +++++++
 .../java/org/lmdbjava/CursorIterableTest.java | 238 ++++++++---
 src/test/java/org/lmdbjava/DbiTest.java       |   4 +-
 src/test/java/org/lmdbjava/KeyRangeTest.java  |   5 +-
 src/test/java/org/lmdbjava/TestUtils.java     |   2 +
 20 files changed, 768 insertions(+), 315 deletions(-)
 create mode 100644 src/main/java/org/lmdbjava/Key.java
 create mode 100644 src/main/java/org/lmdbjava/RangeComparator.java
 create mode 100644 src/test/java/org/lmdbjava/CursorIterablePerfTest.java

diff --git a/src/main/java/org/lmdbjava/BufferProxy.java b/src/main/java/org/lmdbjava/BufferProxy.java
index e66031d2..26d9db74 100644
--- a/src/main/java/org/lmdbjava/BufferProxy.java
+++ b/src/main/java/org/lmdbjava/BufferProxy.java
@@ -16,10 +16,6 @@
 package org.lmdbjava;
 
 import static java.lang.Long.BYTES;
-import static org.lmdbjava.DbiFlags.MDB_INTEGERKEY;
-import static org.lmdbjava.DbiFlags.MDB_UNSIGNEDKEY;
-import static org.lmdbjava.MaskedFlag.isSet;
-import static org.lmdbjava.MaskedFlag.mask;
 
 import java.util.Comparator;
 import jnr.ffi.Pointer;
@@ -70,36 +66,25 @@ protected BufferProxy() {}
    */
   protected abstract byte[] getBytes(T buffer);
 
-  /**
-   * Get a suitable default {@link Comparator} given the provided flags.
-   *
-   * <p>The provided comparator must strictly match the lexicographical order of keys in the native
-   * LMDB database.
-   *
-   * @param flags for the database
-   * @return a comparator that can be used (never null)
-   */
-  protected Comparator<T> getComparator(DbiFlags... flags) {
-    final int intFlag = mask(flags);
-
-    return isSet(intFlag, MDB_INTEGERKEY) || isSet(intFlag, MDB_UNSIGNEDKEY)
-        ? getUnsignedComparator()
-        : getSignedComparator();
-  }
-
   /**
    * Get a suitable default {@link Comparator} to compare numeric key values as signed.
    *
+   * <p>
+   * Note: LMDB's default comparator is unsigned so if this is used only for the {@link CursorIterable}
+   * start/stop key comparisons then its behaviour will differ from the iteration order. Use
+   * with caution.
+   * </p>
+   *
    * @return a comparator that can be used (never null)
    */
-  protected abstract Comparator<T> getSignedComparator();
+  public abstract Comparator<T> getSignedComparator();
 
   /**
    * Get a suitable default {@link Comparator} to compare numeric key values as unsigned.
    *
    * @return a comparator that can be used (never null)
    */
-  protected abstract Comparator<T> getUnsignedComparator();
+  public abstract Comparator<T> getUnsignedComparator();
 
   /**
    * Called when the <code>MDB_val</code> should be set to reflect the passed buffer. This buffer
@@ -140,4 +125,13 @@ protected Comparator<T> getComparator(DbiFlags... flags) {
   final KeyVal<T> keyVal() {
     return new KeyVal<>(this);
   }
+
+  /**
+   * Create a new {@link Key} to hold pointers for this buffer proxy.
+   *
+   * @return a non-null key holder
+   */
+  final Key<T> key() {
+    return new Key<>(this);
+  }
 }
diff --git a/src/main/java/org/lmdbjava/ByteArrayProxy.java b/src/main/java/org/lmdbjava/ByteArrayProxy.java
index 4a22ab83..3aeba047 100644
--- a/src/main/java/org/lmdbjava/ByteArrayProxy.java
+++ b/src/main/java/org/lmdbjava/ByteArrayProxy.java
@@ -104,12 +104,12 @@ protected byte[] getBytes(final byte[] buffer) {
   }
 
   @Override
-  protected Comparator<byte[]> getSignedComparator() {
+  public Comparator<byte[]> getSignedComparator() {
     return signedComparator;
   }
 
   @Override
-  protected Comparator<byte[]> getUnsignedComparator() {
+  public Comparator<byte[]> getUnsignedComparator() {
     return unsignedComparator;
   }
 
diff --git a/src/main/java/org/lmdbjava/ByteBufProxy.java b/src/main/java/org/lmdbjava/ByteBufProxy.java
index cac5b97b..933b52a4 100644
--- a/src/main/java/org/lmdbjava/ByteBufProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufProxy.java
@@ -114,12 +114,12 @@ protected ByteBuf allocate() {
   }
 
   @Override
-  protected Comparator<ByteBuf> getSignedComparator() {
+  public Comparator<ByteBuf> getSignedComparator() {
     return comparator;
   }
 
   @Override
-  protected Comparator<ByteBuf> getUnsignedComparator() {
+  public Comparator<ByteBuf> getUnsignedComparator() {
     return comparator;
   }
 
diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
index 2b7cdf0d..1fce090a 100644
--- a/src/main/java/org/lmdbjava/ByteBufferProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -182,12 +182,12 @@ protected final ByteBuffer allocate() {
     }
 
     @Override
-    protected Comparator<ByteBuffer> getSignedComparator() {
+    public Comparator<ByteBuffer> getSignedComparator() {
       return signedComparator;
     }
 
     @Override
-    protected Comparator<ByteBuffer> getUnsignedComparator() {
+    public Comparator<ByteBuffer> getUnsignedComparator() {
       return unsignedComparator;
     }
 
diff --git a/src/main/java/org/lmdbjava/Cursor.java b/src/main/java/org/lmdbjava/Cursor.java
index d49a9bed..9070cff6 100644
--- a/src/main/java/org/lmdbjava/Cursor.java
+++ b/src/main/java/org/lmdbjava/Cursor.java
@@ -196,6 +196,10 @@ public T key() {
     return kv.key();
   }
 
+  KeyVal<T> keyVal() {
+    return kv;
+  }
+
   /**
    * Position at last key/data item.
    *
diff --git a/src/main/java/org/lmdbjava/CursorIterable.java b/src/main/java/org/lmdbjava/CursorIterable.java
index 6a03bd90..6b92a9cd 100644
--- a/src/main/java/org/lmdbjava/CursorIterable.java
+++ b/src/main/java/org/lmdbjava/CursorIterable.java
@@ -21,10 +21,14 @@
 import static org.lmdbjava.CursorIterable.State.REQUIRES_NEXT_OP;
 import static org.lmdbjava.CursorIterable.State.TERMINATED;
 import static org.lmdbjava.GetOp.MDB_SET_RANGE;
+import static org.lmdbjava.Library.LIB;
 
 import java.util.Comparator;
 import java.util.Iterator;
 import java.util.NoSuchElementException;
+import java.util.Objects;
+import java.util.function.Supplier;
+import jnr.ffi.Pointer;
 import org.lmdbjava.KeyRangeType.CursorOp;
 import org.lmdbjava.KeyRangeType.IteratorOp;
 
@@ -38,185 +42,266 @@
  */
 public final class CursorIterable<T> implements Iterable<CursorIterable.KeyVal<T>>, AutoCloseable {
 
-  private final Comparator<T> comparator;
-  private final Cursor<T> cursor;
-  private final KeyVal<T> entry;
-  private boolean iteratorReturned;
-  private final KeyRange<T> range;
-  private State state = REQUIRES_INITIAL_OP;
-
-  CursorIterable(
-      final Txn<T> txn, final Dbi<T> dbi, final KeyRange<T> range, final Comparator<T> comparator) {
-    this.cursor = dbi.openCursor(txn);
-    this.range = range;
-    this.comparator = comparator;
-    this.entry = new KeyVal<>();
-  }
-
-  @Override
-  public void close() {
-    cursor.close();
-  }
-
-  /**
-   * Obtain an iterator.
-   *
-   * <p>As iteration of the returned iterator will cause movement of the underlying LMDB cursor, an
-   * {@link IllegalStateException} is thrown if an attempt is made to obtain the iterator more than
-   * once. For advanced cursor control (such as being able to iterate over the same data multiple
-   * times etc) please instead refer to {@link Dbi#openCursor(org.lmdbjava.Txn)}.
-   *
-   * @return an iterator
-   */
-  @Override
-  public Iterator<KeyVal<T>> iterator() {
-    if (iteratorReturned) {
-      throw new IllegalStateException("Iterator can only be returned once");
-    }
-    iteratorReturned = true;
+    //  private final Comparator<T> comparator;
+    private final RangeComparator rangeComparator;
+    private final Cursor<T> cursor;
+    private final Dbi<T> dbi;
+    private final KeyVal<T> entry;
+    private boolean iteratorReturned;
+    private final KeyRange<T> range;
+    private State state = REQUIRES_INITIAL_OP;
+    private final Key<T> startKey;
+    private final Key<T> stopKey;
 
-    return new Iterator<KeyVal<T>>() {
-      @Override
-      public boolean hasNext() {
-        while (state != RELEASED && state != TERMINATED) {
-          update();
-        }
-        return state == RELEASED;
-      }
+    CursorIterable(
+            final Txn<T> txn,
+            final Dbi<T> dbi,
+            final KeyRange<T> range,
+            final Comparator<T> comparator,
+            final BufferProxy<T> proxy) {
+        this.cursor = dbi.openCursor(txn);
+        this.dbi = dbi;
+        this.range = range;
+        this.entry = new KeyVal<>();
 
-      @Override
-      public KeyVal<T> next() {
-        if (!hasNext()) {
-          throw new NoSuchElementException();
+        if (comparator != null) {
+            // User supplied java-side comparator so use that
+            this.rangeComparator = createJavaRangeComparator(range, comparator, entry::key);
+            this.startKey = null;
+            this.stopKey = null;
+        } else {
+            // No java-side comparator so call down to LMDB to do the comparison
+            this.rangeComparator = createLmdbDbiComparator(txn.pointer(), dbi.pointer());
+            // Allocate buffers for use with the start/stop keys if required.
+            // Saves us copying bytes on each comparison
+            this.startKey = createKey(range.getStart(), proxy);
+            this.stopKey = createKey(range.getStop(), proxy);
         }
-        state = REQUIRES_NEXT_OP;
-        return entry;
-      }
-
-      @Override
-      public void remove() {
-        cursor.delete();
-      }
-    };
-  }
-
-  private void executeCursorOp(final CursorOp op) {
-    final boolean found;
-    switch (op) {
-      case FIRST:
-        found = cursor.first();
-        break;
-      case LAST:
-        found = cursor.last();
-        break;
-      case NEXT:
-        found = cursor.next();
-        break;
-      case PREV:
-        found = cursor.prev();
-        break;
-      case GET_START_KEY:
-        found = cursor.get(range.getStart(), MDB_SET_RANGE);
-        break;
-      case GET_START_KEY_BACKWARD:
-        found = cursor.get(range.getStart(), MDB_SET_RANGE) || cursor.last();
-        break;
-      default:
-        throw new IllegalStateException("Unknown cursor operation");
     }
-    entry.setK(found ? cursor.key() : null);
-    entry.setV(found ? cursor.val() : null);
-  }
-
-  private void executeIteratorOp() {
-    final IteratorOp op =
-        range.getType().iteratorOp(range.getStart(), range.getStop(), entry.key(), comparator);
-    switch (op) {
-      case CALL_NEXT_OP:
-        executeCursorOp(range.getType().nextOp());
-        state = REQUIRES_ITERATOR_OP;
-        break;
-      case TERMINATE:
-        state = TERMINATED;
-        break;
-      case RELEASE:
-        state = RELEASED;
-        break;
-      default:
-        throw new IllegalStateException("Unknown operation");
+
+    private Key<T> createKey(final T keyBuffer, final BufferProxy<T> proxy) {
+        if (keyBuffer != null) {
+            final Key<T> key = proxy.key();
+            key.keyIn(keyBuffer);
+            return key;
+        } else {
+            return null;
+        }
     }
-  }
-
-  private void update() {
-    switch (state) {
-      case REQUIRES_INITIAL_OP:
-        executeCursorOp(range.getType().initialOp());
-        state = REQUIRES_ITERATOR_OP;
-        break;
-      case REQUIRES_NEXT_OP:
-        executeCursorOp(range.getType().nextOp());
-        state = REQUIRES_ITERATOR_OP;
-        break;
-      case REQUIRES_ITERATOR_OP:
-        executeIteratorOp();
-        break;
-      case TERMINATED:
-        break;
-      default:
-        throw new IllegalStateException("Unknown state");
+
+    static <T> RangeComparator createJavaRangeComparator(
+            final KeyRange<T> range,
+            final Comparator<T> comparator,
+            final Supplier<T> currentKeySupplier) {
+        final T start = range.getStart();
+        final T stop = range.getStop();
+        return new RangeComparator() {
+            @Override
+            public int compareToStartKey() {
+                return comparator.compare(currentKeySupplier.get(), start);
+            }
+
+            @Override
+            public int compareToStopKey() {
+                return comparator.compare(currentKeySupplier.get(), stop);
+            }
+        };
     }
-  }
 
-  /**
-   * Holder for a key and value pair.
-   *
-   * <p>The same holder instance will always be returned for a given iterator. The returned keys and
-   * values may change or point to different memory locations following changes in the iterator,
-   * cursor or transaction.
-   *
-   * @param <T> buffer type
-   */
-  public static final class KeyVal<T> {
+    /**
+     * Calls down to mdb_cmp to make use of the comparator that LMDB uses for insertion order.
+     *
+     * @param txnPointer The pointer to the transaction.
+     * @param dbiPointer The pointer to the Dbi so LMDB can use the comparator of the Dbi
+     */
+    private RangeComparator createLmdbDbiComparator(
+            final Pointer txnPointer, final Pointer dbiPointer) {
+        Objects.requireNonNull(txnPointer);
+        Objects.requireNonNull(dbiPointer);
+        Objects.requireNonNull(cursor);
+
+        return new RangeComparator() {
+            @Override
+            public int compareToStartKey() {
+                return LIB.mdb_cmp(txnPointer, dbiPointer, cursor.keyVal().pointerKey(), startKey.pointerKey());
+            }
 
-    private T k;
-    private T v;
+            @Override
+            public int compareToStopKey() {
+                return LIB.mdb_cmp(txnPointer, dbiPointer, cursor.keyVal().pointerKey(), stopKey.pointerKey());
+            }
+        };
+    }
 
-    /** Explicitly-defined default constructor to avoid warnings. */
-    public KeyVal() {}
+    @Override
+    public void close() {
+        cursor.close();
+    }
 
     /**
-     * The key.
+     * Obtain an iterator.
+     *
+     * <p>As iteration of the returned iterator will cause movement of the underlying LMDB cursor, an
+     * {@link IllegalStateException} is thrown if an attempt is made to obtain the iterator more than
+     * once. For advanced cursor control (such as being able to iterate over the same data multiple
+     * times etc) please instead refer to {@link Dbi#openCursor(org.lmdbjava.Txn)}.
      *
-     * @return key
+     * @return an iterator
      */
-    public T key() {
-      return k;
+    @Override
+    public Iterator<KeyVal<T>> iterator() {
+        if (iteratorReturned) {
+            throw new IllegalStateException("Iterator can only be returned once");
+        }
+        iteratorReturned = true;
+
+        return new Iterator<KeyVal<T>>() {
+            @Override
+            public boolean hasNext() {
+                while (state != RELEASED && state != TERMINATED) {
+                    update();
+                }
+                return state == RELEASED;
+            }
+
+            @Override
+            public KeyVal<T> next() {
+                if (!hasNext()) {
+                    throw new NoSuchElementException();
+                }
+                state = REQUIRES_NEXT_OP;
+                return entry;
+            }
+
+            @Override
+            public void remove() {
+                cursor.delete();
+            }
+        };
+    }
+
+    private void executeCursorOp(final CursorOp op) {
+        final boolean found;
+        switch (op) {
+            case FIRST:
+                found = cursor.first();
+                break;
+            case LAST:
+                found = cursor.last();
+                break;
+            case NEXT:
+                found = cursor.next();
+                break;
+            case PREV:
+                found = cursor.prev();
+                break;
+            case GET_START_KEY:
+                found = cursor.get(range.getStart(), MDB_SET_RANGE);
+                break;
+            case GET_START_KEY_BACKWARD:
+                found = cursor.get(range.getStart(), MDB_SET_RANGE) || cursor.last();
+                break;
+            default:
+                throw new IllegalStateException("Unknown cursor operation");
+        }
+        entry.setK(found ? cursor.key() : null);
+        entry.setV(found ? cursor.val() : null);
+    }
+
+    private void executeIteratorOp() {
+        final IteratorOp op =
+                range.getType().iteratorOp(range.getStart(), range.getStop(), entry.key(), rangeComparator);
+        switch (op) {
+            case CALL_NEXT_OP:
+                executeCursorOp(range.getType().nextOp());
+                state = REQUIRES_ITERATOR_OP;
+                break;
+            case TERMINATE:
+                state = TERMINATED;
+                break;
+            case RELEASE:
+                state = RELEASED;
+                break;
+            default:
+                throw new IllegalStateException("Unknown operation");
+        }
+    }
+
+    private void update() {
+        switch (state) {
+            case REQUIRES_INITIAL_OP:
+                executeCursorOp(range.getType().initialOp());
+                state = REQUIRES_ITERATOR_OP;
+                break;
+            case REQUIRES_NEXT_OP:
+                executeCursorOp(range.getType().nextOp());
+                state = REQUIRES_ITERATOR_OP;
+                break;
+            case REQUIRES_ITERATOR_OP:
+                executeIteratorOp();
+                break;
+            case TERMINATED:
+                break;
+            default:
+                throw new IllegalStateException("Unknown state");
+        }
     }
 
     /**
-     * The value.
+     * Holder for a key and value pair.
+     *
+     * <p>The same holder instance will always be returned for a given iterator. The returned keys and
+     * values may change or point to different memory locations following changes in the iterator,
+     * cursor or transaction.
      *
-     * @return value
+     * @param <T> buffer type
      */
-    public T val() {
-      return v;
-    }
+    public static final class KeyVal<T> {
+
+        private T k;
+        private T v;
+
+        /**
+         * Explicitly-defined default constructor to avoid warnings.
+         */
+        public KeyVal() {
+        }
+
+        /**
+         * The key.
+         *
+         * @return key
+         */
+        public T key() {
+            return k;
+        }
+
+        /**
+         * The value.
+         *
+         * @return value
+         */
+        public T val() {
+            return v;
+        }
 
-    void setK(final T key) {
-      this.k = key;
+        void setK(final T key) {
+            this.k = key;
+        }
+
+        void setV(final T val) {
+            this.v = val;
+        }
     }
 
-    void setV(final T val) {
-      this.v = val;
+    /**
+     * Represents the internal {@link CursorIterable} state.
+     */
+    enum State {
+        REQUIRES_INITIAL_OP,
+        REQUIRES_NEXT_OP,
+        REQUIRES_ITERATOR_OP,
+        RELEASED,
+        TERMINATED
     }
-  }
-
-  /** Represents the internal {@link CursorIterable} state. */
-  enum State {
-    REQUIRES_INITIAL_OP,
-    REQUIRES_NEXT_OP,
-    REQUIRES_ITERATOR_OP,
-    RELEASED,
-    TERMINATED
-  }
 }
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index ad1bb5a7..c622462b 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -54,6 +54,7 @@ public final class Dbi<T> {
   private final Env<T> env;
   private final byte[] name;
   private final Pointer ptr;
+  private final BufferProxy<T> proxy;
 
   Dbi(
       final Env<T> env,
@@ -69,16 +70,14 @@ public final class Dbi<T> {
     }
     this.env = env;
     this.name = name == null ? null : Arrays.copyOf(name, name.length);
-    if (comparator == null) {
-      this.comparator = proxy.getComparator(flags);
-    } else {
-      this.comparator = comparator;
-    }
+    this.proxy = proxy;
+    this.comparator = comparator;
     final int flagsMask = mask(true, flags);
     final Pointer dbiPtr = allocateDirect(RUNTIME, ADDRESS);
     checkRc(LIB.mdb_dbi_open(txn.pointer(), name, flagsMask, dbiPtr));
     ptr = dbiPtr.getPointer(0);
     if (nativeCb) {
+      requireNonNull(comparator, "comparator cannot be null if nativeCb is set");
       this.ccb =
           (keyA, keyB) -> {
             final T compKeyA = proxy.allocate();
@@ -96,6 +95,10 @@ public final class Dbi<T> {
     }
   }
 
+  Pointer pointer() {
+    return ptr;
+  }
+
   /**
    * Close the database handle (normally unnecessary; use with caution).
    *
@@ -275,7 +278,7 @@ public CursorIterable<T> iterate(final Txn<T> txn, final KeyRange<T> range) {
       env.checkNotClosed();
       txn.checkReady();
     }
-    return new CursorIterable<>(txn, this, range, comparator);
+    return new CursorIterable<>(txn, this, range, comparator, proxy);
   }
 
   /**
diff --git a/src/main/java/org/lmdbjava/DbiFlags.java b/src/main/java/org/lmdbjava/DbiFlags.java
index 123ec9fd..2f5eadf6 100644
--- a/src/main/java/org/lmdbjava/DbiFlags.java
+++ b/src/main/java/org/lmdbjava/DbiFlags.java
@@ -55,14 +55,6 @@ public enum DbiFlags implements MaskedFlag {
    * #MDB_INTEGERKEY} keys.
    */
   MDB_INTEGERDUP(0x20),
-  /**
-   * Compare the <b>numeric</b> keys in native byte order and as unsigned.
-   *
-   * <p>This option is applied only to {@link java.nio.ByteBuffer}, {@link org.agrona.DirectBuffer}
-   * and byte array keys. {@link io.netty.buffer.ByteBuf} keys are always compared in native byte
-   * order and as unsigned.
-   */
-  MDB_UNSIGNEDKEY(0x30, false),
   /**
    * With {@link #MDB_DUPSORT}, use reverse string dups.
    *
@@ -78,24 +70,13 @@ public enum DbiFlags implements MaskedFlag {
   MDB_CREATE(0x4_0000);
 
   private final int mask;
-  private final boolean propagatedToLmdb;
-
-  DbiFlags(final int mask, final boolean propagatedToLmdb) {
-    this.mask = mask;
-    this.propagatedToLmdb = propagatedToLmdb;
-  }
 
   DbiFlags(final int mask) {
-    this(mask, true);
+    this.mask = mask;
   }
 
   @Override
   public int getMask() {
     return mask;
   }
-
-  @Override
-  public boolean isPropagatedToLmdb() {
-    return propagatedToLmdb;
-  }
 }
diff --git a/src/main/java/org/lmdbjava/DirectBufferProxy.java b/src/main/java/org/lmdbjava/DirectBufferProxy.java
index 156e60e9..5022ed02 100644
--- a/src/main/java/org/lmdbjava/DirectBufferProxy.java
+++ b/src/main/java/org/lmdbjava/DirectBufferProxy.java
@@ -111,12 +111,12 @@ protected DirectBuffer allocate() {
   }
 
   @Override
-  protected Comparator<DirectBuffer> getSignedComparator() {
+  public Comparator<DirectBuffer> getSignedComparator() {
     return signedComparator;
   }
 
   @Override
-  protected Comparator<DirectBuffer> getUnsignedComparator() {
+  public Comparator<DirectBuffer> getUnsignedComparator() {
     return unsignedComparator;
   }
 
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 3db16119..1543282c 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -256,10 +256,17 @@ public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
 
   /**
    * Convenience method that opens a {@link Dbi} with a UTF-8 database name and associated {@link
-   * Comparator} that is not invoked from native code.
+   * Comparator} for use by {@link CursorIterable} when comparing start/stop keys.
+   * <p>
+   * It is very important that the passed comparator behaves in the same way as the comparator
+   * LMDB uses for its insertion order (for the type of data that will be stored in the database),
+   * or you fully understand the implications of them behaving differently.
+   * LMDB's comparator is unsigned lexicographical, unless {@link DbiFlags#MDB_INTEGERKEY} is used.
+   * </p>
    *
    * @param name name of the database (or null if no name is required)
-   * @param comparator custom comparator callback (or null to use default)
+   * @param comparator custom comparator for cursor start/stop key comparisons. If null,
+   *                   LMDB's comparator will be used.
    * @param flags to open the database with
    * @return a database that is ready to use
    */
@@ -271,11 +278,15 @@ public Dbi<T> openDbi(
 
   /**
    * Convenience method that opens a {@link Dbi} with a UTF-8 database name and associated {@link
-   * Comparator} that may be invoked from native code if specified.
+   * Comparator}. The comparator will be used by {@link CursorIterable} when comparing start/stop keys
+   * as a minimum. If nativeCb is {@code true}, this comparator will also be called by LMDB to determine
+   * insertion/iteration order. Calling back to a java comparator may significantly impact performance.
    *
    * @param name name of the database (or null if no name is required)
-   * @param comparator custom comparator callback (or null to use default)
-   * @param nativeCb whether native code calls back to the Java comparator
+   * @param comparator custom comparator for cursor start/stop key comparisons and optionally for
+   *                   LMDB to call back to. If null,
+   *                   LMDB's comparator will be used.
+   * @param nativeCb whether LMDB native code calls back to the Java comparator
    * @param flags to open the database with
    * @return a database that is ready to use
    */
diff --git a/src/main/java/org/lmdbjava/Key.java b/src/main/java/org/lmdbjava/Key.java
new file mode 100644
index 00000000..7fd8bbe2
--- /dev/null
+++ b/src/main/java/org/lmdbjava/Key.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import static java.util.Objects.requireNonNull;
+import static org.lmdbjava.BufferProxy.MDB_VAL_STRUCT_SIZE;
+import static org.lmdbjava.Library.RUNTIME;
+
+import jnr.ffi.Pointer;
+import jnr.ffi.provider.MemoryManager;
+
+/**
+ * Represents off-heap memory holding a key only.
+ *
+ * @param <T> buffer type
+ */
+final class Key<T> implements AutoCloseable {
+
+  private static final MemoryManager MEM_MGR = RUNTIME.getMemoryManager();
+  private boolean closed;
+  private T k;
+  private final BufferProxy<T> proxy;
+  private final Pointer ptrArray;
+  private final Pointer ptrKey;
+  private final long ptrKeyAddr;
+
+  Key(final BufferProxy<T> proxy) {
+    requireNonNull(proxy);
+    this.proxy = proxy;
+    this.k = proxy.allocate();
+    ptrKey = MEM_MGR.allocateTemporary(MDB_VAL_STRUCT_SIZE, false);
+    ptrKeyAddr = ptrKey.address();
+    ptrArray = MEM_MGR.allocateTemporary(MDB_VAL_STRUCT_SIZE * 2, false);
+  }
+
+  @Override
+  public void close() {
+    if (closed) {
+      return;
+    }
+    closed = true;
+    proxy.deallocate(k);
+  }
+
+  T key() {
+    return k;
+  }
+
+  void keyIn(final T key) {
+    proxy.in(key, ptrKey, ptrKeyAddr);
+  }
+
+  T keyOut() {
+    k = proxy.out(k, ptrKey, ptrKeyAddr);
+    return k;
+  }
+
+  Pointer pointerKey() {
+    return ptrKey;
+  }
+}
diff --git a/src/main/java/org/lmdbjava/KeyRangeType.java b/src/main/java/org/lmdbjava/KeyRangeType.java
index ad67286d..07123e9a 100644
--- a/src/main/java/org/lmdbjava/KeyRangeType.java
+++ b/src/main/java/org/lmdbjava/KeyRangeType.java
@@ -322,12 +322,12 @@ CursorOp initialOp() {
    * @param start start buffer
    * @param stop stop buffer
    * @param buffer current key returned by LMDB (may be null)
-   * @param c comparator (required)
+   * @param rangeComparator comparator (required)
    * @return response to this key
    */
   <T, C extends Comparator<T>> IteratorOp iteratorOp(
-      final T start, final T stop, final T buffer, final C c) {
-    requireNonNull(c, "Comparator required");
+      final T start, final T stop, final T buffer, final RangeComparator rangeComparator) {
+    requireNonNull(rangeComparator, "Comparator required");
     if (buffer == null) {
       return TERMINATE;
     }
@@ -337,55 +337,55 @@ <T, C extends Comparator<T>> IteratorOp iteratorOp(
       case FORWARD_AT_LEAST:
         return RELEASE;
       case FORWARD_AT_MOST:
-        return c.compare(buffer, stop) > 0 ? TERMINATE : RELEASE;
+        return rangeComparator.compareToStopKey() > 0 ? TERMINATE : RELEASE;
       case FORWARD_CLOSED:
-        return c.compare(buffer, stop) > 0 ? TERMINATE : RELEASE;
+        return rangeComparator.compareToStopKey() > 0 ? TERMINATE : RELEASE;
       case FORWARD_CLOSED_OPEN:
-        return c.compare(buffer, stop) >= 0 ? TERMINATE : RELEASE;
+        return rangeComparator.compareToStopKey() >= 0 ? TERMINATE : RELEASE;
       case FORWARD_GREATER_THAN:
-        return c.compare(buffer, start) == 0 ? CALL_NEXT_OP : RELEASE;
+        return rangeComparator.compareToStartKey() == 0 ? CALL_NEXT_OP : RELEASE;
       case FORWARD_LESS_THAN:
-        return c.compare(buffer, stop) >= 0 ? TERMINATE : RELEASE;
+        return rangeComparator.compareToStopKey() >= 0 ? TERMINATE : RELEASE;
       case FORWARD_OPEN:
-        if (c.compare(buffer, start) == 0) {
+        if (rangeComparator.compareToStartKey() == 0) {
           return CALL_NEXT_OP;
         }
-        return c.compare(buffer, stop) >= 0 ? TERMINATE : RELEASE;
+        return rangeComparator.compareToStopKey() >= 0 ? TERMINATE : RELEASE;
       case FORWARD_OPEN_CLOSED:
-        if (c.compare(buffer, start) == 0) {
+        if (rangeComparator.compareToStartKey() == 0) {
           return CALL_NEXT_OP;
         }
-        return c.compare(buffer, stop) > 0 ? TERMINATE : RELEASE;
+        return rangeComparator.compareToStopKey() > 0 ? TERMINATE : RELEASE;
       case BACKWARD_ALL:
         return RELEASE;
       case BACKWARD_AT_LEAST:
-        return c.compare(buffer, start) > 0 ? CALL_NEXT_OP : RELEASE; // rewind
+        return rangeComparator.compareToStartKey() > 0 ? CALL_NEXT_OP : RELEASE; // rewind
       case BACKWARD_AT_MOST:
-        return c.compare(buffer, stop) >= 0 ? RELEASE : TERMINATE;
+        return rangeComparator.compareToStopKey() >= 0 ? RELEASE : TERMINATE;
       case BACKWARD_CLOSED:
-        if (c.compare(buffer, start) > 0) {
+        if (rangeComparator.compareToStartKey() > 0) {
           return CALL_NEXT_OP; // rewind
         }
-        return c.compare(buffer, stop) >= 0 ? RELEASE : TERMINATE;
+        return rangeComparator.compareToStopKey() >= 0 ? RELEASE : TERMINATE;
       case BACKWARD_CLOSED_OPEN:
-        if (c.compare(buffer, start) > 0) {
+        if (rangeComparator.compareToStartKey() > 0) {
           return CALL_NEXT_OP; // rewind
         }
-        return c.compare(buffer, stop) > 0 ? RELEASE : TERMINATE;
+        return rangeComparator.compareToStopKey() > 0 ? RELEASE : TERMINATE;
       case BACKWARD_GREATER_THAN:
-        return c.compare(buffer, start) >= 0 ? CALL_NEXT_OP : RELEASE;
+        return rangeComparator.compareToStartKey() >= 0 ? CALL_NEXT_OP : RELEASE;
       case BACKWARD_LESS_THAN:
-        return c.compare(buffer, stop) > 0 ? RELEASE : TERMINATE;
+        return rangeComparator.compareToStopKey() > 0 ? RELEASE : TERMINATE;
       case BACKWARD_OPEN:
-        if (c.compare(buffer, start) >= 0) {
+        if (rangeComparator.compareToStartKey() >= 0) {
           return CALL_NEXT_OP; // rewind
         }
-        return c.compare(buffer, stop) > 0 ? RELEASE : TERMINATE;
+        return rangeComparator.compareToStopKey() > 0 ? RELEASE : TERMINATE;
       case BACKWARD_OPEN_CLOSED:
-        if (c.compare(buffer, start) >= 0) {
+        if (rangeComparator.compareToStartKey() >= 0) {
           return CALL_NEXT_OP; // rewind
         }
-        return c.compare(buffer, stop) >= 0 ? RELEASE : TERMINATE;
+        return rangeComparator.compareToStopKey() >= 0 ? RELEASE : TERMINATE;
       default:
         throw new IllegalStateException("Invalid type");
     }
diff --git a/src/main/java/org/lmdbjava/Library.java b/src/main/java/org/lmdbjava/Library.java
index ef9b9b35..6d8122d2 100644
--- a/src/main/java/org/lmdbjava/Library.java
+++ b/src/main/java/org/lmdbjava/Library.java
@@ -235,6 +235,8 @@ public interface Lmdb {
 
     void mdb_txn_reset(@In Pointer txn);
 
+    int mdb_cmp(@In Pointer txn, @In Pointer dbi, @In Pointer key1, @In Pointer key2);
+
     Pointer mdb_version(IntByReference major, IntByReference minor, IntByReference patch);
   }
 }
diff --git a/src/main/java/org/lmdbjava/RangeComparator.java b/src/main/java/org/lmdbjava/RangeComparator.java
new file mode 100644
index 00000000..162584b1
--- /dev/null
+++ b/src/main/java/org/lmdbjava/RangeComparator.java
@@ -0,0 +1,19 @@
+package org.lmdbjava;
+
+/**
+ * For comparing a cursor's current key against a {@link KeyRange}'s start/stop key.
+ */
+interface RangeComparator {
+
+    /**
+     * Compare the cursor's current key to the range start key. Equivalent to compareTo(currentKey,
+     * startKey)
+     */
+    int compareToStartKey();
+
+    /**
+     * Compare the cursor's current key to the range stop key. Equivalent to compareTo(currentKey,
+     * stopKey)
+     */
+    int compareToStopKey();
+}
diff --git a/src/test/java/org/lmdbjava/ComparatorTest.java b/src/test/java/org/lmdbjava/ComparatorTest.java
index 3e265cee..dad84ed2 100644
--- a/src/test/java/org/lmdbjava/ComparatorTest.java
+++ b/src/test/java/org/lmdbjava/ComparatorTest.java
@@ -135,7 +135,7 @@ private static final class ByteArrayRunner implements ComparatorRunner {
 
     @Override
     public int compare(final byte[] o1, final byte[] o2) {
-      final Comparator<byte[]> c = PROXY_BA.getComparator();
+      final Comparator<byte[]> c = PROXY_BA.getUnsignedComparator();
       return c.compare(o1, o2);
     }
   }
@@ -145,7 +145,7 @@ private static final class ByteBufferRunner implements ComparatorRunner {
 
     @Override
     public int compare(final byte[] o1, final byte[] o2) {
-      final Comparator<ByteBuffer> c = PROXY_OPTIMAL.getComparator();
+      final Comparator<ByteBuffer> c = PROXY_OPTIMAL.getUnsignedComparator();
 
       // Convert arrays to buffers that are larger than the array, with
       // limit set at the array length. One buffer bigger than the other.
@@ -189,7 +189,7 @@ private static final class DirectBufferRunner implements ComparatorRunner {
     public int compare(final byte[] o1, final byte[] o2) {
       final DirectBuffer o1b = new UnsafeBuffer(o1);
       final DirectBuffer o2b = new UnsafeBuffer(o2);
-      final Comparator<DirectBuffer> c = PROXY_DB.getComparator();
+      final Comparator<DirectBuffer> c = PROXY_DB.getUnsignedComparator();
       return c.compare(o1b, o2b);
     }
   }
@@ -223,7 +223,7 @@ public int compare(final byte[] o1, final byte[] o2) {
       final ByteBuf o2b = DEFAULT.directBuffer(o2.length);
       o1b.writeBytes(o1);
       o2b.writeBytes(o2);
-      final Comparator<ByteBuf> c = PROXY_NETTY.getComparator();
+      final Comparator<ByteBuf> c = PROXY_NETTY.getUnsignedComparator();
       return c.compare(o1b, o2b);
     }
   }
diff --git a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
new file mode 100644
index 00000000..a9647d56
--- /dev/null
+++ b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
@@ -0,0 +1,163 @@
+package org.lmdbjava;
+
+import static com.jakewharton.byteunits.BinaryByteUnit.GIBIBYTES;
+import static org.lmdbjava.DbiFlags.MDB_CREATE;
+import static org.lmdbjava.Env.create;
+import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
+import static org.lmdbjava.PutFlags.MDB_APPEND;
+import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
+import static org.lmdbjava.TestUtils.POSIX_MODE;
+import static org.lmdbjava.TestUtils.bb;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.time.Duration;
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+
+public class CursorIterablePerfTest {
+
+    @Rule
+    public final TemporaryFolder tmp = new TemporaryFolder();
+
+//    private static final int ITERATIONS = 5_000_000;
+    private static final int ITERATIONS = 100_000;
+//    private static final int ITERATIONS = 10;
+
+    private Dbi<ByteBuffer> dbJavaComparator;
+    private Dbi<ByteBuffer> dbLmdbComparator;
+    private Dbi<ByteBuffer> dbCallbackComparator;
+    private List<Dbi<ByteBuffer>> dbs = new ArrayList<>();
+    private Env<ByteBuffer> env;
+    private List<Integer> data = new ArrayList<>(ITERATIONS);
+
+    @Before
+    public void before() throws IOException {
+        final File path = tmp.newFile();
+        final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
+        env =
+                create(bufferProxy)
+                        .setMapSize(GIBIBYTES.toBytes(1))
+                        .setMaxReaders(1)
+                        .setMaxDbs(3)
+                        .open(path, POSIX_MODE, MDB_NOSUBDIR);
+
+        // Use a java comparator for start/stop keys only
+        dbJavaComparator = env.openDbi("JavaComparator", bufferProxy.getUnsignedComparator(), MDB_CREATE);
+        // Use LMDB comparator for start/stop keys
+        dbLmdbComparator = env.openDbi("LmdbComparator", MDB_CREATE);
+        // Use a java comparator for start/stop keys and as a callback comparator
+        dbCallbackComparator = env.openDbi(
+                "CallBackComparator", bufferProxy.getUnsignedComparator(), true, MDB_CREATE);
+
+        dbs.add(dbJavaComparator);
+        dbs.add(dbLmdbComparator);
+        dbs.add(dbCallbackComparator);
+
+        populateList();
+    }
+
+    private void populateList() {
+        for (int i = 0; i < ITERATIONS * 2; i+=2) {
+            data.add(i);
+        }
+    }
+
+    private void populateDatabases(final boolean randomOrder) {
+        System.out.println("Clear then populate databases");
+
+        final List<Integer> data;
+        if (randomOrder) {
+            data = new ArrayList<>(this.data);
+            Collections.shuffle(data);
+        } else {
+            data = this.data;
+        }
+
+        for (int round = 0; round < 3; round++) {
+            System.out.println("round: " + round + " -----------------------------------------");
+
+            for (final Dbi<ByteBuffer> db : dbs) {
+                // Clean out the db first
+                try (Txn<ByteBuffer> txn = env.txnWrite();
+                     final Cursor<ByteBuffer> cursor = db.openCursor(txn)) {
+                    while (cursor.next()) {
+                        cursor.delete();
+                    }
+                }
+
+                final String dbName = new String(db.getName(), StandardCharsets.UTF_8);
+                final Instant start = Instant.now();
+                try (Txn<ByteBuffer> txn = env.txnWrite()) {
+                    for (final Integer i : data) {
+                        if (randomOrder) {
+                            db.put(txn, bb(i), bb(i + 1), MDB_NOOVERWRITE);
+                        } else {
+                            db.put(txn, bb(i), bb(i + 1), MDB_NOOVERWRITE, MDB_APPEND);
+                        }
+                    }
+                    txn.commit();
+                }
+                final Duration duration = Duration.between(start, Instant.now());
+                System.out.println("DB: " + dbName
+                        + " - Loaded in duration: " + duration
+                        + ", millis: " + duration.toMillis());
+            }
+        }
+    }
+
+    @After
+    public void after() {
+        env.close();
+        tmp.delete();
+    }
+
+    @Test
+    public void comparePerf_sequential() {
+        comparePerf(false);
+    }
+
+    @Test
+    public void comparePerf_random() {
+        comparePerf(true);
+    }
+
+    public void comparePerf(final boolean randomOrder) {
+        populateDatabases(randomOrder);
+        final ByteBuffer startKeyBuf = bb(data.getFirst());
+        final ByteBuffer stopKeyBuf = bb(data.getLast());
+        final KeyRange<ByteBuffer> keyRange = KeyRange.closed(startKeyBuf, stopKeyBuf);
+
+        System.out.println("\nIterating over all entries");
+        for (int round = 0; round < 3; round++) {
+            System.out.println("round: " + round + " -----------------------------------------");
+            for (final Dbi<ByteBuffer> db : dbs) {
+                final String dbName = new String(db.getName(), StandardCharsets.UTF_8);
+
+                final Instant start = Instant.now();
+                int cnt = 0;
+                // Exercise the stop key comparator on every entry
+                try (Txn<ByteBuffer> txn = env.txnRead();
+                     CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
+                    for (final CursorIterable.KeyVal<ByteBuffer> kv : c) {
+                        cnt++;
+                    }
+                }
+                final Duration duration = Duration.between(start, Instant.now());
+                System.out.println("DB: " + dbName
+                        + " - Iterated in duration: " + duration
+                        + ", millis: " + duration.toMillis()
+                        + ", cnt: " + cnt);
+            }
+        }
+    }
+}
diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index bd23bc55..96be0816 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -43,6 +43,8 @@
 import static org.lmdbjava.KeyRange.openClosedBackward;
 import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
 import static org.lmdbjava.TestUtils.DB_1;
+import static org.lmdbjava.TestUtils.DB_2;
+import static org.lmdbjava.TestUtils.DB_3;
 import static org.lmdbjava.TestUtils.POSIX_MODE;
 import static org.lmdbjava.TestUtils.bb;
 
@@ -69,7 +71,10 @@
 public final class CursorIterableTest {
 
   @Rule public final TemporaryFolder tmp = new TemporaryFolder();
-  private Dbi<ByteBuffer> db;
+  private Dbi<ByteBuffer> dbJavaComparator;
+  private Dbi<ByteBuffer> dbLmdbComparator;
+  private Dbi<ByteBuffer> dbCallbackComparator;
+  private List<Dbi<ByteBuffer>> dbs = new ArrayList<>();
   private Env<ByteBuffer> env;
   private Deque<Integer> list;
 
@@ -116,19 +121,39 @@ public void atMostTest() {
   @Before
   public void before() throws IOException {
     final File path = tmp.newFile();
+    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
     env =
-        create()
+        create(bufferProxy)
             .setMapSize(KIBIBYTES.toBytes(256))
             .setMaxReaders(1)
-            .setMaxDbs(1)
+            .setMaxDbs(3)
             .open(path, POSIX_MODE, MDB_NOSUBDIR);
-    db = env.openDbi(DB_1, MDB_CREATE);
-    populateDatabase(db);
+
+    // Use a java comparator for start/stop keys only
+    dbJavaComparator = env.openDbi(DB_1, bufferProxy.getUnsignedComparator(), MDB_CREATE);
+    // Use LMDB comparator for start/stop keys
+    dbLmdbComparator = env.openDbi(DB_2, MDB_CREATE);
+    // Use a java comparator for start/stop keys and as a callback comparaotr
+    dbCallbackComparator = env.openDbi(
+            DB_3, bufferProxy.getUnsignedComparator(), true, MDB_CREATE);
+
+    populateList();
+
+    populateDatabase(dbJavaComparator);
+    populateDatabase(dbLmdbComparator);
+    populateDatabase(dbCallbackComparator);
+
+    dbs.add(dbJavaComparator);
+    dbs.add(dbLmdbComparator);
+    dbs.add(dbCallbackComparator);
   }
 
-  private void populateDatabase(final Dbi<ByteBuffer> dbi) {
+  private void populateList() {
     list = new LinkedList<>();
     list.addAll(asList(2, 3, 4, 5, 6, 7, 8, 9));
+  }
+
+  private void populateDatabase(final Dbi<ByteBuffer> dbi) {
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       final Cursor<ByteBuffer> c = dbi.openCursor(txn);
       c.put(bb(2), bb(3), MDB_NOOVERWRITE);
@@ -166,6 +191,14 @@ public void closedTest() {
     verify(closed(bb(1), bb(7)), 2, 4, 6);
   }
 
+  public void closedTest1() {
+    verify(dbLmdbComparator, closed(bb(3), bb(7)), 4, 6);
+  }
+
+  public void closedTest2() {
+    verify(dbJavaComparator, closed(bb(3), bb(7)), 4, 6);
+  }
+
   @Test
   public void greaterThanBackwardTest() {
     verify(greaterThanBackward(bb(6)), 4, 2);
@@ -181,30 +214,39 @@ public void greaterThanTest() {
 
   @Test(expected = IllegalStateException.class)
   public void iterableOnlyReturnedOnce() {
-    try (Txn<ByteBuffer> txn = env.txnRead();
-        CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-      c.iterator(); // ok
-      c.iterator(); // fails
+    for (final Dbi<ByteBuffer> db : dbs) {
+      try (Txn<ByteBuffer> txn = env.txnRead();
+          CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+        c.iterator(); // ok
+        c.iterator(); // fails
+      }
     }
   }
 
   @Test
   public void iterate() {
-    try (Txn<ByteBuffer> txn = env.txnRead();
-        CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-      for (final KeyVal<ByteBuffer> kv : c) {
-        assertThat(kv.key().getInt(), is(list.pollFirst()));
-        assertThat(kv.val().getInt(), is(list.pollFirst()));
+    for (final Dbi<ByteBuffer> db : dbs) {
+      populateList();
+      try (Txn<ByteBuffer> txn = env.txnRead();
+          CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+
+        int cnt = 0;
+        for (final KeyVal<ByteBuffer> kv : c) {
+          assertThat(kv.key().getInt(), is(list.pollFirst()));
+          assertThat(kv.val().getInt(), is(list.pollFirst()));
+        }
       }
     }
   }
 
   @Test(expected = IllegalStateException.class)
   public void iteratorOnlyReturnedOnce() {
-    try (Txn<ByteBuffer> txn = env.txnRead();
-        CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-      c.iterator(); // ok
-      c.iterator(); // fails
+    for (final Dbi<ByteBuffer> db : dbs) {
+      try (Txn<ByteBuffer> txn = env.txnRead();
+          CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+        c.iterator(); // ok
+        c.iterator(); // fails
+      }
     }
   }
 
@@ -222,16 +264,19 @@ public void lessThanTest() {
 
   @Test(expected = NoSuchElementException.class)
   public void nextThrowsNoSuchElementExceptionIfNoMoreElements() {
-    try (Txn<ByteBuffer> txn = env.txnRead();
-        CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-      final Iterator<KeyVal<ByteBuffer>> i = c.iterator();
-      while (i.hasNext()) {
-        final KeyVal<ByteBuffer> kv = i.next();
-        assertThat(kv.key().getInt(), is(list.pollFirst()));
-        assertThat(kv.val().getInt(), is(list.pollFirst()));
+    for (final Dbi<ByteBuffer> db : dbs) {
+      populateList();
+      try (Txn<ByteBuffer> txn = env.txnRead();
+          CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+        final Iterator<KeyVal<ByteBuffer>> i = c.iterator();
+        while (i.hasNext()) {
+          final KeyVal<ByteBuffer> kv = i.next();
+          assertThat(kv.key().getInt(), is(list.pollFirst()));
+          assertThat(kv.val().getInt(), is(list.pollFirst()));
+        }
+        assertThat(i.hasNext(), is(false));
+        i.next();
       }
-      assertThat(i.hasNext(), is(false));
-      i.next();
     }
   }
 
@@ -284,81 +329,148 @@ public void openTest() {
 
   @Test
   public void removeOddElements() {
-    verify(all(), 2, 4, 6, 8);
-    int idx = -1;
-    try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      try (CursorIterable<ByteBuffer> ci = db.iterate(txn)) {
-        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
-        while (c.hasNext()) {
-          c.next();
-          idx++;
-          if (idx % 2 == 0) {
-            c.remove();
+    for (final Dbi<ByteBuffer> db : dbs) {
+      verify(db, all(), 2, 4, 6, 8);
+      int idx = -1;
+      try (Txn<ByteBuffer> txn = env.txnWrite()) {
+        try (CursorIterable<ByteBuffer> ci = db.iterate(txn)) {
+          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+          while (c.hasNext()) {
+            c.next();
+            idx++;
+            if (idx % 2 == 0) {
+              c.remove();
+            }
           }
         }
+        txn.commit();
       }
-      txn.commit();
+      verify(db, all(), 4, 8);
     }
-    verify(all(), 4, 8);
   }
 
   @Test(expected = Env.AlreadyClosedException.class)
   public void nextWithClosedEnvTest() {
-    try (Txn<ByteBuffer> txn = env.txnRead()) {
-      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+    for (final Dbi<ByteBuffer> db : dbs) {
+      try (Txn<ByteBuffer> txn = env.txnRead()) {
+        try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
 
-        env.close();
-        c.next();
+          env.close();
+          c.next();
+        }
       }
     }
   }
 
   @Test(expected = Env.AlreadyClosedException.class)
   public void removeWithClosedEnvTest() {
-    try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+    for (final Dbi<ByteBuffer> db : dbs) {
+      try (Txn<ByteBuffer> txn = env.txnWrite()) {
+        try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
 
-        final KeyVal<ByteBuffer> keyVal = c.next();
-        assertThat(keyVal, Matchers.notNullValue());
+          final KeyVal<ByteBuffer> keyVal = c.next();
+          assertThat(keyVal, Matchers.notNullValue());
 
-        env.close();
-        c.remove();
+          env.close();
+          c.remove();
+        }
       }
     }
   }
 
   @Test(expected = Env.AlreadyClosedException.class)
   public void hasNextWithClosedEnvTest() {
-    try (Txn<ByteBuffer> txn = env.txnRead()) {
-      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+    for (final Dbi<ByteBuffer> db : dbs) {
+      try (Txn<ByteBuffer> txn = env.txnRead()) {
+        try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
 
-        env.close();
-        c.hasNext();
+          env.close();
+          c.hasNext();
+        }
       }
     }
   }
 
   @Test(expected = Env.AlreadyClosedException.class)
   public void forEachRemainingWithClosedEnvTest() {
-    try (Txn<ByteBuffer> txn = env.txnRead()) {
-      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+    for (final Dbi<ByteBuffer> db : dbs) {
+      try (Txn<ByteBuffer> txn = env.txnRead()) {
+        try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
 
-        env.close();
-        c.forEachRemaining(keyVal -> {});
+          env.close();
+          c.forEachRemaining(keyVal -> {});
+        }
+      }
+    }
+  }
+
+  @Test
+  public void testSignedVsUnsigned() {
+    final ByteBuffer val1 = bb(1);
+    final ByteBuffer val2 = bb(2);
+    final ByteBuffer val110 = bb(110);
+    final ByteBuffer val111 = bb(111);
+    final ByteBuffer val150 = bb(150);
+
+    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
+    final Comparator<ByteBuffer> unsignedComparator = bufferProxy.getUnsignedComparator();
+    final Comparator<ByteBuffer> signedComparator = bufferProxy.getSignedComparator();
+
+    // Compare the same
+    assertThat(
+            unsignedComparator.compare(val1, val2),
+            Matchers.is(signedComparator.compare(val1, val2)));
+
+    // Compare differently
+    assertThat(
+            unsignedComparator.compare(val110, val150),
+            Matchers.not(signedComparator.compare(val110, val150)));
+
+    // Compare differently
+    assertThat(
+            unsignedComparator.compare(val111, val150),
+            Matchers.not(signedComparator.compare(val111, val150)));
+
+    // This will fail if the db is using a signed comparator for the start/stop keys
+    for (final Dbi<ByteBuffer> db : dbs) {
+      db.put(val110, val110);
+      db.put(val150, val150);
+
+      final ByteBuffer startKeyBuf = val111;
+      KeyRange<ByteBuffer> keyRange = KeyRange.atLeastBackward(startKeyBuf);
+
+      try (Txn<ByteBuffer> txn = env.txnRead();
+           CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
+        for (final CursorIterable.KeyVal<ByteBuffer> kv : c) {
+          final int key = kv.key().getInt();
+          final int val = kv.val().getInt();
+//          System.out.println("key: " + key + " val: " + val);
+          assertThat(key, is(110));
+          break;
+        }
       }
     }
   }
 
   private void verify(final KeyRange<ByteBuffer> range, final int... expected) {
-    verify(range, db, expected);
+    // Verify using all comparator types
+    for (final Dbi<ByteBuffer> db : dbs) {
+      verify(range, db, expected);
+    }
+  }
+
+  private void verify(
+      final Dbi<ByteBuffer> dbi, final KeyRange<ByteBuffer> range, final int... expected) {
+    verify(range, dbi, expected);
   }
 
   private void verify(
       final KeyRange<ByteBuffer> range, final Dbi<ByteBuffer> dbi, final int... expected) {
+
     final List<Integer> results = new ArrayList<>();
 
     try (Txn<ByteBuffer> txn = env.txnRead();
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 1fa80f6e..9c5cdb2e 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -111,7 +111,7 @@ public void close() {
   public void customComparator() {
     final Comparator<ByteBuffer> reverseOrder =
         (o1, o2) -> {
-          final int lexical = PROXY_OPTIMAL.getComparator().compare(o1, o2);
+          final int lexical = PROXY_OPTIMAL.getUnsignedComparator().compare(o1, o2);
           if (lexical == 0) {
             return 0;
           }
@@ -144,7 +144,7 @@ public void dbOpenMaxDatabases() {
   @Test
   public void dbiWithComparatorThreadSafety() {
     final DbiFlags[] flags = new DbiFlags[] {MDB_CREATE, MDB_INTEGERKEY};
-    final Comparator<ByteBuffer> c = PROXY_OPTIMAL.getComparator(flags);
+    final Comparator<ByteBuffer> c = PROXY_OPTIMAL.getUnsignedComparator();
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, c, true, flags);
 
     final List<Integer> keys = range(0, 1_000).boxed().collect(toList());
diff --git a/src/test/java/org/lmdbjava/KeyRangeTest.java b/src/test/java/org/lmdbjava/KeyRangeTest.java
index 6e104bbf..0197bf11 100644
--- a/src/test/java/org/lmdbjava/KeyRangeTest.java
+++ b/src/test/java/org/lmdbjava/KeyRangeTest.java
@@ -195,7 +195,10 @@ private void verify(final KeyRange<Integer> range, final int... expected) {
 
     IteratorOp op;
     do {
-      op = range.getType().iteratorOp(range.getStart(), range.getStop(), buff, Integer::compare);
+      final Integer finalBuff = buff;
+      final RangeComparator rangeComparator =
+          CursorIterable.createJavaRangeComparator(range, Integer::compareTo, () -> finalBuff);
+      op = range.getType().iteratorOp(range.getStart(), range.getStop(), buff, rangeComparator);
       switch (op) {
         case CALL_NEXT_OP:
           buff = cursor.apply(range.getType().nextOp(), range.getStart());
diff --git a/src/test/java/org/lmdbjava/TestUtils.java b/src/test/java/org/lmdbjava/TestUtils.java
index 42dcf052..f3d3974b 100644
--- a/src/test/java/org/lmdbjava/TestUtils.java
+++ b/src/test/java/org/lmdbjava/TestUtils.java
@@ -30,6 +30,8 @@
 final class TestUtils {
 
   public static final String DB_1 = "test-db-1";
+  public static final String DB_2 = "test-db-2";
+  public static final String DB_3 = "test-db-3";
 
   public static final int POSIX_MODE = 0664;
 

From 46f8d08194d989529f87b447f48fad0214c10e80 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Thu, 6 Mar 2025 17:27:25 +0000
Subject: [PATCH 198/322] gh-249 Remove non-J8 features, use indent size 2

---
 .../org/lmdbjava/CursorIterablePerfTest.java  | 220 +++++++++---------
 1 file changed, 110 insertions(+), 110 deletions(-)

diff --git a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
index a9647d56..ab94f85f 100644
--- a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
@@ -29,135 +29,135 @@ public class CursorIterablePerfTest {
     @Rule
     public final TemporaryFolder tmp = new TemporaryFolder();
 
-//    private static final int ITERATIONS = 5_000_000;
-    private static final int ITERATIONS = 100_000;
-//    private static final int ITERATIONS = 10;
-
-    private Dbi<ByteBuffer> dbJavaComparator;
-    private Dbi<ByteBuffer> dbLmdbComparator;
-    private Dbi<ByteBuffer> dbCallbackComparator;
-    private List<Dbi<ByteBuffer>> dbs = new ArrayList<>();
-    private Env<ByteBuffer> env;
-    private List<Integer> data = new ArrayList<>(ITERATIONS);
-
-    @Before
-    public void before() throws IOException {
-        final File path = tmp.newFile();
-        final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
-        env =
-                create(bufferProxy)
-                        .setMapSize(GIBIBYTES.toBytes(1))
-                        .setMaxReaders(1)
-                        .setMaxDbs(3)
-                        .open(path, POSIX_MODE, MDB_NOSUBDIR);
-
-        // Use a java comparator for start/stop keys only
+  //    private static final int ITERATIONS = 5_000_000;
+  private static final int ITERATIONS = 100_000;
+  //    private static final int ITERATIONS = 10;
+
+  private Dbi<ByteBuffer> dbJavaComparator;
+  private Dbi<ByteBuffer> dbLmdbComparator;
+  private Dbi<ByteBuffer> dbCallbackComparator;
+  private List<Dbi<ByteBuffer>> dbs = new ArrayList<>();
+  private Env<ByteBuffer> env;
+  private List<Integer> data = new ArrayList<>(ITERATIONS);
+
+  @Before
+  public void before() throws IOException {
+    final File path = tmp.newFile();
+    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
+    env =
+        create(bufferProxy)
+            .setMapSize(GIBIBYTES.toBytes(1))
+            .setMaxReaders(1)
+            .setMaxDbs(3)
+            .open(path, POSIX_MODE, MDB_NOSUBDIR);
+
+    // Use a java comparator for start/stop keys only
         dbJavaComparator = env.openDbi("JavaComparator", bufferProxy.getUnsignedComparator(), MDB_CREATE);
-        // Use LMDB comparator for start/stop keys
-        dbLmdbComparator = env.openDbi("LmdbComparator", MDB_CREATE);
-        // Use a java comparator for start/stop keys and as a callback comparator
+    // Use LMDB comparator for start/stop keys
+    dbLmdbComparator = env.openDbi("LmdbComparator", MDB_CREATE);
+    // Use a java comparator for start/stop keys and as a callback comparator
         dbCallbackComparator = env.openDbi(
                 "CallBackComparator", bufferProxy.getUnsignedComparator(), true, MDB_CREATE);
 
-        dbs.add(dbJavaComparator);
-        dbs.add(dbLmdbComparator);
-        dbs.add(dbCallbackComparator);
+    dbs.add(dbJavaComparator);
+    dbs.add(dbLmdbComparator);
+    dbs.add(dbCallbackComparator);
 
-        populateList();
+    populateList();
+  }
+
+  private void populateList() {
+    for (int i = 0; i < ITERATIONS * 2; i += 2) {
+      data.add(i);
     }
+  }
 
-    private void populateList() {
-        for (int i = 0; i < ITERATIONS * 2; i+=2) {
-            data.add(i);
-        }
+  private void populateDatabases(final boolean randomOrder) {
+    System.out.println("Clear then populate databases");
+
+    final List<Integer> data;
+    if (randomOrder) {
+      data = new ArrayList<>(this.data);
+      Collections.shuffle(data);
+    } else {
+      data = this.data;
     }
 
-    private void populateDatabases(final boolean randomOrder) {
-        System.out.println("Clear then populate databases");
+    for (int round = 0; round < 3; round++) {
+      System.out.println("round: " + round + " -----------------------------------------");
 
-        final List<Integer> data;
-        if (randomOrder) {
-            data = new ArrayList<>(this.data);
-            Collections.shuffle(data);
-        } else {
-            data = this.data;
+      for (final Dbi<ByteBuffer> db : dbs) {
+        // Clean out the db first
+        try (Txn<ByteBuffer> txn = env.txnWrite();
+            final Cursor<ByteBuffer> cursor = db.openCursor(txn)) {
+          while (cursor.next()) {
+            cursor.delete();
+          }
         }
 
-        for (int round = 0; round < 3; round++) {
-            System.out.println("round: " + round + " -----------------------------------------");
-
-            for (final Dbi<ByteBuffer> db : dbs) {
-                // Clean out the db first
-                try (Txn<ByteBuffer> txn = env.txnWrite();
-                     final Cursor<ByteBuffer> cursor = db.openCursor(txn)) {
-                    while (cursor.next()) {
-                        cursor.delete();
-                    }
-                }
-
-                final String dbName = new String(db.getName(), StandardCharsets.UTF_8);
-                final Instant start = Instant.now();
-                try (Txn<ByteBuffer> txn = env.txnWrite()) {
-                    for (final Integer i : data) {
-                        if (randomOrder) {
-                            db.put(txn, bb(i), bb(i + 1), MDB_NOOVERWRITE);
-                        } else {
-                            db.put(txn, bb(i), bb(i + 1), MDB_NOOVERWRITE, MDB_APPEND);
-                        }
-                    }
-                    txn.commit();
-                }
-                final Duration duration = Duration.between(start, Instant.now());
+        final String dbName = new String(db.getName(), StandardCharsets.UTF_8);
+        final Instant start = Instant.now();
+        try (Txn<ByteBuffer> txn = env.txnWrite()) {
+          for (final Integer i : data) {
+            if (randomOrder) {
+              db.put(txn, bb(i), bb(i + 1), MDB_NOOVERWRITE);
+            } else {
+              db.put(txn, bb(i), bb(i + 1), MDB_NOOVERWRITE, MDB_APPEND);
+            }
+          }
+          txn.commit();
+        }
+        final Duration duration = Duration.between(start, Instant.now());
                 System.out.println("DB: " + dbName
                         + " - Loaded in duration: " + duration
                         + ", millis: " + duration.toMillis());
-            }
-        }
-    }
-
-    @After
-    public void after() {
-        env.close();
-        tmp.delete();
+      }
     }
-
-    @Test
-    public void comparePerf_sequential() {
-        comparePerf(false);
-    }
-
-    @Test
-    public void comparePerf_random() {
-        comparePerf(true);
-    }
-
-    public void comparePerf(final boolean randomOrder) {
-        populateDatabases(randomOrder);
-        final ByteBuffer startKeyBuf = bb(data.getFirst());
-        final ByteBuffer stopKeyBuf = bb(data.getLast());
-        final KeyRange<ByteBuffer> keyRange = KeyRange.closed(startKeyBuf, stopKeyBuf);
-
-        System.out.println("\nIterating over all entries");
-        for (int round = 0; round < 3; round++) {
-            System.out.println("round: " + round + " -----------------------------------------");
-            for (final Dbi<ByteBuffer> db : dbs) {
-                final String dbName = new String(db.getName(), StandardCharsets.UTF_8);
-
-                final Instant start = Instant.now();
-                int cnt = 0;
-                // Exercise the stop key comparator on every entry
-                try (Txn<ByteBuffer> txn = env.txnRead();
-                     CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
-                    for (final CursorIterable.KeyVal<ByteBuffer> kv : c) {
-                        cnt++;
-                    }
-                }
-                final Duration duration = Duration.between(start, Instant.now());
+  }
+
+  @After
+  public void after() {
+    env.close();
+    tmp.delete();
+  }
+
+  @Test
+  public void comparePerf_sequential() {
+    comparePerf(false);
+  }
+
+  @Test
+  public void comparePerf_random() {
+    comparePerf(true);
+  }
+
+  public void comparePerf(final boolean randomOrder) {
+    populateDatabases(randomOrder);
+    final ByteBuffer startKeyBuf = bb(data.get(0));
+    final ByteBuffer stopKeyBuf = bb(data.get(data.size() - 1));
+    final KeyRange<ByteBuffer> keyRange = KeyRange.closed(startKeyBuf, stopKeyBuf);
+
+    System.out.println("\nIterating over all entries");
+    for (int round = 0; round < 3; round++) {
+      System.out.println("round: " + round + " -----------------------------------------");
+      for (final Dbi<ByteBuffer> db : dbs) {
+        final String dbName = new String(db.getName(), StandardCharsets.UTF_8);
+
+        final Instant start = Instant.now();
+        int cnt = 0;
+        // Exercise the stop key comparator on every entry
+        try (Txn<ByteBuffer> txn = env.txnRead();
+            CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
+          for (final CursorIterable.KeyVal<ByteBuffer> kv : c) {
+            cnt++;
+          }
+        }
+        final Duration duration = Duration.between(start, Instant.now());
                 System.out.println("DB: " + dbName
                         + " - Iterated in duration: " + duration
                         + ", millis: " + duration.toMillis()
                         + ", cnt: " + cnt);
-            }
-        }
+      }
     }
+  }
 }

From f92012ecc079149b2414925e0a077a75f82ba043 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Thu, 6 Mar 2025 17:33:40 +0000
Subject: [PATCH 199/322] gh-249 Fix indents

---
 .../org/lmdbjava/CursorIterablePerfTest.java  | 28 +++++++++----------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
index ab94f85f..99667b1d 100644
--- a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
@@ -26,8 +26,8 @@
 
 public class CursorIterablePerfTest {
 
-    @Rule
-    public final TemporaryFolder tmp = new TemporaryFolder();
+  @Rule
+  public final TemporaryFolder tmp = new TemporaryFolder();
 
   //    private static final int ITERATIONS = 5_000_000;
   private static final int ITERATIONS = 100_000;
@@ -52,12 +52,12 @@ public void before() throws IOException {
             .open(path, POSIX_MODE, MDB_NOSUBDIR);
 
     // Use a java comparator for start/stop keys only
-        dbJavaComparator = env.openDbi("JavaComparator", bufferProxy.getUnsignedComparator(), MDB_CREATE);
+    dbJavaComparator = env.openDbi("JavaComparator", bufferProxy.getUnsignedComparator(), MDB_CREATE);
     // Use LMDB comparator for start/stop keys
     dbLmdbComparator = env.openDbi("LmdbComparator", MDB_CREATE);
     // Use a java comparator for start/stop keys and as a callback comparator
-        dbCallbackComparator = env.openDbi(
-                "CallBackComparator", bufferProxy.getUnsignedComparator(), true, MDB_CREATE);
+    dbCallbackComparator = env.openDbi(
+        "CallBackComparator", bufferProxy.getUnsignedComparator(), true, MDB_CREATE);
 
     dbs.add(dbJavaComparator);
     dbs.add(dbLmdbComparator);
@@ -89,7 +89,7 @@ private void populateDatabases(final boolean randomOrder) {
       for (final Dbi<ByteBuffer> db : dbs) {
         // Clean out the db first
         try (Txn<ByteBuffer> txn = env.txnWrite();
-            final Cursor<ByteBuffer> cursor = db.openCursor(txn)) {
+             final Cursor<ByteBuffer> cursor = db.openCursor(txn)) {
           while (cursor.next()) {
             cursor.delete();
           }
@@ -108,9 +108,9 @@ private void populateDatabases(final boolean randomOrder) {
           txn.commit();
         }
         final Duration duration = Duration.between(start, Instant.now());
-                System.out.println("DB: " + dbName
-                        + " - Loaded in duration: " + duration
-                        + ", millis: " + duration.toMillis());
+        System.out.println("DB: " + dbName
+            + " - Loaded in duration: " + duration
+            + ", millis: " + duration.toMillis());
       }
     }
   }
@@ -147,16 +147,16 @@ public void comparePerf(final boolean randomOrder) {
         int cnt = 0;
         // Exercise the stop key comparator on every entry
         try (Txn<ByteBuffer> txn = env.txnRead();
-            CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
+             CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
           for (final CursorIterable.KeyVal<ByteBuffer> kv : c) {
             cnt++;
           }
         }
         final Duration duration = Duration.between(start, Instant.now());
-                System.out.println("DB: " + dbName
-                        + " - Iterated in duration: " + duration
-                        + ", millis: " + duration.toMillis()
-                        + ", cnt: " + cnt);
+        System.out.println("DB: " + dbName
+            + " - Iterated in duration: " + duration
+            + ", millis: " + duration.toMillis()
+            + ", cnt: " + cnt);
       }
     }
   }

From e1756d633d7cbd1d23a33ffa0fcaaaa44c06aacd Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Thu, 6 Mar 2025 19:02:46 +0000
Subject: [PATCH 200/322] gh-249 Tidy code and refactor RangeComparator impls

---
 src/main/java/org/lmdbjava/BufferProxy.java   |   8 +-
 .../java/org/lmdbjava/CursorIterable.java     | 544 ++++++++++--------
 src/main/java/org/lmdbjava/Env.java           |  23 +-
 src/main/java/org/lmdbjava/Key.java           |   4 +-
 src/main/java/org/lmdbjava/KeyRangeType.java  |   4 +-
 .../java/org/lmdbjava/RangeComparator.java    |  26 +-
 .../org/lmdbjava/CursorIterablePerfTest.java  |  37 +-
 .../java/org/lmdbjava/CursorIterableTest.java |  18 +-
 src/test/java/org/lmdbjava/KeyRangeTest.java  |   4 +-
 9 files changed, 376 insertions(+), 292 deletions(-)

diff --git a/src/main/java/org/lmdbjava/BufferProxy.java b/src/main/java/org/lmdbjava/BufferProxy.java
index 26d9db74..ab7ba3a4 100644
--- a/src/main/java/org/lmdbjava/BufferProxy.java
+++ b/src/main/java/org/lmdbjava/BufferProxy.java
@@ -69,11 +69,9 @@ protected BufferProxy() {}
   /**
    * Get a suitable default {@link Comparator} to compare numeric key values as signed.
    *
-   * <p>
-   * Note: LMDB's default comparator is unsigned so if this is used only for the {@link CursorIterable}
-   * start/stop key comparisons then its behaviour will differ from the iteration order. Use
-   * with caution.
-   * </p>
+   * <p>Note: LMDB's default comparator is unsigned so if this is used only for the {@link
+   * CursorIterable} start/stop key comparisons then its behaviour will differ from the iteration
+   * order. Use with caution.
    *
    * @return a comparator that can be used (never null)
    */
diff --git a/src/main/java/org/lmdbjava/CursorIterable.java b/src/main/java/org/lmdbjava/CursorIterable.java
index 6b92a9cd..7c487bae 100644
--- a/src/main/java/org/lmdbjava/CursorIterable.java
+++ b/src/main/java/org/lmdbjava/CursorIterable.java
@@ -42,266 +42,352 @@
  */
 public final class CursorIterable<T> implements Iterable<CursorIterable.KeyVal<T>>, AutoCloseable {
 
-    //  private final Comparator<T> comparator;
-    private final RangeComparator rangeComparator;
-    private final Cursor<T> cursor;
-    private final Dbi<T> dbi;
-    private final KeyVal<T> entry;
-    private boolean iteratorReturned;
-    private final KeyRange<T> range;
-    private State state = REQUIRES_INITIAL_OP;
-    private final Key<T> startKey;
-    private final Key<T> stopKey;
+  //  private final Comparator<T> comparator;
+  private final RangeComparator rangeComparator;
+  private final Cursor<T> cursor;
+  private final KeyVal<T> entry;
+  private boolean iteratorReturned;
+  private final KeyRange<T> range;
+  private State state = REQUIRES_INITIAL_OP;
 
-    CursorIterable(
-            final Txn<T> txn,
-            final Dbi<T> dbi,
-            final KeyRange<T> range,
-            final Comparator<T> comparator,
-            final BufferProxy<T> proxy) {
-        this.cursor = dbi.openCursor(txn);
-        this.dbi = dbi;
-        this.range = range;
-        this.entry = new KeyVal<>();
-
-        if (comparator != null) {
-            // User supplied java-side comparator so use that
-            this.rangeComparator = createJavaRangeComparator(range, comparator, entry::key);
-            this.startKey = null;
-            this.stopKey = null;
-        } else {
-            // No java-side comparator so call down to LMDB to do the comparison
-            this.rangeComparator = createLmdbDbiComparator(txn.pointer(), dbi.pointer());
-            // Allocate buffers for use with the start/stop keys if required.
-            // Saves us copying bytes on each comparison
-            this.startKey = createKey(range.getStart(), proxy);
-            this.stopKey = createKey(range.getStop(), proxy);
-        }
+  CursorIterable(
+      final Txn<T> txn,
+      final Dbi<T> dbi,
+      final KeyRange<T> range,
+      final Comparator<T> comparator,
+      final BufferProxy<T> proxy) {
+    this.cursor = dbi.openCursor(txn);
+    this.range = range;
+    this.entry = new KeyVal<>();
+
+    if (comparator != null) {
+      // User supplied java-side comparator so use that
+      this.rangeComparator = new JavaRangeComparator<>(range, comparator, entry::key);
+    } else {
+      // No java-side comparator so call down to LMDB to do the comparison
+      this.rangeComparator = new LmdbRangeComparator<>(txn, dbi, cursor, range, proxy);
     }
+  }
 
-    private Key<T> createKey(final T keyBuffer, final BufferProxy<T> proxy) {
-        if (keyBuffer != null) {
-            final Key<T> key = proxy.key();
-            key.keyIn(keyBuffer);
-            return key;
-        } else {
-            return null;
+  //  static <T> RangeComparator createJavaRangeComparator(
+  //      final KeyRange<T> range,
+  //      final Comparator<T> comparator,
+  //      final Supplier<T> currentKeySupplier) {
+  //    final T start = range.getStart();
+  //    final T stop = range.getStop();
+  //    return new RangeComparator() {
+  //      @Override
+  //      public int compareToStartKey() {
+  //        return comparator.compare(currentKeySupplier.get(), start);
+  //      }
+  //
+  //      @Override
+  //      public int compareToStopKey() {
+  //        return comparator.compare(currentKeySupplier.get(), stop);
+  //      }
+  //    };
+  //  }
+
+  //  /**
+  //   * Calls down to mdb_cmp to make use of the comparator that LMDB uses for insertion order.
+  //   *
+  //   * @param txnPointer The pointer to the transaction.
+  //   * @param dbiPointer The pointer to the Dbi so LMDB can use the comparator of the Dbi
+  //   * @param proxy
+  //   */
+  //  private RangeComparator createLmdbDbiComparator(final Pointer txnPointer,
+  //                                                  final Pointer dbiPointer,
+  //                                                  final Pointer cursorKeyPointer,
+  //                                                  final KeyRange<T> range,
+  //                                                  final BufferProxy<T> proxy) {
+  //    Objects.requireNonNull(txnPointer);
+  //    Objects.requireNonNull(dbiPointer);
+  //    Objects.requireNonNull(range);
+  //    Objects.requireNonNull(cursor);
+  //    // Allocate buffers for use with the start/stop keys if required.
+  //    // Saves us copying bytes on each comparison
+  //    final Key<T> startKey = createKey(range.getStart(), proxy);
+  //    final Key<T> stopKey = createKey(range.getStop(), proxy);
+  //
+  //    return new RangeComparator() {
+  //      @Override
+  //      public int compareToStartKey() {
+  //        return LIB.mdb_cmp(txnPointer, dbiPointer, cursor.keyVal().pointerKey(),
+  // startKey.pointer());
+  //      }
+  //
+  //      @Override
+  //      public int compareToStopKey() {
+  //        return LIB.mdb_cmp(txnPointer, dbiPointer, cursor.keyVal().pointerKey(),
+  // stopKey.pointer());
+  //      }
+  //    };
+  //  }
+
+  @Override
+  public void close() {
+    cursor.close();
+    try {
+      rangeComparator.close();
+    } catch (Exception e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  /**
+   * Obtain an iterator.
+   *
+   * <p>As iteration of the returned iterator will cause movement of the underlying LMDB cursor, an
+   * {@link IllegalStateException} is thrown if an attempt is made to obtain the iterator more than
+   * once. For advanced cursor control (such as being able to iterate over the same data multiple
+   * times etc) please instead refer to {@link Dbi#openCursor(org.lmdbjava.Txn)}.
+   *
+   * @return an iterator
+   */
+  @Override
+  public Iterator<KeyVal<T>> iterator() {
+    if (iteratorReturned) {
+      throw new IllegalStateException("Iterator can only be returned once");
+    }
+    iteratorReturned = true;
+
+    return new Iterator<KeyVal<T>>() {
+      @Override
+      public boolean hasNext() {
+        while (state != RELEASED && state != TERMINATED) {
+          update();
+        }
+        return state == RELEASED;
+      }
+
+      @Override
+      public KeyVal<T> next() {
+        if (!hasNext()) {
+          throw new NoSuchElementException();
         }
+        state = REQUIRES_NEXT_OP;
+        return entry;
+      }
+
+      @Override
+      public void remove() {
+        cursor.delete();
+      }
+    };
+  }
+
+  private void executeCursorOp(final CursorOp op) {
+    final boolean found;
+    switch (op) {
+      case FIRST:
+        found = cursor.first();
+        break;
+      case LAST:
+        found = cursor.last();
+        break;
+      case NEXT:
+        found = cursor.next();
+        break;
+      case PREV:
+        found = cursor.prev();
+        break;
+      case GET_START_KEY:
+        found = cursor.get(range.getStart(), MDB_SET_RANGE);
+        break;
+      case GET_START_KEY_BACKWARD:
+        found = cursor.get(range.getStart(), MDB_SET_RANGE) || cursor.last();
+        break;
+      default:
+        throw new IllegalStateException("Unknown cursor operation");
     }
+    entry.setK(found ? cursor.key() : null);
+    entry.setV(found ? cursor.val() : null);
+  }
 
-    static <T> RangeComparator createJavaRangeComparator(
-            final KeyRange<T> range,
-            final Comparator<T> comparator,
-            final Supplier<T> currentKeySupplier) {
-        final T start = range.getStart();
-        final T stop = range.getStop();
-        return new RangeComparator() {
-            @Override
-            public int compareToStartKey() {
-                return comparator.compare(currentKeySupplier.get(), start);
-            }
-
-            @Override
-            public int compareToStopKey() {
-                return comparator.compare(currentKeySupplier.get(), stop);
-            }
-        };
+  private void executeIteratorOp() {
+    final IteratorOp op = range.getType().iteratorOp(entry.key(), rangeComparator);
+    switch (op) {
+      case CALL_NEXT_OP:
+        executeCursorOp(range.getType().nextOp());
+        state = REQUIRES_ITERATOR_OP;
+        break;
+      case TERMINATE:
+        state = TERMINATED;
+        break;
+      case RELEASE:
+        state = RELEASED;
+        break;
+      default:
+        throw new IllegalStateException("Unknown operation");
     }
+  }
+
+  private void update() {
+    switch (state) {
+      case REQUIRES_INITIAL_OP:
+        executeCursorOp(range.getType().initialOp());
+        state = REQUIRES_ITERATOR_OP;
+        break;
+      case REQUIRES_NEXT_OP:
+        executeCursorOp(range.getType().nextOp());
+        state = REQUIRES_ITERATOR_OP;
+        break;
+      case REQUIRES_ITERATOR_OP:
+        executeIteratorOp();
+        break;
+      case TERMINATED:
+        break;
+      default:
+        throw new IllegalStateException("Unknown state");
+    }
+  }
+
+  /**
+   * Holder for a key and value pair.
+   *
+   * <p>The same holder instance will always be returned for a given iterator. The returned keys and
+   * values may change or point to different memory locations following changes in the iterator,
+   * cursor or transaction.
+   *
+   * @param <T> buffer type
+   */
+  public static final class KeyVal<T> {
+
+    private T k;
+    private T v;
+
+    /** Explicitly-defined default constructor to avoid warnings. */
+    public KeyVal() {}
 
     /**
-     * Calls down to mdb_cmp to make use of the comparator that LMDB uses for insertion order.
+     * The key.
      *
-     * @param txnPointer The pointer to the transaction.
-     * @param dbiPointer The pointer to the Dbi so LMDB can use the comparator of the Dbi
+     * @return key
      */
-    private RangeComparator createLmdbDbiComparator(
-            final Pointer txnPointer, final Pointer dbiPointer) {
-        Objects.requireNonNull(txnPointer);
-        Objects.requireNonNull(dbiPointer);
-        Objects.requireNonNull(cursor);
-
-        return new RangeComparator() {
-            @Override
-            public int compareToStartKey() {
-                return LIB.mdb_cmp(txnPointer, dbiPointer, cursor.keyVal().pointerKey(), startKey.pointerKey());
-            }
-
-            @Override
-            public int compareToStopKey() {
-                return LIB.mdb_cmp(txnPointer, dbiPointer, cursor.keyVal().pointerKey(), stopKey.pointerKey());
-            }
-        };
-    }
-
-    @Override
-    public void close() {
-        cursor.close();
+    public T key() {
+      return k;
     }
 
     /**
-     * Obtain an iterator.
+     * The value.
      *
-     * <p>As iteration of the returned iterator will cause movement of the underlying LMDB cursor, an
-     * {@link IllegalStateException} is thrown if an attempt is made to obtain the iterator more than
-     * once. For advanced cursor control (such as being able to iterate over the same data multiple
-     * times etc) please instead refer to {@link Dbi#openCursor(org.lmdbjava.Txn)}.
-     *
-     * @return an iterator
+     * @return value
      */
-    @Override
-    public Iterator<KeyVal<T>> iterator() {
-        if (iteratorReturned) {
-            throw new IllegalStateException("Iterator can only be returned once");
-        }
-        iteratorReturned = true;
-
-        return new Iterator<KeyVal<T>>() {
-            @Override
-            public boolean hasNext() {
-                while (state != RELEASED && state != TERMINATED) {
-                    update();
-                }
-                return state == RELEASED;
-            }
-
-            @Override
-            public KeyVal<T> next() {
-                if (!hasNext()) {
-                    throw new NoSuchElementException();
-                }
-                state = REQUIRES_NEXT_OP;
-                return entry;
-            }
-
-            @Override
-            public void remove() {
-                cursor.delete();
-            }
-        };
+    public T val() {
+      return v;
     }
 
-    private void executeCursorOp(final CursorOp op) {
-        final boolean found;
-        switch (op) {
-            case FIRST:
-                found = cursor.first();
-                break;
-            case LAST:
-                found = cursor.last();
-                break;
-            case NEXT:
-                found = cursor.next();
-                break;
-            case PREV:
-                found = cursor.prev();
-                break;
-            case GET_START_KEY:
-                found = cursor.get(range.getStart(), MDB_SET_RANGE);
-                break;
-            case GET_START_KEY_BACKWARD:
-                found = cursor.get(range.getStart(), MDB_SET_RANGE) || cursor.last();
-                break;
-            default:
-                throw new IllegalStateException("Unknown cursor operation");
-        }
-        entry.setK(found ? cursor.key() : null);
-        entry.setV(found ? cursor.val() : null);
+    void setK(final T key) {
+      this.k = key;
     }
 
-    private void executeIteratorOp() {
-        final IteratorOp op =
-                range.getType().iteratorOp(range.getStart(), range.getStop(), entry.key(), rangeComparator);
-        switch (op) {
-            case CALL_NEXT_OP:
-                executeCursorOp(range.getType().nextOp());
-                state = REQUIRES_ITERATOR_OP;
-                break;
-            case TERMINATE:
-                state = TERMINATED;
-                break;
-            case RELEASE:
-                state = RELEASED;
-                break;
-            default:
-                throw new IllegalStateException("Unknown operation");
-        }
+    void setV(final T val) {
+      this.v = val;
     }
+  }
 
-    private void update() {
-        switch (state) {
-            case REQUIRES_INITIAL_OP:
-                executeCursorOp(range.getType().initialOp());
-                state = REQUIRES_ITERATOR_OP;
-                break;
-            case REQUIRES_NEXT_OP:
-                executeCursorOp(range.getType().nextOp());
-                state = REQUIRES_ITERATOR_OP;
-                break;
-            case REQUIRES_ITERATOR_OP:
-                executeIteratorOp();
-                break;
-            case TERMINATED:
-                break;
-            default:
-                throw new IllegalStateException("Unknown state");
-        }
+  /** Represents the internal {@link CursorIterable} state. */
+  enum State {
+    REQUIRES_INITIAL_OP,
+    REQUIRES_NEXT_OP,
+    REQUIRES_ITERATOR_OP,
+    RELEASED,
+    TERMINATED
+  }
+
+  static class JavaRangeComparator<T> implements RangeComparator {
+
+    private final Comparator<T> comparator;
+    private final Supplier<T> currentKeySupplier;
+    private final T start;
+    private final T stop;
+
+    JavaRangeComparator(
+        final KeyRange<T> range,
+        final Comparator<T> comparator,
+        final Supplier<T> currentKeySupplier) {
+      this.comparator = comparator;
+      this.currentKeySupplier = currentKeySupplier;
+      this.start = range.getStart();
+      this.stop = range.getStop();
     }
 
-    /**
-     * Holder for a key and value pair.
-     *
-     * <p>The same holder instance will always be returned for a given iterator. The returned keys and
-     * values may change or point to different memory locations following changes in the iterator,
-     * cursor or transaction.
-     *
-     * @param <T> buffer type
-     */
-    public static final class KeyVal<T> {
+    @Override
+    public int compareToStartKey() {
+      return comparator.compare(currentKeySupplier.get(), start);
+    }
 
-        private T k;
-        private T v;
+    @Override
+    public int compareToStopKey() {
+      return comparator.compare(currentKeySupplier.get(), stop);
+    }
 
-        /**
-         * Explicitly-defined default constructor to avoid warnings.
-         */
-        public KeyVal() {
-        }
+    @Override
+    public void close() throws Exception {
+      // Nothing to close
+    }
+  }
 
-        /**
-         * The key.
-         *
-         * @return key
-         */
-        public T key() {
-            return k;
-        }
+  /**
+   * Calls down to mdb_cmp to make use of the comparator that LMDB uses for insertion order. Has a
+   * very slight overhead as compared to {@link JavaRangeComparator}.
+   */
+  private static class LmdbRangeComparator<T> implements RangeComparator {
 
-        /**
-         * The value.
-         *
-         * @return value
-         */
-        public T val() {
-            return v;
-        }
+    private final Pointer txnPointer;
+    private final Pointer dbiPointer;
+    private final Pointer cursorKeyPointer;
+    private final Key<T> startKey;
+    private final Key<T> stopKey;
+    private final Pointer startKeyPointer;
+    private final Pointer stopKeyPointer;
 
-        void setK(final T key) {
-            this.k = key;
-        }
+    public LmdbRangeComparator(
+        final Txn<T> txn,
+        final Dbi<T> dbi,
+        final Cursor<T> cursor,
+        final KeyRange<T> range,
+        final BufferProxy<T> proxy) {
+      txnPointer = Objects.requireNonNull(txn).pointer();
+      dbiPointer = Objects.requireNonNull(dbi).pointer();
+      cursorKeyPointer = Objects.requireNonNull(cursor).keyVal().pointerKey();
+      // Allocate buffers for use with the start/stop keys if required.
+      // Saves us copying bytes on each comparison
+      Objects.requireNonNull(range);
+      startKey = createKey(range.getStart(), proxy);
+      stopKey = createKey(range.getStop(), proxy);
+      startKeyPointer = startKey != null ? startKey.pointer() : null;
+      stopKeyPointer = stopKey != null ? stopKey.pointer() : null;
+    }
 
-        void setV(final T val) {
-            this.v = val;
-        }
+    @Override
+    public int compareToStartKey() {
+      return LIB.mdb_cmp(txnPointer, dbiPointer, cursorKeyPointer, startKeyPointer);
     }
 
-    /**
-     * Represents the internal {@link CursorIterable} state.
-     */
-    enum State {
-        REQUIRES_INITIAL_OP,
-        REQUIRES_NEXT_OP,
-        REQUIRES_ITERATOR_OP,
-        RELEASED,
-        TERMINATED
+    @Override
+    public int compareToStopKey() {
+      return LIB.mdb_cmp(txnPointer, dbiPointer, cursorKeyPointer, stopKeyPointer);
+    }
+
+    @Override
+    public void close() {
+      if (startKey != null) {
+        startKey.close();
+      }
+      if (stopKey != null) {
+        stopKey.close();
+      }
+    }
+
+    private Key<T> createKey(final T keyBuffer, final BufferProxy<T> proxy) {
+      if (keyBuffer != null) {
+        final Key<T> key = proxy.key();
+        key.keyIn(keyBuffer);
+        return key;
+      } else {
+        return null;
+      }
     }
+  }
 }
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 1543282c..2e4822b7 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -257,16 +257,15 @@ public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
   /**
    * Convenience method that opens a {@link Dbi} with a UTF-8 database name and associated {@link
    * Comparator} for use by {@link CursorIterable} when comparing start/stop keys.
-   * <p>
-   * It is very important that the passed comparator behaves in the same way as the comparator
+   *
+   * <p>It is very important that the passed comparator behaves in the same way as the comparator
    * LMDB uses for its insertion order (for the type of data that will be stored in the database),
-   * or you fully understand the implications of them behaving differently.
-   * LMDB's comparator is unsigned lexicographical, unless {@link DbiFlags#MDB_INTEGERKEY} is used.
-   * </p>
+   * or you fully understand the implications of them behaving differently. LMDB's comparator is
+   * unsigned lexicographical, unless {@link DbiFlags#MDB_INTEGERKEY} is used.
    *
    * @param name name of the database (or null if no name is required)
-   * @param comparator custom comparator for cursor start/stop key comparisons. If null,
-   *                   LMDB's comparator will be used.
+   * @param comparator custom comparator for cursor start/stop key comparisons. If null, LMDB's
+   *     comparator will be used.
    * @param flags to open the database with
    * @return a database that is ready to use
    */
@@ -278,14 +277,14 @@ public Dbi<T> openDbi(
 
   /**
    * Convenience method that opens a {@link Dbi} with a UTF-8 database name and associated {@link
-   * Comparator}. The comparator will be used by {@link CursorIterable} when comparing start/stop keys
-   * as a minimum. If nativeCb is {@code true}, this comparator will also be called by LMDB to determine
-   * insertion/iteration order. Calling back to a java comparator may significantly impact performance.
+   * Comparator}. The comparator will be used by {@link CursorIterable} when comparing start/stop
+   * keys as a minimum. If nativeCb is {@code true}, this comparator will also be called by LMDB to
+   * determine insertion/iteration order. Calling back to a java comparator may significantly impact
+   * performance.
    *
    * @param name name of the database (or null if no name is required)
    * @param comparator custom comparator for cursor start/stop key comparisons and optionally for
-   *                   LMDB to call back to. If null,
-   *                   LMDB's comparator will be used.
+   *     LMDB to call back to. If null, LMDB's comparator will be used.
    * @param nativeCb whether LMDB native code calls back to the Java comparator
    * @param flags to open the database with
    * @return a database that is ready to use
diff --git a/src/main/java/org/lmdbjava/Key.java b/src/main/java/org/lmdbjava/Key.java
index 7fd8bbe2..12c54290 100644
--- a/src/main/java/org/lmdbjava/Key.java
+++ b/src/main/java/org/lmdbjava/Key.java
@@ -33,7 +33,6 @@ final class Key<T> implements AutoCloseable {
   private boolean closed;
   private T k;
   private final BufferProxy<T> proxy;
-  private final Pointer ptrArray;
   private final Pointer ptrKey;
   private final long ptrKeyAddr;
 
@@ -43,7 +42,6 @@ final class Key<T> implements AutoCloseable {
     this.k = proxy.allocate();
     ptrKey = MEM_MGR.allocateTemporary(MDB_VAL_STRUCT_SIZE, false);
     ptrKeyAddr = ptrKey.address();
-    ptrArray = MEM_MGR.allocateTemporary(MDB_VAL_STRUCT_SIZE * 2, false);
   }
 
   @Override
@@ -68,7 +66,7 @@ T keyOut() {
     return k;
   }
 
-  Pointer pointerKey() {
+  Pointer pointer() {
     return ptrKey;
   }
 }
diff --git a/src/main/java/org/lmdbjava/KeyRangeType.java b/src/main/java/org/lmdbjava/KeyRangeType.java
index 07123e9a..26f09636 100644
--- a/src/main/java/org/lmdbjava/KeyRangeType.java
+++ b/src/main/java/org/lmdbjava/KeyRangeType.java
@@ -319,14 +319,12 @@ CursorOp initialOp() {
    *
    * @param <T> buffer type
    * @param <C> comparator for the buffers
-   * @param start start buffer
-   * @param stop stop buffer
    * @param buffer current key returned by LMDB (may be null)
    * @param rangeComparator comparator (required)
    * @return response to this key
    */
   <T, C extends Comparator<T>> IteratorOp iteratorOp(
-      final T start, final T stop, final T buffer, final RangeComparator rangeComparator) {
+      final T buffer, final RangeComparator rangeComparator) {
     requireNonNull(rangeComparator, "Comparator required");
     if (buffer == null) {
       return TERMINATE;
diff --git a/src/main/java/org/lmdbjava/RangeComparator.java b/src/main/java/org/lmdbjava/RangeComparator.java
index 162584b1..59d46015 100644
--- a/src/main/java/org/lmdbjava/RangeComparator.java
+++ b/src/main/java/org/lmdbjava/RangeComparator.java
@@ -1,19 +1,17 @@
 package org.lmdbjava;
 
-/**
- * For comparing a cursor's current key against a {@link KeyRange}'s start/stop key.
- */
-interface RangeComparator {
+/** For comparing a cursor's current key against a {@link KeyRange}'s start/stop key. */
+interface RangeComparator extends AutoCloseable {
 
-    /**
-     * Compare the cursor's current key to the range start key. Equivalent to compareTo(currentKey,
-     * startKey)
-     */
-    int compareToStartKey();
+  /**
+   * Compare the cursor's current key to the range start key. Equivalent to compareTo(currentKey,
+   * startKey)
+   */
+  int compareToStartKey();
 
-    /**
-     * Compare the cursor's current key to the range stop key. Equivalent to compareTo(currentKey,
-     * stopKey)
-     */
-    int compareToStopKey();
+  /**
+   * Compare the cursor's current key to the range stop key. Equivalent to compareTo(currentKey,
+   * stopKey)
+   */
+  int compareToStopKey();
 }
diff --git a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
index 99667b1d..19e5a9b9 100644
--- a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
@@ -26,8 +26,7 @@
 
 public class CursorIterablePerfTest {
 
-  @Rule
-  public final TemporaryFolder tmp = new TemporaryFolder();
+  @Rule public final TemporaryFolder tmp = new TemporaryFolder();
 
   //    private static final int ITERATIONS = 5_000_000;
   private static final int ITERATIONS = 100_000;
@@ -52,12 +51,13 @@ public void before() throws IOException {
             .open(path, POSIX_MODE, MDB_NOSUBDIR);
 
     // Use a java comparator for start/stop keys only
-    dbJavaComparator = env.openDbi("JavaComparator", bufferProxy.getUnsignedComparator(), MDB_CREATE);
+    dbJavaComparator =
+        env.openDbi("JavaComparator", bufferProxy.getUnsignedComparator(), MDB_CREATE);
     // Use LMDB comparator for start/stop keys
     dbLmdbComparator = env.openDbi("LmdbComparator", MDB_CREATE);
     // Use a java comparator for start/stop keys and as a callback comparator
-    dbCallbackComparator = env.openDbi(
-        "CallBackComparator", bufferProxy.getUnsignedComparator(), true, MDB_CREATE);
+    dbCallbackComparator =
+        env.openDbi("CallBackComparator", bufferProxy.getUnsignedComparator(), true, MDB_CREATE);
 
     dbs.add(dbJavaComparator);
     dbs.add(dbLmdbComparator);
@@ -89,7 +89,7 @@ private void populateDatabases(final boolean randomOrder) {
       for (final Dbi<ByteBuffer> db : dbs) {
         // Clean out the db first
         try (Txn<ByteBuffer> txn = env.txnWrite();
-             final Cursor<ByteBuffer> cursor = db.openCursor(txn)) {
+            final Cursor<ByteBuffer> cursor = db.openCursor(txn)) {
           while (cursor.next()) {
             cursor.delete();
           }
@@ -108,9 +108,13 @@ private void populateDatabases(final boolean randomOrder) {
           txn.commit();
         }
         final Duration duration = Duration.between(start, Instant.now());
-        System.out.println("DB: " + dbName
-            + " - Loaded in duration: " + duration
-            + ", millis: " + duration.toMillis());
+        System.out.println(
+            "DB: "
+                + dbName
+                + " - Loaded in duration: "
+                + duration
+                + ", millis: "
+                + duration.toMillis());
       }
     }
   }
@@ -147,16 +151,21 @@ public void comparePerf(final boolean randomOrder) {
         int cnt = 0;
         // Exercise the stop key comparator on every entry
         try (Txn<ByteBuffer> txn = env.txnRead();
-             CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
+            CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
           for (final CursorIterable.KeyVal<ByteBuffer> kv : c) {
             cnt++;
           }
         }
         final Duration duration = Duration.between(start, Instant.now());
-        System.out.println("DB: " + dbName
-            + " - Iterated in duration: " + duration
-            + ", millis: " + duration.toMillis()
-            + ", cnt: " + cnt);
+        System.out.println(
+            "DB: "
+                + dbName
+                + " - Iterated in duration: "
+                + duration
+                + ", millis: "
+                + duration.toMillis()
+                + ", cnt: "
+                + cnt);
       }
     }
   }
diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index 96be0816..22cf7361 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -134,8 +134,7 @@ public void before() throws IOException {
     // Use LMDB comparator for start/stop keys
     dbLmdbComparator = env.openDbi(DB_2, MDB_CREATE);
     // Use a java comparator for start/stop keys and as a callback comparaotr
-    dbCallbackComparator = env.openDbi(
-            DB_3, bufferProxy.getUnsignedComparator(), true, MDB_CREATE);
+    dbCallbackComparator = env.openDbi(DB_3, bufferProxy.getUnsignedComparator(), true, MDB_CREATE);
 
     populateList();
 
@@ -422,18 +421,17 @@ public void testSignedVsUnsigned() {
 
     // Compare the same
     assertThat(
-            unsignedComparator.compare(val1, val2),
-            Matchers.is(signedComparator.compare(val1, val2)));
+        unsignedComparator.compare(val1, val2), Matchers.is(signedComparator.compare(val1, val2)));
 
     // Compare differently
     assertThat(
-            unsignedComparator.compare(val110, val150),
-            Matchers.not(signedComparator.compare(val110, val150)));
+        unsignedComparator.compare(val110, val150),
+        Matchers.not(signedComparator.compare(val110, val150)));
 
     // Compare differently
     assertThat(
-            unsignedComparator.compare(val111, val150),
-            Matchers.not(signedComparator.compare(val111, val150)));
+        unsignedComparator.compare(val111, val150),
+        Matchers.not(signedComparator.compare(val111, val150)));
 
     // This will fail if the db is using a signed comparator for the start/stop keys
     for (final Dbi<ByteBuffer> db : dbs) {
@@ -444,11 +442,11 @@ public void testSignedVsUnsigned() {
       KeyRange<ByteBuffer> keyRange = KeyRange.atLeastBackward(startKeyBuf);
 
       try (Txn<ByteBuffer> txn = env.txnRead();
-           CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
+          CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
         for (final CursorIterable.KeyVal<ByteBuffer> kv : c) {
           final int key = kv.key().getInt();
           final int val = kv.val().getInt();
-//          System.out.println("key: " + key + " val: " + val);
+          //          System.out.println("key: " + key + " val: " + val);
           assertThat(key, is(110));
           break;
         }
diff --git a/src/test/java/org/lmdbjava/KeyRangeTest.java b/src/test/java/org/lmdbjava/KeyRangeTest.java
index 0197bf11..c474e982 100644
--- a/src/test/java/org/lmdbjava/KeyRangeTest.java
+++ b/src/test/java/org/lmdbjava/KeyRangeTest.java
@@ -197,8 +197,8 @@ private void verify(final KeyRange<Integer> range, final int... expected) {
     do {
       final Integer finalBuff = buff;
       final RangeComparator rangeComparator =
-          CursorIterable.createJavaRangeComparator(range, Integer::compareTo, () -> finalBuff);
-      op = range.getType().iteratorOp(range.getStart(), range.getStop(), buff, rangeComparator);
+          new CursorIterable.JavaRangeComparator<>(range, Integer::compareTo, () -> finalBuff);
+      op = range.getType().iteratorOp(buff, rangeComparator);
       switch (op) {
         case CALL_NEXT_OP:
           buff = cursor.apply(range.getType().nextOp(), range.getStart());

From 9509f6bea115c7839e14881e4ecb4459211820d4 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Thu, 6 Mar 2025 19:05:48 +0000
Subject: [PATCH 201/322] gh-249 Remove commented code

---
 .../java/org/lmdbjava/CursorIterable.java     | 56 -------------------
 1 file changed, 56 deletions(-)

diff --git a/src/main/java/org/lmdbjava/CursorIterable.java b/src/main/java/org/lmdbjava/CursorIterable.java
index 7c487bae..b0de7d06 100644
--- a/src/main/java/org/lmdbjava/CursorIterable.java
+++ b/src/main/java/org/lmdbjava/CursorIterable.java
@@ -42,7 +42,6 @@
  */
 public final class CursorIterable<T> implements Iterable<CursorIterable.KeyVal<T>>, AutoCloseable {
 
-  //  private final Comparator<T> comparator;
   private final RangeComparator rangeComparator;
   private final Cursor<T> cursor;
   private final KeyVal<T> entry;
@@ -69,61 +68,6 @@ public final class CursorIterable<T> implements Iterable<CursorIterable.KeyVal<T
     }
   }
 
-  //  static <T> RangeComparator createJavaRangeComparator(
-  //      final KeyRange<T> range,
-  //      final Comparator<T> comparator,
-  //      final Supplier<T> currentKeySupplier) {
-  //    final T start = range.getStart();
-  //    final T stop = range.getStop();
-  //    return new RangeComparator() {
-  //      @Override
-  //      public int compareToStartKey() {
-  //        return comparator.compare(currentKeySupplier.get(), start);
-  //      }
-  //
-  //      @Override
-  //      public int compareToStopKey() {
-  //        return comparator.compare(currentKeySupplier.get(), stop);
-  //      }
-  //    };
-  //  }
-
-  //  /**
-  //   * Calls down to mdb_cmp to make use of the comparator that LMDB uses for insertion order.
-  //   *
-  //   * @param txnPointer The pointer to the transaction.
-  //   * @param dbiPointer The pointer to the Dbi so LMDB can use the comparator of the Dbi
-  //   * @param proxy
-  //   */
-  //  private RangeComparator createLmdbDbiComparator(final Pointer txnPointer,
-  //                                                  final Pointer dbiPointer,
-  //                                                  final Pointer cursorKeyPointer,
-  //                                                  final KeyRange<T> range,
-  //                                                  final BufferProxy<T> proxy) {
-  //    Objects.requireNonNull(txnPointer);
-  //    Objects.requireNonNull(dbiPointer);
-  //    Objects.requireNonNull(range);
-  //    Objects.requireNonNull(cursor);
-  //    // Allocate buffers for use with the start/stop keys if required.
-  //    // Saves us copying bytes on each comparison
-  //    final Key<T> startKey = createKey(range.getStart(), proxy);
-  //    final Key<T> stopKey = createKey(range.getStop(), proxy);
-  //
-  //    return new RangeComparator() {
-  //      @Override
-  //      public int compareToStartKey() {
-  //        return LIB.mdb_cmp(txnPointer, dbiPointer, cursor.keyVal().pointerKey(),
-  // startKey.pointer());
-  //      }
-  //
-  //      @Override
-  //      public int compareToStopKey() {
-  //        return LIB.mdb_cmp(txnPointer, dbiPointer, cursor.keyVal().pointerKey(),
-  // stopKey.pointer());
-  //      }
-  //    };
-  //  }
-
   @Override
   public void close() {
     cursor.close();

From 67e2df1002ee86534ad082beb83a1c753e2ab6b5 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 7 Mar 2025 10:31:12 +0000
Subject: [PATCH 202/322] gh-249 Add CursorIterableIntegerKeyTest

---
 .../CursorIterableIntegerKeyTest.java         | 493 ++++++++++++++++++
 .../org/lmdbjava/CursorIterablePerfTest.java  |   2 +-
 src/test/java/org/lmdbjava/TestUtils.java     |  15 +
 3 files changed, 509 insertions(+), 1 deletion(-)
 create mode 100644 src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java

diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
new file mode 100644
index 00000000..431c6e51
--- /dev/null
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
@@ -0,0 +1,493 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
+import static java.util.Arrays.asList;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.hasSize;
+import static org.lmdbjava.DbiFlags.MDB_CREATE;
+import static org.lmdbjava.DbiFlags.MDB_INTEGERKEY;
+import static org.lmdbjava.Env.create;
+import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
+import static org.lmdbjava.KeyRange.all;
+import static org.lmdbjava.KeyRange.allBackward;
+import static org.lmdbjava.KeyRange.atLeast;
+import static org.lmdbjava.KeyRange.atLeastBackward;
+import static org.lmdbjava.KeyRange.atMost;
+import static org.lmdbjava.KeyRange.atMostBackward;
+import static org.lmdbjava.KeyRange.closed;
+import static org.lmdbjava.KeyRange.closedBackward;
+import static org.lmdbjava.KeyRange.closedOpen;
+import static org.lmdbjava.KeyRange.closedOpenBackward;
+import static org.lmdbjava.KeyRange.greaterThan;
+import static org.lmdbjava.KeyRange.greaterThanBackward;
+import static org.lmdbjava.KeyRange.lessThan;
+import static org.lmdbjava.KeyRange.lessThanBackward;
+import static org.lmdbjava.KeyRange.open;
+import static org.lmdbjava.KeyRange.openBackward;
+import static org.lmdbjava.KeyRange.openClosed;
+import static org.lmdbjava.KeyRange.openClosedBackward;
+import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
+import static org.lmdbjava.TestUtils.DB_1;
+import static org.lmdbjava.TestUtils.DB_2;
+import static org.lmdbjava.TestUtils.DB_3;
+import static org.lmdbjava.TestUtils.POSIX_MODE;
+import static org.lmdbjava.TestUtils.bb;
+import static org.lmdbjava.TestUtils.bbNative;
+import static org.lmdbjava.TestUtils.getNativeInt;
+
+import com.google.common.primitives.UnsignedBytes;
+import java.io.File;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.Deque;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.NoSuchElementException;
+import org.hamcrest.Matchers;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.lmdbjava.CursorIterable.KeyVal;
+
+/** Test {@link CursorIterable} using {@link DbiFlags#MDB_INTEGERKEY} to ensure that
+ * comparators work with native order integer keys. */
+public final class CursorIterableIntegerKeyTest {
+
+  @Rule public final TemporaryFolder tmp = new TemporaryFolder();
+  private Dbi<ByteBuffer> dbJavaComparator;
+  private Dbi<ByteBuffer> dbLmdbComparator;
+  private Dbi<ByteBuffer> dbCallbackComparator;
+  private List<Dbi<ByteBuffer>> dbs = new ArrayList<>();
+  private Env<ByteBuffer> env;
+  private Deque<Integer> list;
+
+  @After
+  public void after() {
+    env.close();
+  }
+
+  @Test
+  public void allBackwardTest() {
+    verify(allBackward(), 8, 6, 4, 2);
+  }
+
+  @Test
+  public void allTest() {
+    verify(all(), 2, 4, 6, 8);
+  }
+
+  @Test
+  public void atLeastBackwardTest() {
+    verify(atLeastBackward(bbNative(5)), 4, 2);
+    verify(atLeastBackward(bbNative(6)), 6, 4, 2);
+    verify(atLeastBackward(bbNative(9)), 8, 6, 4, 2);
+  }
+
+  @Test
+  public void atLeastTest() {
+    verify(atLeast(bbNative(5)), 6, 8);
+    verify(atLeast(bbNative(6)), 6, 8);
+  }
+
+  @Test
+  public void atMostBackwardTest() {
+    verify(atMostBackward(bbNative(5)), 8, 6);
+    verify(atMostBackward(bbNative(6)), 8, 6);
+  }
+
+  @Test
+  public void atMostTest() {
+    verify(atMost(bbNative(5)), 2, 4);
+    verify(atMost(bbNative(6)), 2, 4, 6);
+  }
+
+  @Before
+  public void before() throws IOException {
+    final File path = tmp.newFile();
+    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
+    env =
+        create(bufferProxy)
+            .setMapSize(KIBIBYTES.toBytes(256))
+            .setMaxReaders(1)
+            .setMaxDbs(3)
+            .open(path, POSIX_MODE, MDB_NOSUBDIR);
+
+    // Use a java comparator for start/stop keys only
+    dbJavaComparator = env.openDbi(DB_1,
+        bufferProxy.getUnsignedComparator(),
+        MDB_CREATE,
+        MDB_INTEGERKEY);
+    // Use LMDB comparator for start/stop keys
+    dbLmdbComparator = env.openDbi(DB_2, MDB_CREATE, MDB_INTEGERKEY);
+    // Use a java comparator for start/stop keys and as a callback comparaotr
+    dbCallbackComparator = env.openDbi(DB_3,
+        bufferProxy.getUnsignedComparator(),
+        true,
+        MDB_CREATE,
+        MDB_INTEGERKEY);
+
+    populateList();
+
+    populateDatabase(dbJavaComparator);
+    populateDatabase(dbLmdbComparator);
+    populateDatabase(dbCallbackComparator);
+
+    dbs.add(dbJavaComparator);
+    dbs.add(dbLmdbComparator);
+    dbs.add(dbCallbackComparator);
+  }
+
+  private void populateList() {
+    list = new LinkedList<>();
+    list.addAll(asList(2, 3, 4, 5, 6, 7, 8, 9));
+  }
+
+  private void populateDatabase(final Dbi<ByteBuffer> dbi) {
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      final Cursor<ByteBuffer> c = dbi.openCursor(txn);
+      c.put(bbNative(2), bb(3), MDB_NOOVERWRITE);
+      c.put(bbNative(4), bb(5));
+      c.put(bbNative(6), bb(7));
+      c.put(bbNative(8), bb(9));
+      txn.commit();
+    }
+  }
+
+  @Test
+  public void closedBackwardTest() {
+    verify(closedBackward(bbNative(7), bbNative(3)), 6, 4);
+    verify(closedBackward(bbNative(6), bbNative(2)), 6, 4, 2);
+    verify(closedBackward(bbNative(9), bbNative(3)), 8, 6, 4);
+  }
+
+  @Test
+  public void closedOpenBackwardTest() {
+    verify(closedOpenBackward(bbNative(8), bbNative(3)), 8, 6, 4);
+    verify(closedOpenBackward(bbNative(7), bbNative(2)), 6, 4);
+    verify(closedOpenBackward(bbNative(9), bbNative(3)), 8, 6, 4);
+  }
+
+  @Test
+  public void closedOpenTest() {
+    verify(closedOpen(bbNative(3), bbNative(8)), 4, 6);
+    verify(closedOpen(bbNative(2), bbNative(6)), 2, 4);
+  }
+
+  @Test
+  public void closedTest() {
+    verify(closed(bbNative(3), bbNative(7)), 4, 6);
+    verify(closed(bbNative(2), bbNative(6)), 2, 4, 6);
+    verify(closed(bbNative(1), bbNative(7)), 2, 4, 6);
+  }
+
+  @Test
+  public void greaterThanBackwardTest() {
+    verify(greaterThanBackward(bbNative(6)), 4, 2);
+    verify(greaterThanBackward(bbNative(7)), 6, 4, 2);
+    verify(greaterThanBackward(bbNative(9)), 8, 6, 4, 2);
+  }
+
+  @Test
+  public void greaterThanTest() {
+    verify(greaterThan(bbNative(4)), 6, 8);
+    verify(greaterThan(bbNative(3)), 4, 6, 8);
+  }
+
+  @Test(expected = IllegalStateException.class)
+  public void iterableOnlyReturnedOnce() {
+    for (final Dbi<ByteBuffer> db : dbs) {
+      try (Txn<ByteBuffer> txn = env.txnRead();
+          CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+        c.iterator(); // ok
+        c.iterator(); // fails
+      }
+    }
+  }
+
+  @Test
+  public void iterate() {
+    for (final Dbi<ByteBuffer> db : dbs) {
+      populateList();
+      try (Txn<ByteBuffer> txn = env.txnRead();
+          CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+
+        int cnt = 0;
+        for (final KeyVal<ByteBuffer> kv : c) {
+          assertThat(getNativeInt(kv.key()), is(list.pollFirst()));
+          assertThat(kv.val().getInt(), is(list.pollFirst()));
+        }
+      }
+    }
+  }
+
+  @Test(expected = IllegalStateException.class)
+  public void iteratorOnlyReturnedOnce() {
+    for (final Dbi<ByteBuffer> db : dbs) {
+      try (Txn<ByteBuffer> txn = env.txnRead();
+          CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+        c.iterator(); // ok
+        c.iterator(); // fails
+      }
+    }
+  }
+
+  @Test
+  public void lessThanBackwardTest() {
+    verify(lessThanBackward(bbNative(5)), 8, 6);
+    verify(lessThanBackward(bbNative(2)), 8, 6, 4);
+  }
+
+  @Test
+  public void lessThanTest() {
+    verify(lessThan(bbNative(5)), 2, 4);
+    verify(lessThan(bbNative(8)), 2, 4, 6);
+  }
+
+  @Test(expected = NoSuchElementException.class)
+  public void nextThrowsNoSuchElementExceptionIfNoMoreElements() {
+    for (final Dbi<ByteBuffer> db : dbs) {
+      populateList();
+      try (Txn<ByteBuffer> txn = env.txnRead();
+          CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+        final Iterator<KeyVal<ByteBuffer>> i = c.iterator();
+        while (i.hasNext()) {
+          final KeyVal<ByteBuffer> kv = i.next();
+          assertThat(TestUtils.getNativeInt(kv.key()), is(list.pollFirst()));
+          assertThat(kv.val().getInt(), is(list.pollFirst()));
+        }
+        assertThat(i.hasNext(), is(false));
+        i.next();
+      }
+    }
+  }
+
+  @Test
+  public void openBackwardTest() {
+    verify(openBackward(bbNative(7), bbNative(2)), 6, 4);
+    verify(openBackward(bbNative(8), bbNative(1)), 6, 4, 2);
+    verify(openBackward(bbNative(9), bbNative(4)), 8, 6);
+  }
+
+  @Test
+  public void openClosedBackwardTest() {
+    verify(openClosedBackward(bbNative(7), bbNative(2)), 6, 4, 2);
+    verify(openClosedBackward(bbNative(8), bbNative(4)), 6, 4);
+    verify(openClosedBackward(bbNative(9), bbNative(4)), 8, 6, 4);
+  }
+
+  @Test
+  public void openClosedBackwardTestWithGuava() {
+    final Comparator<byte[]> guava = UnsignedBytes.lexicographicalComparator();
+    final Comparator<ByteBuffer> comparator =
+        (bb1, bb2) -> {
+          final byte[] array1 = new byte[bb1.remaining()];
+          final byte[] array2 = new byte[bb2.remaining()];
+          bb1.mark();
+          bb2.mark();
+          bb1.get(array1);
+          bb2.get(array2);
+          bb1.reset();
+          bb2.reset();
+          return guava.compare(array1, array2);
+        };
+    final Dbi<ByteBuffer> guavaDbi = env.openDbi(DB_1, comparator, MDB_CREATE);
+    populateDatabase(guavaDbi);
+    verify(openClosedBackward(bbNative(7), bbNative(2)), guavaDbi, 6, 4, 2);
+    verify(openClosedBackward(bbNative(8), bbNative(4)), guavaDbi, 6, 4);
+  }
+
+  @Test
+  public void openClosedTest() {
+    verify(openClosed(bbNative(3), bbNative(8)), 4, 6, 8);
+    verify(openClosed(bbNative(2), bbNative(6)), 4, 6);
+  }
+
+  @Test
+  public void openTest() {
+    verify(open(bbNative(3), bbNative(7)), 4, 6);
+    verify(open(bbNative(2), bbNative(8)), 4, 6);
+  }
+
+  @Test
+  public void removeOddElements() {
+    for (final Dbi<ByteBuffer> db : dbs) {
+      verify(db, all(), 2, 4, 6, 8);
+      int idx = -1;
+      try (Txn<ByteBuffer> txn = env.txnWrite()) {
+        try (CursorIterable<ByteBuffer> ci = db.iterate(txn)) {
+          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+          while (c.hasNext()) {
+            c.next();
+            idx++;
+            if (idx % 2 == 0) {
+              c.remove();
+            }
+          }
+        }
+        txn.commit();
+      }
+      verify(db, all(), 4, 8);
+    }
+  }
+
+  @Test(expected = Env.AlreadyClosedException.class)
+  public void nextWithClosedEnvTest() {
+    for (final Dbi<ByteBuffer> db : dbs) {
+      try (Txn<ByteBuffer> txn = env.txnRead()) {
+        try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+          env.close();
+          c.next();
+        }
+      }
+    }
+  }
+
+  @Test(expected = Env.AlreadyClosedException.class)
+  public void removeWithClosedEnvTest() {
+    for (final Dbi<ByteBuffer> db : dbs) {
+      try (Txn<ByteBuffer> txn = env.txnWrite()) {
+        try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+          final KeyVal<ByteBuffer> keyVal = c.next();
+          assertThat(keyVal, Matchers.notNullValue());
+
+          env.close();
+          c.remove();
+        }
+      }
+    }
+  }
+
+  @Test(expected = Env.AlreadyClosedException.class)
+  public void hasNextWithClosedEnvTest() {
+    for (final Dbi<ByteBuffer> db : dbs) {
+      try (Txn<ByteBuffer> txn = env.txnRead()) {
+        try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+          env.close();
+          c.hasNext();
+        }
+      }
+    }
+  }
+
+  @Test(expected = Env.AlreadyClosedException.class)
+  public void forEachRemainingWithClosedEnvTest() {
+    for (final Dbi<ByteBuffer> db : dbs) {
+      try (Txn<ByteBuffer> txn = env.txnRead()) {
+        try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+          env.close();
+          c.forEachRemaining(keyVal -> {});
+        }
+      }
+    }
+  }
+
+  @Test
+  public void testSignedVsUnsigned() {
+    final ByteBuffer val1 = bbNative(1);
+    final ByteBuffer val2 = bbNative(2);
+    final ByteBuffer val110 = bbNative(110);
+    final ByteBuffer val111 = bbNative(111);
+    final ByteBuffer val150 = bbNative(150);
+
+    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
+    final Comparator<ByteBuffer> unsignedComparator = bufferProxy.getUnsignedComparator();
+    final Comparator<ByteBuffer> signedComparator = bufferProxy.getSignedComparator();
+
+    // Compare the same
+    assertThat(
+        unsignedComparator.compare(val1, val2), Matchers.is(signedComparator.compare(val1, val2)));
+
+    // Compare differently
+    assertThat(
+        unsignedComparator.compare(val110, val150),
+        Matchers.not(signedComparator.compare(val110, val150)));
+
+    // Compare differently
+    assertThat(
+        unsignedComparator.compare(val111, val150),
+        Matchers.not(signedComparator.compare(val111, val150)));
+
+    // This will fail if the db is using a signed comparator for the start/stop keys
+    for (final Dbi<ByteBuffer> db : dbs) {
+      db.put(val110, val110);
+      db.put(val150, val150);
+
+      final ByteBuffer startKeyBuf = val111;
+      KeyRange<ByteBuffer> keyRange = KeyRange.atLeastBackward(startKeyBuf);
+
+      try (Txn<ByteBuffer> txn = env.txnRead();
+          CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
+        for (final KeyVal<ByteBuffer> kv : c) {
+          final int key = getNativeInt(kv.key());
+          final int val = kv.val().getInt();
+          //          System.out.println("key: " + key + " val: " + val);
+          assertThat(key, is(110));
+          break;
+        }
+      }
+    }
+  }
+
+  private void verify(final KeyRange<ByteBuffer> range, final int... expected) {
+    // Verify using all comparator types
+    for (final Dbi<ByteBuffer> db : dbs) {
+      verify(range, db, expected);
+    }
+  }
+
+  private void verify(
+      final Dbi<ByteBuffer> dbi, final KeyRange<ByteBuffer> range, final int... expected) {
+    verify(range, dbi, expected);
+  }
+
+  private void verify(
+      final KeyRange<ByteBuffer> range, final Dbi<ByteBuffer> dbi, final int... expected) {
+
+    final List<Integer> results = new ArrayList<>();
+
+    try (Txn<ByteBuffer> txn = env.txnRead();
+        CursorIterable<ByteBuffer> c = dbi.iterate(txn, range)) {
+      for (final KeyVal<ByteBuffer> kv : c) {
+        final int key = kv.key().order(ByteOrder.nativeOrder()).getInt();
+        final int val = kv.val().getInt();
+        results.add(key);
+        assertThat(val, is(key + 1));
+      }
+    }
+
+    assertThat(results, hasSize(expected.length));
+    for (int idx = 0; idx < results.size(); idx++) {
+      assertThat(results.get(idx), is(expected[idx]));
+    }
+  }
+}
diff --git a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
index 19e5a9b9..257ee705 100644
--- a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
@@ -73,7 +73,7 @@ private void populateList() {
   }
 
   private void populateDatabases(final boolean randomOrder) {
-    System.out.println("Clear then populate databases");
+    System.out.println("Clear then populate databases (randomOrder=" + randomOrder + ")");
 
     final List<Integer> data;
     if (randomOrder) {
diff --git a/src/test/java/org/lmdbjava/TestUtils.java b/src/test/java/org/lmdbjava/TestUtils.java
index f3d3974b..ff84946f 100644
--- a/src/test/java/org/lmdbjava/TestUtils.java
+++ b/src/test/java/org/lmdbjava/TestUtils.java
@@ -23,6 +23,7 @@
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
 import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
 import org.agrona.MutableDirectBuffer;
 import org.agrona.concurrent.UnsafeBuffer;
 
@@ -49,6 +50,20 @@ static ByteBuffer bb(final int value) {
     return bb;
   }
 
+  static ByteBuffer bbNative(final int value) {
+    final ByteBuffer bb = allocateDirect(Long.BYTES)
+        .order(ByteOrder.nativeOrder());
+    bb.putInt(value).flip();
+    return bb;
+  }
+
+  static int getNativeInt(final ByteBuffer bb) {
+    final int val = bb.order(ByteOrder.nativeOrder())
+        .getInt();
+    bb.rewind();
+    return val;
+  }
+
   static void invokePrivateConstructor(final Class<?> clazz) {
     try {
       final Constructor<?> c = clazz.getDeclaredConstructor();

From 620a89fc4bdc292b3f5cace5631a5af6afd6f11e Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Thu, 5 Jun 2025 10:03:12 +0100
Subject: [PATCH 203/322] gh-249 Remove MaskedFlag.isPropagatedToLmdb, add
 DbiBuilder WIP

---
 src/main/java/org/lmdbjava/Cursor.java     |   8 +-
 src/main/java/org/lmdbjava/Dbi.java        |   6 +-
 src/main/java/org/lmdbjava/DbiBuilder.java | 335 +++++++++++++++++++++
 src/main/java/org/lmdbjava/DbiFlags.java   |   3 +
 src/main/java/org/lmdbjava/Env.java        |  27 +-
 src/main/java/org/lmdbjava/MaskedFlag.java |  72 +----
 src/main/java/org/lmdbjava/Txn.java        |   2 +-
 7 files changed, 382 insertions(+), 71 deletions(-)
 create mode 100644 src/main/java/org/lmdbjava/DbiBuilder.java

diff --git a/src/main/java/org/lmdbjava/Cursor.java b/src/main/java/org/lmdbjava/Cursor.java
index 9070cff6..69f84c88 100644
--- a/src/main/java/org/lmdbjava/Cursor.java
+++ b/src/main/java/org/lmdbjava/Cursor.java
@@ -112,7 +112,7 @@ public void delete(final PutFlags... f) {
       txn.checkReady();
       txn.checkWritesAllowed();
     }
-    final int flags = mask(true, f);
+    final int flags = mask(f);
     checkRc(LIB.mdb_cursor_del(ptrCursor, flags));
   }
 
@@ -249,7 +249,7 @@ public boolean put(final T key, final T val, final PutFlags... op) {
     }
     kv.keyIn(key);
     kv.valIn(val);
-    final int mask = mask(true, op);
+    final int mask = mask(op);
     final int rc = LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(), mask);
     if (rc == MDB_KEYEXIST) {
       if (isSet(mask, MDB_NOOVERWRITE)) {
@@ -287,7 +287,7 @@ public void putMultiple(final T key, final T val, final int elements, final PutF
       txn.checkReady();
       txn.checkWritesAllowed();
     }
-    final int mask = mask(true, op);
+    final int mask = mask(op);
     if (SHOULD_CHECK && !isSet(mask, MDB_MULTIPLE)) {
       throw new IllegalArgumentException("Must set " + MDB_MULTIPLE + " flag");
     }
@@ -346,7 +346,7 @@ public T reserve(final T key, final int size, final PutFlags... op) {
     }
     kv.keyIn(key);
     kv.valIn(size);
-    final int flags = mask(true, op) | MDB_RESERVE.getMask();
+    final int flags = mask(op) | MDB_RESERVE.getMask();
     checkRc(LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(), flags));
     kv.valOut();
     ReferenceUtil.reachabilityFence0(key);
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index c622462b..8560e34c 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -72,7 +72,7 @@ public final class Dbi<T> {
     this.name = name == null ? null : Arrays.copyOf(name, name.length);
     this.proxy = proxy;
     this.comparator = comparator;
-    final int flagsMask = mask(true, flags);
+    final int flagsMask = mask(flags);
     final Pointer dbiPtr = allocateDirect(RUNTIME, ADDRESS);
     checkRc(LIB.mdb_dbi_open(txn.pointer(), name, flagsMask, dbiPtr));
     ptr = dbiPtr.getPointer(0);
@@ -371,7 +371,7 @@ public boolean put(final Txn<T> txn, final T key, final T val, final PutFlags...
     }
     txn.kv().keyIn(key);
     txn.kv().valIn(val);
-    final int mask = mask(true, flags);
+    final int mask = mask(flags);
     final int rc =
         LIB.mdb_put(txn.pointer(), ptr, txn.kv().pointerKey(), txn.kv().pointerVal(), mask);
     if (rc == MDB_KEYEXIST) {
@@ -413,7 +413,7 @@ public T reserve(final Txn<T> txn, final T key, final int size, final PutFlags..
     }
     txn.kv().keyIn(key);
     txn.kv().valIn(size);
-    final int flags = mask(true, op) | MDB_RESERVE.getMask();
+    final int flags = mask(op) | MDB_RESERVE.getMask();
     checkRc(LIB.mdb_put(txn.pointer(), ptr, txn.kv().pointerKey(), txn.kv().pointerVal(), flags));
     txn.kv().valOut(); // marked as in,out in LMDB C docs
     ReferenceUtil.reachabilityFence0(key);
diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
new file mode 100644
index 00000000..a33ca746
--- /dev/null
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -0,0 +1,335 @@
+package org.lmdbjava;
+
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.EnumSet;
+import java.util.Objects;
+import java.util.Set;
+
+/**
+ * Staged builder for building a {@link Dbi}
+ *
+ * @param <T> buffer type
+ */
+public class DbiBuilder<T> {
+
+  private final Env<T> env;
+  private final BufferProxy<T> proxy;
+  private final boolean readOnly;
+  private byte[] name;
+
+  DbiBuilder(final Env<T> env,
+             final BufferProxy<T> proxy,
+             final boolean readOnly) {
+    this.env = Objects.requireNonNull(env);
+    this.proxy = Objects.requireNonNull(proxy);
+    this.readOnly = readOnly;
+  }
+
+  /**
+   * <p>
+   * Create the {@link Dbi} with the passed name.
+   * </p>
+   * <p>
+   * The name will be converted into bytes using {@link StandardCharsets#UTF_8}.
+   * </p>
+   */
+  public RequireComparator<T> withDbName(final String name) {
+    // Null name is allowed so no null check
+    final byte[] nameBytes = name == null
+        ? null
+        : name.getBytes(StandardCharsets.UTF_8);
+    return withDbName(nameBytes);
+  }
+
+  /**
+   * Create the {@link Dbi} with the passed name in byte[] form.
+   */
+  public RequireComparator<T> withDbName(final byte[] name) {
+    // Null name is allowed so no null check
+    this.name = name;
+    return new RequireComparator<>(this);
+  }
+
+  /**
+   * <p>
+   * Create the {@link Dbi} without a name.
+   * </p>
+   * <p>
+   * Equivalent to passing null to
+   * {@link DbiBuilder#withDbName(String)} or {@link DbiBuilder#withDbName(byte[])}.
+   * </p>
+   */
+  public RequireComparator<T> withoutDbName() {
+    return withDbName((byte[]) null);
+  }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  /**
+   * Intermediate builder stage for constructing a {@link Dbi}.
+   *
+   * @param <T> buffer type
+   */
+  public static class RequireComparator<T> {
+
+    private final DbiBuilder<T> dbiBuilder;
+
+    private Comparator<T> comparator;
+    private boolean useNativeCallback;
+
+    private RequireComparator(final DbiBuilder<T> dbiBuilder) {
+      this.dbiBuilder = dbiBuilder;
+    }
+
+    /**
+     * <p>
+     * {@link CursorIterable} will call down to LMDB's {@code mdb_cmp} method when
+     * comparing entries to start/stop keys. This ensures LmdbJava is comparing start/stop
+     * keys using the same comparator that is used for insert order into the db.
+     * </p>
+     * <p>
+     * This option may be slightly less performant than when using
+     * {@link RequireComparator#withDefaultJavaComparator()} as it need to call down
+     * to LMDB to perform the comparisons, however it guarantees that {@link CursorIterable}
+     * key comparison matches LMDB key comparison.
+     * </p>
+     * <p>
+     * If you do not intend to use {@link CursorIterable} then it doesn't matter whether
+     * you choose {@link RequireComparator#withNativeComparator()},
+     * {@link RequireComparator#withDefaultJavaComparator()} or
+     * {@link RequireComparator#withIteratorComparator(Comparator)} as these comparators will
+     * never be used.
+     * </p>
+     *
+     * @return this builder instance.
+     */
+    public FinalStage<T> withNativeComparator() {
+      this.comparator = null;
+      this.useNativeCallback = false;
+      return new FinalStage<>(this);
+    }
+
+    /**
+     * <p>
+     * {@link CursorIterable} will make use of the default Java-side comparators when
+     * comparing entries to start/stop keys.
+     * </p>
+     * <p>
+     * This option may be slightly more performant than when using
+     * {@link RequireComparator#withNativeComparator()} but it relies on the default comparator
+     * in LmdbJava behaving identically to the comparator in LMDB.
+     * </p>
+     * <p>
+     * If you do not intend to use {@link CursorIterable} then it doesn't matter whether
+     * you choose {@link RequireComparator#withNativeComparator()},
+     * {@link RequireComparator#withDefaultJavaComparator()} or
+     * {@link RequireComparator#withIteratorComparator(Comparator)} as these comparators will
+     * never be used.
+     * </p>
+     *
+     * @return this builder instance.
+     */
+    public FinalStage<T> withDefaultJavaComparator() {
+      this.comparator = dbiBuilder.proxy.getUnsignedComparator();
+      this.useNativeCallback = false;
+      return new FinalStage<>(this);
+    }
+
+    /**
+     * Provide a java-side {@link Comparator} that LMDB will call back to in order to
+     * manage database insertion/iteration order. It will also be used for {@link CursorIterable}
+     * start/stop key comparisons.
+     * <p>
+     * Due to calling back to java, this will be less performant than using LMDB's
+     * default comparator, but allows for total control over the order in which entries
+     * are stored in the database.
+     * </p>
+     *
+     * @param comparator for all key comparison operations.
+     * @return this builder instance.
+     */
+    public FinalStage<T> withCallbackComparator(final Comparator<T> comparator) {
+      this.comparator = Objects.requireNonNull(comparator);
+      this.useNativeCallback = true;
+      return new FinalStage<>(this);
+    }
+
+    /**
+     * <p>
+     * {@link CursorIterable} will make use of the passed comparator for
+     * comparing entries to start/stop keys. It has NO bearing on the insert/iteration
+     * order of the db.
+     * </p>
+     * <p>
+     * <strong>WARNING:</strong> Only call this method if you fully understand the implications
+     * of using a comparator for the {@link CursorIterable} start/stop keys that behaves
+     * differently to the comparator in LMDB that controls the insert/iteration order.
+     * </p>
+     * <p>
+     * This option may be slightly less performant than when using
+     * {@link RequireComparator#withDefaultJavaComparator()} as it need to call down
+     * to LMDB to perform the comparisons, however it guarantees that {@link CursorIterable}
+     * key comparison matches LMDB key comparison.
+     * </p>
+     * <p>
+     * If you do not intend to use {@link CursorIterable} then it doesn't matter whether
+     * you choose {@link RequireComparator#withNativeComparator()},
+     * {@link RequireComparator#withDefaultJavaComparator()} or
+     * {@link RequireComparator#withIteratorComparator(Comparator)} as these comparators will
+     * never be used.
+     * </p>
+     *
+     * @param comparator The comparator to use with {@link CursorIterable}.
+     * @return this builder instance.
+     */
+    public FinalStage<T> withIteratorComparator(final Comparator<T> comparator) {
+      this.comparator = Objects.requireNonNull(comparator);
+      this.useNativeCallback = false;
+      return new FinalStage<>(this);
+    }
+  }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  /**
+   * Final stage builder for constructing a {@link Dbi}.
+   *
+   * @param <T> buffer type
+   */
+  public static class FinalStage<T> {
+
+    private final RequireComparator<T> requireComparator;
+    private Set<DbiFlags> dbiFlags = null;
+    private Txn<T> txn = null;
+
+    private FinalStage(RequireComparator<T> requireComparator) {
+      this.requireComparator = requireComparator;
+    }
+
+    private void initDbiFlags() {
+      if (dbiFlags == null) {
+        dbiFlags = EnumSet.noneOf(DbiFlags.class);
+      }
+    }
+
+    /**
+     * <p>
+     * Apply all the dbi flags supplied in dbiFlags.
+     * </p>
+     * <p>
+     * Replaces any flags applies in previous calls to
+     * {@link FinalStage#withDbiFlags(Collection)}, {@link FinalStage#withDbiFlags(DbiFlags...)}
+     * or {@link FinalStage#addDbiFlag(DbiFlags)}.
+     * </p>
+     *
+     * @param dbiFlags to open the database with.
+     */
+    public FinalStage<T> withDbiFlags(final Collection<DbiFlags> dbiFlags) {
+      initDbiFlags();
+      if (dbiFlags != null) {
+        this.dbiFlags.addAll(dbiFlags);
+      }
+      return this;
+    }
+
+    /**
+     * <p>
+     * Apply all the dbi flags supplied in dbiFlags.
+     * </p>
+     * <p>
+     * Replaces any flags applies in previous calls to
+     * {@link FinalStage#withDbiFlags(Collection)}, {@link FinalStage#withDbiFlags(DbiFlags...)}
+     * or {@link FinalStage#addDbiFlag(DbiFlags)}.
+     * </p>
+     *
+     * @param dbiFlags to open the database with.
+     */
+    public FinalStage<T> withDbiFlags(final DbiFlags... dbiFlags) {
+      initDbiFlags();
+      if (dbiFlags != null) {
+        Arrays.stream(dbiFlags)
+            .filter(Objects::nonNull)
+            .forEach(this.dbiFlags::add);
+      }
+      return this;
+    }
+
+    /**
+     * Adds dbiFlag to those flags already added to this builder.
+     *
+     * @param dbiFlag to open the database with.
+     * @return this builder instance.
+     */
+    public FinalStage<T> addDbiFlag(final DbiFlags dbiFlag) {
+      initDbiFlags();
+      if (dbiFlags != null) {
+        this.dbiFlags.add(dbiFlag);
+      }
+      return this;
+    }
+
+    /**
+     * Use the supplied transaction to open the {@link Dbi}.
+     * <p>
+     * The caller must commit the transaction after calling {@link FinalStage#open()}
+     * in order to retain the <code>Dbi</code> in the <code>Env</code>.
+     * </p>
+     *
+     * @param txn transaction to use (required; not closed)
+     * @return this builder instance.
+     */
+    public FinalStage<T> withTxn(final Txn<T> txn) {
+      this.txn = Objects.requireNonNull(txn);
+      return this;
+    }
+
+    /**
+     * Construct and open the {@link Dbi}.
+     * <p>
+     * If a {@link Txn} was supplied to the builder, it should be committed upon return from
+     * this method.
+     * </p>
+     *
+     * @return A newly constructed and opened {@link Dbi}.
+     */
+    public Dbi<T> open() {
+      final DbiBuilder<T> dbiBuilder = requireComparator.dbiBuilder;
+      if (txn == null) {
+        try (final Txn<T> txn = getTxn(dbiBuilder)) {
+          return open(txn, dbiBuilder);
+        }
+      } else {
+        return open(txn, dbiBuilder);
+      }
+    }
+
+    private Txn<T> getTxn(final DbiBuilder<T> dbiBuilder) {
+      return dbiBuilder.readOnly
+          ? dbiBuilder.env.txnRead()
+          : dbiBuilder.env.txnWrite();
+    }
+
+    private Dbi<T> open(final Txn<T> txn,
+                        final DbiBuilder<T> dbiBuilder) {
+      final DbiFlags[] dbiFlagsArr = dbiFlags != null && !dbiFlags.isEmpty()
+          ? this.dbiFlags.toArray(new DbiFlags[0])
+          : null;
+
+      return new Dbi<>(
+          dbiBuilder.env,
+          txn,
+          dbiBuilder.name,
+          requireComparator.comparator,
+          requireComparator.useNativeCallback,
+          dbiBuilder.proxy,
+          dbiFlagsArr);
+    }
+  }
+}
diff --git a/src/main/java/org/lmdbjava/DbiFlags.java b/src/main/java/org/lmdbjava/DbiFlags.java
index 2f5eadf6..af6eaeaa 100644
--- a/src/main/java/org/lmdbjava/DbiFlags.java
+++ b/src/main/java/org/lmdbjava/DbiFlags.java
@@ -31,6 +31,9 @@ public enum DbiFlags implements MaskedFlag {
    * <p>Duplicate keys may be used in the database. Or, from another perspective, keys may have
    * multiple data items, stored in sorted order. By default keys must be unique and may have only a
    * single data item.
+   * <p>
+   *
+   * </p>
    */
   MDB_DUPSORT(0x04),
   /**
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 2e4822b7..d7c7b269 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -145,7 +145,7 @@ public void close() {
   public void copy(final File path, final CopyFlags... flags) {
     requireNonNull(path);
     validatePath(path);
-    final int flagsMask = mask(true, flags);
+    final int flagsMask = mask(flags);
     checkRc(LIB.mdb_env_copy2(ptr, path.getAbsolutePath(), flagsMask));
   }
 
@@ -241,6 +241,15 @@ public boolean isReadOnly() {
     return readOnly;
   }
 
+  /**
+   * Open (and optionally creates, if {@link DbiFlags#MDB_CREATE} is set)
+   * a {@link Dbi} using a builder.
+   * @return A new builder instance for creating/opening a {@link Dbi}.
+   */
+  public DbiBuilder<T> buildDbi() {
+    return new DbiBuilder<>(this, proxy, readOnly);
+  }
+
   /**
    * Convenience method that opens a {@link Dbi} with a UTF-8 database name and default {@link
    * Comparator} that is not invoked from native code.
@@ -248,7 +257,9 @@ public boolean isReadOnly() {
    * @param name name of the database (or null if no name is required)
    * @param flags to open the database with
    * @return a database that is ready to use
+   * @deprecated Instead use {@link Env#buildDbi()}
    */
+  @Deprecated()
   public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
     final byte[] nameBytes = name == null ? null : name.getBytes(UTF_8);
     return openDbi(nameBytes, null, false, flags);
@@ -268,7 +279,9 @@ public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
    *     comparator will be used.
    * @param flags to open the database with
    * @return a database that is ready to use
+   * @deprecated Instead use {@link Env#buildDbi()}
    */
+  @Deprecated()
   public Dbi<T> openDbi(
       final String name, final Comparator<T> comparator, final DbiFlags... flags) {
     final byte[] nameBytes = name == null ? null : name.getBytes(UTF_8);
@@ -288,7 +301,9 @@ public Dbi<T> openDbi(
    * @param nativeCb whether LMDB native code calls back to the Java comparator
    * @param flags to open the database with
    * @return a database that is ready to use
+   * @deprecated Instead use {@link Env#buildDbi()}
    */
+  @Deprecated()
   public Dbi<T> openDbi(
       final String name,
       final Comparator<T> comparator,
@@ -305,7 +320,9 @@ public Dbi<T> openDbi(
    * @param name name of the database (or null if no name is required)
    * @param flags to open the database with
    * @return a database that is ready to use
+   * @deprecated Instead use {@link Env#buildDbi()}
    */
+  @Deprecated()
   public Dbi<T> openDbi(final byte[] name, final DbiFlags... flags) {
     return openDbi(name, null, false, flags);
   }
@@ -318,7 +335,9 @@ public Dbi<T> openDbi(final byte[] name, final DbiFlags... flags) {
    * @param comparator custom comparator callback (or null to use LMDB default)
    * @param flags to open the database with
    * @return a database that is ready to use
+   * @deprecated Instead use {@link Env#buildDbi()}
    */
+  @Deprecated()
   public Dbi<T> openDbi(
       final byte[] name, final Comparator<T> comparator, final DbiFlags... flags) {
     return openDbi(name, comparator, false, flags);
@@ -336,7 +355,9 @@ public Dbi<T> openDbi(
    * @param nativeCb whether native code calls back to the Java comparator
    * @param flags to open the database with
    * @return a database that is ready to use
+   * @deprecated Instead use {@link Env#buildDbi()}
    */
+  @Deprecated()
   public Dbi<T> openDbi(
       final byte[] name,
       final Comparator<T> comparator,
@@ -375,7 +396,9 @@ public Dbi<T> openDbi(
    * @param nativeCb whether native code should call back to the comparator
    * @param flags to open the database with
    * @return a database that is ready to use
+   * @deprecated Instead use {@link Env#buildDbi()}
    */
+  @Deprecated()
   public Dbi<T> openDbi(
       final Txn<T> txn,
       final byte[] name,
@@ -557,7 +580,7 @@ public Env<T> open(final File path, final int mode, final EnvFlags... flags) {
         checkRc(LIB.mdb_env_set_mapsize(ptr, mapSize));
         checkRc(LIB.mdb_env_set_maxdbs(ptr, maxDbs));
         checkRc(LIB.mdb_env_set_maxreaders(ptr, maxReaders));
-        final int flagsMask = mask(true, flags);
+        final int flagsMask = mask(flags);
         final boolean readOnly = isSet(flagsMask, MDB_RDONLY_ENV);
         final boolean noSubDir = isSet(flagsMask, MDB_NOSUBDIR);
         checkRc(LIB.mdb_env_open(ptr, path.getAbsolutePath(), flagsMask, mode));
diff --git a/src/main/java/org/lmdbjava/MaskedFlag.java b/src/main/java/org/lmdbjava/MaskedFlag.java
index 00556ecb..4dc47b20 100644
--- a/src/main/java/org/lmdbjava/MaskedFlag.java
+++ b/src/main/java/org/lmdbjava/MaskedFlag.java
@@ -17,11 +17,6 @@
 
 import static java.util.Objects.requireNonNull;
 
-import java.util.Arrays;
-import java.util.Objects;
-import java.util.function.Predicate;
-import java.util.stream.Stream;
-
 /** Indicates an enum that can provide integers for each of its values. */
 public interface MaskedFlag {
 
@@ -32,15 +27,6 @@ public interface MaskedFlag {
    */
   int getMask();
 
-  /**
-   * Indicates if the flag must be propagated to the underlying C code of LMDB or not.
-   *
-   * @return the boolean value indicating the propagation
-   */
-  default boolean isPropagatedToLmdb() {
-    return true;
-  }
-
   /**
    * Fetch the integer mask for all presented flags.
    *
@@ -50,54 +36,18 @@ default boolean isPropagatedToLmdb() {
    */
   @SafeVarargs
   static <M extends MaskedFlag> int mask(final M... flags) {
-    return mask(false, flags);
-  }
-
-  /**
-   * Fetch the integer mask for all presented flags.
-   *
-   * @param <M> flag type
-   * @param flags to mask (null or empty returns zero)
-   * @return the integer mask for use in C
-   */
-  static <M extends MaskedFlag> int mask(final Stream<M> flags) {
-    return mask(false, flags);
-  }
-
-  /**
-   * Fetch the integer mask for the presented flags.
-   *
-   * @param <M> flag type
-   * @param onlyPropagatedToLmdb if to include only the flags which are also propagate to the C code
-   *     or all of them
-   * @param flags to mask (null or empty returns zero)
-   * @return the integer mask for use in C
-   */
-  @SafeVarargs
-  static <M extends MaskedFlag> int mask(final boolean onlyPropagatedToLmdb, final M... flags) {
-    return flags == null ? 0 : mask(onlyPropagatedToLmdb, Arrays.stream(flags));
-  }
-
-  /**
-   * Fetch the integer mask for all presented flags.
-   *
-   * @param <M> flag type
-   * @param onlyPropagatedToLmdb if to include only the flags which are also propagate to the C code
-   *     or all of them
-   * @param flags to mask
-   * @return the integer mask for use in C
-   */
-  static <M extends MaskedFlag> int mask(
-      final boolean onlyPropagatedToLmdb, final Stream<M> flags) {
-    final Predicate<M> filter = onlyPropagatedToLmdb ? MaskedFlag::isPropagatedToLmdb : f -> true;
+    if (flags == null || flags.length == 0) {
+      return 0;
+    }
 
-    return flags == null
-        ? 0
-        : flags
-            .filter(Objects::nonNull)
-            .filter(filter)
-            .map(M::getMask)
-            .reduce(0, (f1, f2) -> f1 | f2);
+    int result = 0;
+    for (MaskedFlag flag : flags) {
+      if (flag == null) {
+        continue;
+      }
+      result |= flag.getMask();
+    }
+    return result;
   }
 
   /**
diff --git a/src/main/java/org/lmdbjava/Txn.java b/src/main/java/org/lmdbjava/Txn.java
index 05e8ce06..1d5d4860 100644
--- a/src/main/java/org/lmdbjava/Txn.java
+++ b/src/main/java/org/lmdbjava/Txn.java
@@ -49,7 +49,7 @@ public final class Txn<T> implements AutoCloseable {
   Txn(final Env<T> env, final Txn<T> parent, final BufferProxy<T> proxy, final TxnFlags... flags) {
     this.proxy = proxy;
     this.keyVal = proxy.keyVal();
-    final int flagsMask = mask(true, flags);
+    final int flagsMask = mask(flags);
     this.readOnly = isSet(flagsMask, MDB_RDONLY_TXN);
     if (env.isReadOnly() && !this.readOnly) {
       throw new EnvIsReadOnly();

From ddca4bd528089d54b1e744ffac2ecde5525f203e Mon Sep 17 00:00:00 2001
From: LambdAurora <email@lambdaurora.dev>
Date: Tue, 8 Jul 2025 18:10:00 +0200
Subject: [PATCH 204/322] Fix comparator lost buffer ref from proxy in Dbi.

TODO: address failing dbiWithComparatorThreadSafetyByteArray test.
---
 src/main/java/org/lmdbjava/Dbi.java           |  8 +-
 .../java/org/lmdbjava/ComparatorTest.java     | 13 ++-
 src/test/java/org/lmdbjava/DbiTest.java       | 94 ++++++++++++++-----
 src/test/java/org/lmdbjava/TestUtils.java     |  5 +
 4 files changed, 89 insertions(+), 31 deletions(-)

diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index ad1bb5a7..4a4cc350 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -81,10 +81,10 @@ public final class Dbi<T> {
     if (nativeCb) {
       this.ccb =
           (keyA, keyB) -> {
-            final T compKeyA = proxy.allocate();
-            final T compKeyB = proxy.allocate();
-            proxy.out(compKeyA, keyA, keyA.address());
-            proxy.out(compKeyB, keyB, keyB.address());
+            T compKeyA = proxy.allocate();
+            T compKeyB = proxy.allocate();
+            compKeyA = proxy.out(compKeyA, keyA, keyA.address());
+            compKeyB = proxy.out(compKeyB, keyB, keyB.address());
             final int result = this.comparator.compare(compKeyA, compKeyB);
             proxy.deallocate(compKeyA);
             proxy.deallocate(compKeyB);
diff --git a/src/test/java/org/lmdbjava/ComparatorTest.java b/src/test/java/org/lmdbjava/ComparatorTest.java
index 3e265cee..3c7e7a4d 100644
--- a/src/test/java/org/lmdbjava/ComparatorTest.java
+++ b/src/test/java/org/lmdbjava/ComparatorTest.java
@@ -67,11 +67,12 @@ public static Object[] data() {
     final ComparatorRunner string = new StringRunner();
     final ComparatorRunner db = new DirectBufferRunner();
     final ComparatorRunner ba = new ByteArrayRunner();
+    final ComparatorRunner baUnsigned = new UnsignedByteArrayRunner();
     final ComparatorRunner bb = new ByteBufferRunner();
     final ComparatorRunner netty = new NettyRunner();
     final ComparatorRunner gub = new GuavaUnsignedBytes();
     final ComparatorRunner gsb = new GuavaSignedBytes();
-    return new Object[] {string, db, ba, bb, netty, gub, gsb};
+    return new Object[] {string, db, ba, baUnsigned, bb, netty, gub, gsb};
   }
 
   private static byte[] buffer(final int... bytes) {
@@ -140,6 +141,16 @@ public int compare(final byte[] o1, final byte[] o2) {
     }
   }
 
+  /** Tests {@link ByteArrayProxy} (unsigned). */
+  private static final class UnsignedByteArrayRunner implements ComparatorRunner {
+
+    @Override
+    public int compare(final byte[] o1, final byte[] o2) {
+      final Comparator<byte[]> c = PROXY_BA.getUnsignedComparator();
+      return c.compare(o1, o2);
+    }
+  }
+
   /** Tests {@link ByteBufferProxy}. */
   private static final class ByteBufferRunner implements ComparatorRunner {
 
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 1fa80f6e..2e87830c 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -46,9 +46,7 @@
 import static org.lmdbjava.KeyRange.atMost;
 import static org.lmdbjava.PutFlags.MDB_NODUPDATA;
 import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
-import static org.lmdbjava.TestUtils.DB_1;
-import static org.lmdbjava.TestUtils.ba;
-import static org.lmdbjava.TestUtils.bb;
+import static org.lmdbjava.TestUtils.*;
 
 import java.io.File;
 import java.io.IOException;
@@ -63,7 +61,7 @@
 import java.util.concurrent.Future;
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.function.BiConsumer;
+import java.util.function.*;
 import org.agrona.concurrent.UnsafeBuffer;
 import org.hamcrest.Matchers;
 import org.junit.After;
@@ -82,6 +80,7 @@ public final class DbiTest {
 
   @Rule public final TemporaryFolder tmp = new TemporaryFolder();
   private Env<ByteBuffer> env;
+  private Env<byte[]> envBa;
 
   @After
   public void after() {
@@ -97,6 +96,13 @@ public void before() throws IOException {
             .setMaxReaders(2)
             .setMaxDbs(2)
             .open(path, MDB_NOSUBDIR);
+    final File pathBa = tmp.newFile();
+    envBa =
+        create(PROXY_BA)
+            .setMapSize(MEBIBYTES.toBytes(64))
+            .setMaxReaders(2)
+            .setMaxDbs(2)
+            .open(pathBa, MDB_NOSUBDIR);
   }
 
   @Test(expected = ConstantDerivedException.class)
@@ -117,20 +123,41 @@ public void customComparator() {
           }
           return lexical * -1;
         };
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, reverseOrder, true, MDB_CREATE);
-    try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      assertThat(db.put(txn, bb(2), bb(3)), is(true));
-      assertThat(db.put(txn, bb(4), bb(6)), is(true));
-      assertThat(db.put(txn, bb(6), bb(7)), is(true));
-      assertThat(db.put(txn, bb(8), bb(7)), is(true));
+    doCustomComparator(env, reverseOrder, TestUtils::bb, ByteBuffer::getInt);
+  }
+
+  @Test
+  public void customComparatorByteArray() {
+    final Comparator<byte[]> reverseOrder =
+        (o1, o2) -> {
+          final int lexical = PROXY_BA.getComparator().compare(o1, o2);
+          if (lexical == 0) {
+            return 0;
+          }
+          return lexical * -1;
+        };
+    doCustomComparator(envBa, reverseOrder, TestUtils::ba, TestUtils::fromBa);
+  }
+
+  private <T> void doCustomComparator(
+      Env<T> env,
+      Comparator<T> comparator,
+      IntFunction<T> serializer,
+      ToIntFunction<T> deserializer) {
+    final Dbi<T> db = env.openDbi(DB_1, comparator, true, MDB_CREATE);
+    try (Txn<T> txn = env.txnWrite()) {
+      assertThat(db.put(txn, serializer.apply(2), serializer.apply(3)), is(true));
+      assertThat(db.put(txn, serializer.apply(4), serializer.apply(6)), is(true));
+      assertThat(db.put(txn, serializer.apply(6), serializer.apply(7)), is(true));
+      assertThat(db.put(txn, serializer.apply(8), serializer.apply(7)), is(true));
       txn.commit();
     }
-    try (Txn<ByteBuffer> txn = env.txnRead();
-        CursorIterable<ByteBuffer> ci = db.iterate(txn, atMost(bb(4)))) {
-      final Iterator<KeyVal<ByteBuffer>> iter = ci.iterator();
-      assertThat(iter.next().key().getInt(), is(8));
-      assertThat(iter.next().key().getInt(), is(6));
-      assertThat(iter.next().key().getInt(), is(4));
+    try (Txn<T> txn = env.txnRead();
+        CursorIterable<T> ci = db.iterate(txn, atMost(serializer.apply(4)))) {
+      final Iterator<KeyVal<T>> iter = ci.iterator();
+      assertThat(deserializer.applyAsInt(iter.next().key()), is(8));
+      assertThat(deserializer.applyAsInt(iter.next().key()), is(6));
+      assertThat(deserializer.applyAsInt(iter.next().key()), is(4));
     }
   }
 
@@ -143,9 +170,24 @@ public void dbOpenMaxDatabases() {
 
   @Test
   public void dbiWithComparatorThreadSafety() {
+    doDbiWithComparatorThreadSafety(
+        env, PROXY_OPTIMAL::getComparator, TestUtils::bb, ByteBuffer::getInt);
+  }
+
+  @Test
+  public void dbiWithComparatorThreadSafetyByteArray() {
+    doDbiWithComparatorThreadSafety(
+        envBa, PROXY_BA::getComparator, TestUtils::ba, TestUtils::fromBa);
+  }
+
+  public <T> void doDbiWithComparatorThreadSafety(
+      Env<T> env,
+      Function<DbiFlags[], Comparator<T>> comparator,
+      IntFunction<T> serializer,
+      ToIntFunction<T> deserializer) {
     final DbiFlags[] flags = new DbiFlags[] {MDB_CREATE, MDB_INTEGERKEY};
-    final Comparator<ByteBuffer> c = PROXY_OPTIMAL.getComparator(flags);
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, c, true, flags);
+    final Comparator<T> c = comparator.apply(flags);
+    final Dbi<T> db = env.openDbi(DB_1, c, true, flags);
 
     final List<Integer> keys = range(0, 1_000).boxed().collect(toList());
 
@@ -155,25 +197,25 @@ public void dbiWithComparatorThreadSafety() {
         pool.submit(
             () -> {
               while (proceed.get()) {
-                try (Txn<ByteBuffer> txn = env.txnRead()) {
-                  db.get(txn, bb(50));
+                try (Txn<T> txn = env.txnRead()) {
+                  db.get(txn, serializer.apply(50));
                 }
               }
             });
 
     for (final Integer key : keys) {
-      try (Txn<ByteBuffer> txn = env.txnWrite()) {
-        db.put(txn, bb(key), bb(3));
+      try (Txn<T> txn = env.txnWrite()) {
+        db.put(txn, serializer.apply(key), serializer.apply(3));
         txn.commit();
       }
     }
 
-    try (Txn<ByteBuffer> txn = env.txnRead();
-        CursorIterable<ByteBuffer> ci = db.iterate(txn)) {
-      final Iterator<KeyVal<ByteBuffer>> iter = ci.iterator();
+    try (Txn<T> txn = env.txnRead();
+        CursorIterable<T> ci = db.iterate(txn)) {
+      final Iterator<KeyVal<T>> iter = ci.iterator();
       final List<Integer> result = new ArrayList<>();
       while (iter.hasNext()) {
-        result.add(iter.next().key().getInt());
+        result.add(deserializer.applyAsInt(iter.next().key()));
       }
 
       assertThat(result, Matchers.contains(keys.toArray(new Integer[0])));
diff --git a/src/test/java/org/lmdbjava/TestUtils.java b/src/test/java/org/lmdbjava/TestUtils.java
index 42dcf052..fd070a31 100644
--- a/src/test/java/org/lmdbjava/TestUtils.java
+++ b/src/test/java/org/lmdbjava/TestUtils.java
@@ -41,6 +41,11 @@ static byte[] ba(final int value) {
     return b.byteArray();
   }
 
+  static int fromBa(final byte[] ba) {
+    final MutableDirectBuffer b = new UnsafeBuffer(ba);
+    return b.getInt(0);
+  }
+
   static ByteBuffer bb(final int value) {
     final ByteBuffer bb = allocateDirect(BYTES);
     bb.putInt(value).flip();

From 236b7c9b912e271bfd6a57c612d12ca641b91d13 Mon Sep 17 00:00:00 2001
From: LambdAurora <email@lambdaurora.dev>
Date: Wed, 9 Jul 2025 10:50:24 +0200
Subject: [PATCH 205/322] Use ByteBuffer for int serialization into bytes.

This proves to be more reliable than Agreno's UnsafeBuffers.
---
 src/test/java/org/lmdbjava/DbiTest.java   | 3 +--
 src/test/java/org/lmdbjava/TestUtils.java | 9 ++++-----
 2 files changed, 5 insertions(+), 7 deletions(-)

diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 2e87830c..75c23931 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -62,7 +62,6 @@
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.*;
-import org.agrona.concurrent.UnsafeBuffer;
 import org.hamcrest.Matchers;
 import org.junit.After;
 import org.junit.Before;
@@ -381,7 +380,7 @@ public void putCommitGetByteArray() throws IOException {
       try (Txn<byte[]> txn = envBa.txnWrite()) {
         final byte[] found = db.get(txn, ba(5));
         assertNotNull(found);
-        assertThat(new UnsafeBuffer(txn.val()).getInt(0), is(5));
+        assertThat(fromBa(txn.val()), is(5));
       }
     }
   }
diff --git a/src/test/java/org/lmdbjava/TestUtils.java b/src/test/java/org/lmdbjava/TestUtils.java
index fd070a31..c0203264 100644
--- a/src/test/java/org/lmdbjava/TestUtils.java
+++ b/src/test/java/org/lmdbjava/TestUtils.java
@@ -36,14 +36,13 @@ final class TestUtils {
   private TestUtils() {}
 
   static byte[] ba(final int value) {
-    final MutableDirectBuffer b = new UnsafeBuffer(new byte[4]);
-    b.putInt(0, value);
-    return b.byteArray();
+    byte[] bytes = new byte[4];
+    ByteBuffer.wrap(bytes).putInt(value);
+    return bytes;
   }
 
   static int fromBa(final byte[] ba) {
-    final MutableDirectBuffer b = new UnsafeBuffer(ba);
-    return b.getInt(0);
+    return ByteBuffer.wrap(ba).getInt();
   }
 
   static ByteBuffer bb(final int value) {

From 741b6f295c73cbc827d13811f43e8589adf2f7fb Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 24 Oct 2025 10:06:45 +0100
Subject: [PATCH 206/322] Add OpenLDAP-2.8.txt

---
 licences/OpenLDAP-2.8.txt | 47 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 47 insertions(+)
 create mode 100644 licences/OpenLDAP-2.8.txt

diff --git a/licences/OpenLDAP-2.8.txt b/licences/OpenLDAP-2.8.txt
new file mode 100644
index 00000000..05ad7571
--- /dev/null
+++ b/licences/OpenLDAP-2.8.txt
@@ -0,0 +1,47 @@
+The OpenLDAP Public License
+  Version 2.8, 17 August 2003
+
+Redistribution and use of this software and associated documentation
+("Software"), with or without modification, are permitted provided
+that the following conditions are met:
+
+1. Redistributions in source form must retain copyright statements
+   and notices,
+
+2. Redistributions in binary form must reproduce applicable copyright
+   statements and notices, this list of conditions, and the following
+   disclaimer in the documentation and/or other materials provided
+   with the distribution, and
+
+3. Redistributions must contain a verbatim copy of this document.
+
+The OpenLDAP Foundation may revise this license from time to time.
+Each revision is distinguished by a version number.  You may use
+this Software under terms of this license revision or under the
+terms of any subsequent revision of the license.
+
+THIS SOFTWARE IS PROVIDED BY THE OPENLDAP FOUNDATION AND ITS
+CONTRIBUTORS ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT
+SHALL THE OPENLDAP FOUNDATION, ITS CONTRIBUTORS, OR THE AUTHOR(S)
+OR OWNER(S) OF THE SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+The names of the authors and copyright holders must not be used in
+advertising or otherwise to promote the sale, use or other dealing
+in this Software without specific, written prior permission.  Title
+to copyright in this Software shall at all times remain with copyright
+holders.
+
+OpenLDAP is a registered trademark of the OpenLDAP Foundation.
+
+Copyright 1999-2003 The OpenLDAP Foundation, Redwood City,
+California, USA.  All Rights Reserved.  Permission to copy and
+distribute verbatim copies of this document is granted.

From 180b91f3f8afded358d8308544929c0697cfc77c Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 24 Oct 2025 10:07:50 +0100
Subject: [PATCH 207/322] Create Apache-2.0

---
 licences/Apache-2.0 | 51 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)
 create mode 100644 licences/Apache-2.0

diff --git a/licences/Apache-2.0 b/licences/Apache-2.0
new file mode 100644
index 00000000..6ca24c75
--- /dev/null
+++ b/licences/Apache-2.0
@@ -0,0 +1,51 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.
+
+"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:
+
+You must give any other recipients of the Work or Derivative Works a copy of this License; and
+You must cause any modified files to carry prominent notices stating that You changed the files; and
+You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and
+If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.
+You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS

From 0f202f303db0b3f78132ebaaf764264bd37e4aa7 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 24 Oct 2025 10:15:34 +0100
Subject: [PATCH 208/322] Create NOTICE.md

---
 NOTICE.md | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 NOTICE.md

diff --git a/NOTICE.md b/NOTICE.md
new file mode 100644
index 00000000..d5727a9d
--- /dev/null
+++ b/NOTICE.md
@@ -0,0 +1,17 @@
+Copyright © 2016-2025 The LmdbJava Open Source Project
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+[http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0)
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+---
+
+This project distribution JAR includes a distribution of [LMDB](https://www.symas.com/mdb), which is licensed under the [OpenLDAP Public License](./licences/OpenLDAP-2.8.txt).

From 856ab0e282736d9d94d8409d9d13f66c18e387ff Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 24 Oct 2025 10:37:39 +0100
Subject: [PATCH 209/322] Update NOTICE.md

---
 NOTICE.md | 21 ++++++++++++++++++++-
 1 file changed, 20 insertions(+), 1 deletion(-)

diff --git a/NOTICE.md b/NOTICE.md
index d5727a9d..0145c1b3 100644
--- a/NOTICE.md
+++ b/NOTICE.md
@@ -14,4 +14,23 @@ limitations under the License.
 
 ---
 
-This project distribution JAR includes a distribution of [LMDB](https://www.symas.com/mdb), which is licensed under the [OpenLDAP Public License](./licences/OpenLDAP-2.8.txt).
+The LmdbJava project distribution JAR file includes a distribution of [LMDB](https://www.symas.com/mdb), which is licensed under the [OpenLDAP Public License](https://www.openldap.org/software/release/license.html).
+
+---
+
+# Dependencies
+
+LmdbJava uses the following libraries.
+All licenese files can also be found in the `licences` directory in the root of this repository.
+
+| Dependency | License |
+|-------------|----------|
+| `com.github.jnr:jnr-constants` | [Apache License 2.0](http://www.apache.org/licenses/LICENSE-2.0) |
+| `com.github.jnr:jnr-ffi` | [Apache License 2.0](http://www.apache.org/licenses/LICENSE-2.0) |
+| `com.google.guava:guava` | [Apache License 2.0](http://www.apache.org/licenses/LICENSE-2.0) |
+| `com.jakewharton.byteunits:byteunits` | [Apache License 2.0](http://www.apache.org/licenses/LICENSE-2.0) |
+| `io.netty:netty-buffer` | [Apache License 2.0](http://www.apache.org/licenses/LICENSE-2.0) |
+| `junit:junit` | [Eclipse Public License 1.0](https://www.eclipse.org/org/documents/epl-v10.html) |
+| `org.agrona:agrona` | [Apache License 2.0](http://www.apache.org/licenses/LICENSE-2.0) |
+| `org.hamcrest:hamcrest` | [BSD 3-Clause License](https://opensource.org/license/bsd-3-clause) |
+| `org.mockito:mockito-inline` | [MIT License](https://opensource.org/license/mit) |

From 3a8d27995c511f9b94073324a4a60616695ead0c Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Sat, 25 Oct 2025 15:02:22 +1100
Subject: [PATCH 210/322] Prevent license plugin from modifying license texts

---
 pom.xml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/pom.xml b/pom.xml
index b3012729..b270c4b0 100644
--- a/pom.xml
+++ b/pom.xml
@@ -108,6 +108,7 @@
                 <exclude>LICENSE.txt</exclude>
                 <exclude>**/*.md</exclude>
                 <exclude>lmdb/**</exclude>
+                <exclude>licenses/**</exclude>
               </excludes>
             </licenseSet>
           </licenseSets>

From 9d7b32eee7537b3807e29de84358dfa7eaa302eb Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Sat, 25 Oct 2025 15:03:13 +1100
Subject: [PATCH 211/322] Automatic POM formatting only

---
 pom.xml | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/pom.xml b/pom.xml
index b270c4b0..454fc3d3 100644
--- a/pom.xml
+++ b/pom.xml
@@ -185,19 +185,19 @@
             </goals>
             <configuration>
               <rules>
-                <dependencyConvergence />
+                <dependencyConvergence/>
                 <requireMavenVersion>
                   <version>[${maven.enforcer.mvn},)</version>
                 </requireMavenVersion>
                 <requireJavaVersion>
                   <version>[${maven.enforcer.java},)</version>
                 </requireJavaVersion>
-                <requireNoRepositories />
-                <requirePluginVersions />
+                <requireNoRepositories/>
+                <requirePluginVersions/>
                 <requireReleaseDeps>
                   <onlyWhenRelease>true</onlyWhenRelease>
                 </requireReleaseDeps>
-                <requireUpperBoundDeps />
+                <requireUpperBoundDeps/>
               </rules>
             </configuration>
           </execution>
@@ -352,7 +352,7 @@
       <name>Kristoffer Sjogren</name>
       <email>stoffe -at- gmail.com</email>
       <url>http://stoffe.deephacks.org/</url>
-      <organization />
+      <organization/>
       <timezone>+1</timezone>
     </developer>
     <developer>

From 8ab46ee4636a11cfea019004021334e9c3c99e4a Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Sat, 25 Oct 2025 15:03:43 +1100
Subject: [PATCH 212/322] JaCoCo Maven Plugin update to 0.8.14

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 454fc3d3..3a71e33c 100644
--- a/pom.xml
+++ b/pom.xml
@@ -316,7 +316,7 @@
       <plugin>
         <groupId>org.jacoco</groupId>
         <artifactId>jacoco-maven-plugin</artifactId>
-        <version>0.8.12</version>
+        <version>0.8.14</version>
         <executions>
           <execution>
             <id>config-jacoco-prepare-agent</id>

From 79c2382d5eaabee1ae818288fc0c065345fe0024 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Sat, 25 Oct 2025 15:04:35 +1100
Subject: [PATCH 213/322] Format Maven Plugin update to 2.29 (inc Java 25
 workaround)

---
 pom.xml | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/pom.xml b/pom.xml
index 3a71e33c..0863fdf7 100644
--- a/pom.xml
+++ b/pom.xml
@@ -442,16 +442,17 @@
             </executions>
           </plugin>
           <plugin>
+            <!-- https://github.com/spotify/fmt-maven-plugin/issues/210 -->
             <groupId>com.spotify.fmt</groupId>
             <artifactId>fmt-maven-plugin</artifactId>
-            <version>2.25</version>
-            <executions>
-              <execution>
-                <goals>
-                  <goal>format</goal>
-                </goals>
-              </execution>
-            </executions>
+            <version>2.29</version>
+            <dependencies>
+              <dependency>
+                <groupId>com.google.googlejavaformat</groupId>
+                <artifactId>google-java-format</artifactId>
+                <version>1.28.0</version>
+              </dependency>
+            </dependencies>
           </plugin>
         </plugins>
       </build>

From 40192dbfef98c2f60dd90d3e2b4b6981971e8419 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Sat, 25 Oct 2025 15:07:56 +1100
Subject: [PATCH 214/322] Rename licences -> licenses for consistency

This matches the existing LICENSE.TXT spelling and the spelling of the
license we are using: https://httpd.apache.org/docs/trunk/license.html
---
 NOTICE.md                               | 2 +-
 {licences => licenses}/Apache-2.0       | 0
 {licences => licenses}/OpenLDAP-2.8.txt | 0
 3 files changed, 1 insertion(+), 1 deletion(-)
 rename {licences => licenses}/Apache-2.0 (100%)
 rename {licences => licenses}/OpenLDAP-2.8.txt (100%)

diff --git a/NOTICE.md b/NOTICE.md
index 0145c1b3..77fad436 100644
--- a/NOTICE.md
+++ b/NOTICE.md
@@ -21,7 +21,7 @@ The LmdbJava project distribution JAR file includes a distribution of [LMDB](htt
 # Dependencies
 
 LmdbJava uses the following libraries.
-All licenese files can also be found in the `licences` directory in the root of this repository.
+All license files can also be found in the `licenses` directory in the root of this repository.
 
 | Dependency | License |
 |-------------|----------|
diff --git a/licences/Apache-2.0 b/licenses/Apache-2.0
similarity index 100%
rename from licences/Apache-2.0
rename to licenses/Apache-2.0
diff --git a/licences/OpenLDAP-2.8.txt b/licenses/OpenLDAP-2.8.txt
similarity index 100%
rename from licences/OpenLDAP-2.8.txt
rename to licenses/OpenLDAP-2.8.txt

From e598e21a0837fafc398747fa625de7b8cbfb4a36 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Sat, 25 Oct 2025 15:09:51 +1100
Subject: [PATCH 215/322] Migrate to Maven Central Portal Publisher API

---
 .github/workflows/maven.yml | 16 ++++++++--------
 README.md                   |  2 +-
 pom.xml                     | 23 ++++++-----------------
 3 files changed, 15 insertions(+), 26 deletions(-)

diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml
index b28e8481..a3311ce7 100644
--- a/.github/workflows/maven.yml
+++ b/.github/workflows/maven.yml
@@ -82,7 +82,7 @@ jobs:
           path: target/surefire-reports
 
   deploy:
-    name: Deploy to OSSRH
+    name: Deploy to Central Portal
     needs: [build, compatibility-checks]
     if: github.event_name == 'push'
     runs-on: ubuntu-latest
@@ -98,9 +98,9 @@ jobs:
         # Java version 8 required due to https://github.com/lmdbjava/lmdbjava/issues/116
         java-version: 8
         cache: maven
-        server-id: ossrh
-        server-username: MAVEN_USERNAME
-        server-password: MAVEN_CENTRAL_TOKEN
+        server-id: central
+        server-username: MAVEN_CENTRAL_USERNAME
+        server-password: MAVEN_CENTRAL_PASSWORD
         gpg-private-key: ${{ secrets.gpg_private_key }}
         gpg-passphrase: MAVEN_GPG_PASSPHRASE
 
@@ -111,15 +111,15 @@ jobs:
       run: ./cross-compile.sh
 
     - name: Publish Maven package
-      run: mvn -B -Possrh-deploy deploy -DskipTests
+      run: mvn -B -Pcentral-deploy deploy -DskipTests
       env:
         MAVEN_GPG_PASSPHRASE: ${{ secrets.gpg_passphrase }}
-        MAVEN_USERNAME: ${{ secrets.nexus_username }}
-        MAVEN_CENTRAL_TOKEN: ${{ secrets.nexus_password }}
+        MAVEN_CENTRAL_USERNAME: ${{ secrets.central_username }}
+        MAVEN_CENTRAL_PASSWORD: ${{ secrets.central_password }}
 
     - name: Debug settings.xml
       uses: actions/upload-artifact@v4
       if: failure()
       with:
         name: settings.xml
-        path: $HOME/.m2/settings.xml
+        path: ~/.m2/settings.xml
diff --git a/README.md b/README.md
index 048e57bc..cde62cd8 100644
--- a/README.md
+++ b/README.md
@@ -31,7 +31,7 @@
 * Low latency design (allocation-free; buffer pools; optional checks can be easily disabled in production etc)
 * Mature code (commenced in 2016) and used for heavy production workloads (eg > 500 TB of HFT data)
 * Actively maintained and with a "Zero Bug Policy" before every release (see [issues](https://github.com/lmdbjava/lmdbjava/issues))
-* Available from [Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22org.lmdbjava%22%20AND%20a%3A%22lmdbjava%22) and [OSS Sonatype Snapshots](https://oss.sonatype.org/content/repositories/snapshots/org/lmdbjava/lmdbjava)
+* Available from [Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22org.lmdbjava%22%20AND%20a%3A%22lmdbjava%22) and [Central Portal Snapshots](https://central.sonatype.com/repository/maven-snapshots/org/lmdbjava/lmdbjava)
 * [Continuous integration](https://github.com/lmdbjava/lmdbjava/actions) testing on Linux, Windows and macOS with Java 8, 11, 17 and 21
 
 ### Performance
diff --git a/pom.xml b/pom.xml
index 0863fdf7..12af842d 100644
--- a/pom.xml
+++ b/pom.xml
@@ -378,16 +378,6 @@
     <system>GitHub Actions</system>
     <url>https://github.com/lmdbjava/lmdbjava/actions</url>
   </ciManagement>
-  <distributionManagement>
-    <repository>
-      <id>ossrh</id>
-      <url>https://oss.sonatype.org/service/local/staging/deploy/maven2/</url>
-    </repository>
-    <snapshotRepository>
-      <id>ossrh</id>
-      <url>https://oss.sonatype.org/content/repositories/snapshots</url>
-    </snapshotRepository>
-  </distributionManagement>
   <profiles>
     <profile>
       <id>add-opens-on-java-9-and-above</id>
@@ -458,7 +448,7 @@
       </build>
     </profile>
     <profile>
-      <id>ossrh-deploy</id>
+      <id>central-deploy</id>
       <build>
         <plugins>
           <plugin>
@@ -482,14 +472,13 @@
             </executions>
           </plugin>
           <plugin>
-            <groupId>org.sonatype.plugins</groupId>
-            <artifactId>nexus-staging-maven-plugin</artifactId>
-            <version>1.7.0</version>
+            <groupId>org.sonatype.central</groupId>
+            <artifactId>central-publishing-maven-plugin</artifactId>
+            <version>0.9.0</version>
             <extensions>true</extensions>
             <configuration>
-              <serverId>ossrh</serverId>
-              <nexusUrl>https://oss.sonatype.org/</nexusUrl>
-              <autoReleaseAfterClose>true</autoReleaseAfterClose>
+              <publishingServerId>central</publishingServerId>
+              <autoPublish>true</autoPublish>
             </configuration>
           </plugin>
         </plugins>

From 3a4b9acf010ac3a992f310458034e5801ae86df6 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Sat, 25 Oct 2025 15:43:31 +1100
Subject: [PATCH 216/322] Fix typo

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index cde62cd8..af13364d 100644
--- a/README.md
+++ b/README.md
@@ -67,7 +67,7 @@ updated (eg following a new official release of the upstream LMDB library).
 If you do not wish to install Zig and/or use an operating system which cannot
 easily execute the `cross-compile.sh` script, you can download the compiled
 LMDB native library for your platform from a location of your choice and set the
-`lmdbjava.native.lib` system property to the resulting file system system
+`lmdbjava.native.lib` system property to the resulting file system
 location. Possible sources of a compiled LMDB native library include operating
 system package managers, running `cross-compile.sh` on a supported system, or
 copying it from the `org/lmdbjava` directory of any recent, officially released

From 1ea59025e61702c40cbd445b10d458e5889881b0 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Sat, 25 Oct 2025 15:44:58 +1100
Subject: [PATCH 217/322] Add Java 25 testing

---
 .github/workflows/maven.yml | 4 ++--
 README.md                   | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml
index a3311ce7..3b97a0c6 100644
--- a/.github/workflows/maven.yml
+++ b/.github/workflows/maven.yml
@@ -19,7 +19,7 @@ jobs:
       uses: actions/setup-java@v3
       with:
         distribution: zulu
-        java-version: 21
+        java-version: 25
         cache: maven
 
     - name: Install Zig
@@ -52,7 +52,7 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest]
-        java: [8, 11, 17, 21]
+        java: [8, 11, 17, 21, 25]
 
     steps:
       - name: Check out Git repository
diff --git a/README.md b/README.md
index af13364d..99ccf54f 100644
--- a/README.md
+++ b/README.md
@@ -32,7 +32,7 @@
 * Mature code (commenced in 2016) and used for heavy production workloads (eg > 500 TB of HFT data)
 * Actively maintained and with a "Zero Bug Policy" before every release (see [issues](https://github.com/lmdbjava/lmdbjava/issues))
 * Available from [Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22org.lmdbjava%22%20AND%20a%3A%22lmdbjava%22) and [Central Portal Snapshots](https://central.sonatype.com/repository/maven-snapshots/org/lmdbjava/lmdbjava)
-* [Continuous integration](https://github.com/lmdbjava/lmdbjava/actions) testing on Linux, Windows and macOS with Java 8, 11, 17 and 21
+* [Continuous integration](https://github.com/lmdbjava/lmdbjava/actions) testing on Linux, Windows and macOS with Java 8, 11, 17, 21 and 25
 
 ### Performance
 

From c91893a876e7edaaea503f689066cf4a6e96f156 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Sat, 25 Oct 2025 19:23:06 +1100
Subject: [PATCH 218/322] Fix transient pointer deallocation in ByteArrayProxy

JNR-FFI's TransientNativeMemory was prematurely deallocating off-heap
memory before LMDB syscalls completed. Return transient pointers from
BufferProxy.in() and use reachability fencing at all call sites to
prevent premature GC.

BufferProxy and KeyVal were also simplified to remove pointer address
passing, given this is inexpensively available from the
Pointer.address() accessor (which is backed by a final field).

This is an API breaking change if external users implemented their own
BufferProxy, however it is considered unlikely many (if any) users
would have ever done this.

Fixes #252
---
 src/main/java/org/lmdbjava/BufferProxy.java   | 11 ++++---
 .../java/org/lmdbjava/ByteArrayProxy.java     |  8 +++--
 src/main/java/org/lmdbjava/ByteBufProxy.java  | 11 +++++--
 .../java/org/lmdbjava/ByteBufferProxy.java    | 22 +++++++++-----
 src/main/java/org/lmdbjava/Cursor.java        | 29 ++++++++++++++-----
 src/main/java/org/lmdbjava/Dbi.java           | 29 ++++++++++++-------
 .../java/org/lmdbjava/DirectBufferProxy.java  | 12 +++++---
 src/main/java/org/lmdbjava/KeyVal.java        | 22 ++++++--------
 .../org/lmdbjava/ByteBufferProxyTest.java     |  4 +--
 9 files changed, 91 insertions(+), 57 deletions(-)

diff --git a/src/main/java/org/lmdbjava/BufferProxy.java b/src/main/java/org/lmdbjava/BufferProxy.java
index e66031d2..96d6aa1e 100644
--- a/src/main/java/org/lmdbjava/BufferProxy.java
+++ b/src/main/java/org/lmdbjava/BufferProxy.java
@@ -107,9 +107,9 @@ protected Comparator<T> getComparator(DbiFlags... flags) {
    *
    * @param buffer the buffer to write to <code>MDB_val</code>
    * @param ptr the pointer to the <code>MDB_val</code>
-   * @param ptrAddr the address of the <code>MDB_val</code> pointer
+   * @return a transient pointer that must be kept alive, or null if none
    */
-  protected abstract void in(T buffer, Pointer ptr, long ptrAddr);
+  protected abstract Pointer in(T buffer, Pointer ptr);
 
   /**
    * Called when the <code>MDB_val</code> should be set to reflect the passed buffer.
@@ -117,9 +117,9 @@ protected Comparator<T> getComparator(DbiFlags... flags) {
    * @param buffer the buffer to write to <code>MDB_val</code>
    * @param size the buffer size to write to <code>MDB_val</code>
    * @param ptr the pointer to the <code>MDB_val</code>
-   * @param ptrAddr the address of the <code>MDB_val</code> pointer
+   * @return a transient pointer that must be kept alive, or null if none
    */
-  protected abstract void in(T buffer, int size, Pointer ptr, long ptrAddr);
+  protected abstract Pointer in(T buffer, int size, Pointer ptr);
 
   /**
    * Called when the <code>MDB_val</code> may have changed and the passed buffer should be modified
@@ -127,10 +127,9 @@ protected Comparator<T> getComparator(DbiFlags... flags) {
    *
    * @param buffer the buffer to write to <code>MDB_val</code>
    * @param ptr the pointer to the <code>MDB_val</code>
-   * @param ptrAddr the address of the <code>MDB_val</code> pointer
    * @return the buffer for <code>MDB_val</code>
    */
-  protected abstract T out(T buffer, Pointer ptr, long ptrAddr);
+  protected abstract T out(T buffer, Pointer ptr);
 
   /**
    * Create a new {@link KeyVal} to hold pointers for this buffer proxy.
diff --git a/src/main/java/org/lmdbjava/ByteArrayProxy.java b/src/main/java/org/lmdbjava/ByteArrayProxy.java
index 4a22ab83..853521e0 100644
--- a/src/main/java/org/lmdbjava/ByteArrayProxy.java
+++ b/src/main/java/org/lmdbjava/ByteArrayProxy.java
@@ -114,20 +114,22 @@ protected Comparator<byte[]> getUnsignedComparator() {
   }
 
   @Override
-  protected void in(final byte[] buffer, final Pointer ptr, final long ptrAddr) {
+  protected Pointer in(final byte[] buffer, final Pointer ptr) {
     final Pointer pointer = MEM_MGR.allocateDirect(buffer.length);
     pointer.put(0, buffer, 0, buffer.length);
     ptr.putLong(STRUCT_FIELD_OFFSET_SIZE, buffer.length);
     ptr.putAddress(STRUCT_FIELD_OFFSET_DATA, pointer.address());
+    return pointer;
   }
 
   @Override
-  protected void in(final byte[] buffer, final int size, final Pointer ptr, final long ptrAddr) {
+  protected Pointer in(final byte[] buffer, final int size, final Pointer ptr) {
     // cannot reserve for byte arrays
+    return null;
   }
 
   @Override
-  protected byte[] out(final byte[] buffer, final Pointer ptr, final long ptrAddr) {
+  protected byte[] out(final byte[] buffer, final Pointer ptr) {
     final long addr = ptr.getAddress(STRUCT_FIELD_OFFSET_DATA);
     final int size = (int) ptr.getLong(STRUCT_FIELD_OFFSET_SIZE);
     final Pointer pointer = MEM_MGR.newPointer(addr, size);
diff --git a/src/main/java/org/lmdbjava/ByteBufProxy.java b/src/main/java/org/lmdbjava/ByteBufProxy.java
index cac5b97b..2866e874 100644
--- a/src/main/java/org/lmdbjava/ByteBufProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufProxy.java
@@ -136,21 +136,26 @@ protected byte[] getBytes(final ByteBuf buffer) {
   }
 
   @Override
-  protected void in(final ByteBuf buffer, final Pointer ptr, final long ptrAddr) {
+  protected Pointer in(final ByteBuf buffer, final Pointer ptr) {
+    final long ptrAddr = ptr.address();
     UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_SIZE, buffer.writerIndex() - buffer.readerIndex());
     UNSAFE.putLong(
         ptrAddr + STRUCT_FIELD_OFFSET_DATA, buffer.memoryAddress() + buffer.readerIndex());
+    return null;
   }
 
   @Override
-  protected void in(final ByteBuf buffer, final int size, final Pointer ptr, final long ptrAddr) {
+  protected Pointer in(final ByteBuf buffer, final int size, final Pointer ptr) {
+    final long ptrAddr = ptr.address();
     UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_SIZE, size);
     UNSAFE.putLong(
         ptrAddr + STRUCT_FIELD_OFFSET_DATA, buffer.memoryAddress() + buffer.readerIndex());
+    return null;
   }
 
   @Override
-  protected ByteBuf out(final ByteBuf buffer, final Pointer ptr, final long ptrAddr) {
+  protected ByteBuf out(final ByteBuf buffer, final Pointer ptr) {
+    final long ptrAddr = ptr.address();
     final long addr = UNSAFE.getLong(ptrAddr + STRUCT_FIELD_OFFSET_DATA);
     final long size = UNSAFE.getLong(ptrAddr + STRUCT_FIELD_OFFSET_SIZE);
     UNSAFE.putLong(buffer, addressOffset, addr);
diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
index 2b7cdf0d..9f30f576 100644
--- a/src/main/java/org/lmdbjava/ByteBufferProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -221,20 +221,22 @@ private static final class ReflectiveProxy extends AbstractByteBufferProxy {
     }
 
     @Override
-    protected void in(final ByteBuffer buffer, final Pointer ptr, final long ptrAddr) {
+    protected Pointer in(final ByteBuffer buffer, final Pointer ptr) {
       ptr.putAddress(STRUCT_FIELD_OFFSET_DATA, address(buffer));
       ptr.putLong(STRUCT_FIELD_OFFSET_SIZE, buffer.remaining());
+      return null;
     }
 
     @Override
-    protected void in(
-        final ByteBuffer buffer, final int size, final Pointer ptr, final long ptrAddr) {
+    protected Pointer in(final ByteBuffer buffer, final int size, final Pointer ptr) {
       ptr.putLong(STRUCT_FIELD_OFFSET_SIZE, size);
       ptr.putAddress(STRUCT_FIELD_OFFSET_DATA, address(buffer));
+      return null;
     }
 
     @Override
-    protected ByteBuffer out(final ByteBuffer buffer, final Pointer ptr, final long ptrAddr) {
+    protected ByteBuffer out(final ByteBuffer buffer, final Pointer ptr) {
+      final long ptrAddr = ptr.address();
       final long addr = ptr.getAddress(STRUCT_FIELD_OFFSET_DATA);
       final long size = ptr.getLong(STRUCT_FIELD_OFFSET_SIZE);
       try {
@@ -269,20 +271,24 @@ private static final class UnsafeProxy extends AbstractByteBufferProxy {
     }
 
     @Override
-    protected void in(final ByteBuffer buffer, final Pointer ptr, final long ptrAddr) {
+    protected Pointer in(final ByteBuffer buffer, final Pointer ptr) {
+      final long ptrAddr = ptr.address();
       UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_SIZE, buffer.remaining());
       UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_DATA, address(buffer));
+      return null;
     }
 
     @Override
-    protected void in(
-        final ByteBuffer buffer, final int size, final Pointer ptr, final long ptrAddr) {
+    protected Pointer in(final ByteBuffer buffer, final int size, final Pointer ptr) {
+      final long ptrAddr = ptr.address();
       UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_SIZE, size);
       UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_DATA, address(buffer));
+      return null;
     }
 
     @Override
-    protected ByteBuffer out(final ByteBuffer buffer, final Pointer ptr, final long ptrAddr) {
+    protected ByteBuffer out(final ByteBuffer buffer, final Pointer ptr) {
+      final long ptrAddr = ptr.address();
       final long addr = UNSAFE.getLong(ptrAddr + STRUCT_FIELD_OFFSET_DATA);
       final long size = UNSAFE.getLong(ptrAddr + STRUCT_FIELD_OFFSET_SIZE);
       UNSAFE.putLong(buffer, ADDRESS_OFFSET, addr);
diff --git a/src/main/java/org/lmdbjava/Cursor.java b/src/main/java/org/lmdbjava/Cursor.java
index d49a9bed..f7fcbc41 100644
--- a/src/main/java/org/lmdbjava/Cursor.java
+++ b/src/main/java/org/lmdbjava/Cursor.java
@@ -141,8 +141,8 @@ public boolean get(final T key, final T data, final SeekOp op) {
       checkNotClosed();
       txn.checkReady();
     }
-    kv.keyIn(key);
-    kv.valIn(data);
+    final Pointer transientKey = kv.keyIn(key);
+    final Pointer transientVal = kv.valIn(data);
 
     final int rc = LIB.mdb_cursor_get(ptrCursor, kv.pointerKey(), kv.pointerVal(), op.getCode());
 
@@ -153,6 +153,10 @@ public boolean get(final T key, final T data, final SeekOp op) {
     checkRc(rc);
     kv.keyOut();
     kv.valOut();
+    ReferenceUtil.reachabilityFence0(transientKey);
+    ReferenceUtil.reachabilityFence0(transientVal);
+    ReferenceUtil.reachabilityFence0(kv.key());
+    ReferenceUtil.reachabilityFence0(kv.val());
     ReferenceUtil.reachabilityFence0(key);
     return true;
   }
@@ -172,7 +176,7 @@ public boolean get(final T key, final GetOp op) {
       checkNotClosed();
       txn.checkReady();
     }
-    kv.keyIn(key);
+    final Pointer transientKey = kv.keyIn(key);
 
     final int rc = LIB.mdb_cursor_get(ptrCursor, kv.pointerKey(), kv.pointerVal(), op.getCode());
 
@@ -183,6 +187,9 @@ public boolean get(final T key, final GetOp op) {
     checkRc(rc);
     kv.keyOut();
     kv.valOut();
+    ReferenceUtil.reachabilityFence0(transientKey);
+    ReferenceUtil.reachabilityFence0(kv.key());
+    ReferenceUtil.reachabilityFence0(kv.val());
     ReferenceUtil.reachabilityFence0(key);
     return true;
   }
@@ -243,8 +250,8 @@ public boolean put(final T key, final T val, final PutFlags... op) {
       txn.checkReady();
       txn.checkWritesAllowed();
     }
-    kv.keyIn(key);
-    kv.valIn(val);
+    final Pointer transientKey = kv.keyIn(key);
+    final Pointer transientVal = kv.valIn(val);
     final int mask = mask(true, op);
     final int rc = LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(), mask);
     if (rc == MDB_KEYEXIST) {
@@ -256,6 +263,8 @@ public boolean put(final T key, final T val, final PutFlags... op) {
       return false;
     }
     checkRc(rc);
+    ReferenceUtil.reachabilityFence0(transientKey);
+    ReferenceUtil.reachabilityFence0(transientVal);
     ReferenceUtil.reachabilityFence0(key);
     ReferenceUtil.reachabilityFence0(val);
     return true;
@@ -287,10 +296,12 @@ public void putMultiple(final T key, final T val, final int elements, final PutF
     if (SHOULD_CHECK && !isSet(mask, MDB_MULTIPLE)) {
       throw new IllegalArgumentException("Must set " + MDB_MULTIPLE + " flag");
     }
-    txn.kv().keyIn(key);
+    final Pointer transientKey = txn.kv().keyIn(key);
     final Pointer dataPtr = txn.kv().valInMulti(val, elements);
     final int rc = LIB.mdb_cursor_put(ptrCursor, txn.kv().pointerKey(), dataPtr, mask);
     checkRc(rc);
+    ReferenceUtil.reachabilityFence0(transientKey);
+    ReferenceUtil.reachabilityFence0(dataPtr);
     ReferenceUtil.reachabilityFence0(key);
     ReferenceUtil.reachabilityFence0(val);
   }
@@ -340,11 +351,13 @@ public T reserve(final T key, final int size, final PutFlags... op) {
       txn.checkReady();
       txn.checkWritesAllowed();
     }
-    kv.keyIn(key);
-    kv.valIn(size);
+    final Pointer transientKey = kv.keyIn(key);
+    final Pointer transientVal = kv.valIn(size);
     final int flags = mask(true, op) | MDB_RESERVE.getMask();
     checkRc(LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(), flags));
     kv.valOut();
+    ReferenceUtil.reachabilityFence0(transientKey);
+    ReferenceUtil.reachabilityFence0(transientVal);
     ReferenceUtil.reachabilityFence0(key);
     return val();
   }
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index ad1bb5a7..2fa7f185 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -83,8 +83,8 @@ public final class Dbi<T> {
           (keyA, keyB) -> {
             final T compKeyA = proxy.allocate();
             final T compKeyB = proxy.allocate();
-            proxy.out(compKeyA, keyA, keyA.address());
-            proxy.out(compKeyB, keyB, keyB.address());
+            proxy.out(compKeyA, keyA);
+            proxy.out(compKeyB, keyB);
             final int result = this.comparator.compare(compKeyA, compKeyB);
             proxy.deallocate(compKeyA);
             proxy.deallocate(compKeyB);
@@ -161,11 +161,12 @@ public boolean delete(final Txn<T> txn, final T key, final T val) {
       txn.checkWritesAllowed();
     }
 
-    txn.kv().keyIn(key);
+    final Pointer transientKey = txn.kv().keyIn(key);
 
     Pointer data = null;
+    Pointer transientVal = null;
     if (val != null) {
-      txn.kv().valIn(val);
+      transientVal = txn.kv().valIn(val);
       data = txn.kv().pointerVal();
     }
     final int rc = LIB.mdb_del(txn.pointer(), ptr, txn.kv().pointerKey(), data);
@@ -173,6 +174,8 @@ public boolean delete(final Txn<T> txn, final T key, final T val) {
       return false;
     }
     checkRc(rc);
+    ReferenceUtil.reachabilityFence0(transientKey);
+    ReferenceUtil.reachabilityFence0(transientVal);
     ReferenceUtil.reachabilityFence0(key);
     ReferenceUtil.reachabilityFence0(val);
     return true;
@@ -232,14 +235,16 @@ public T get(final Txn<T> txn, final T key) {
       env.checkNotClosed();
       txn.checkReady();
     }
-    txn.kv().keyIn(key);
+    final Pointer transientKey = txn.kv().keyIn(key);
     final int rc = LIB.mdb_get(txn.pointer(), ptr, txn.kv().pointerKey(), txn.kv().pointerVal());
     if (rc == MDB_NOTFOUND) {
       return null;
     }
     checkRc(rc);
+    final T result = txn.kv().valOut(); // marked as out in LMDB C docs
+    ReferenceUtil.reachabilityFence0(transientKey);
     ReferenceUtil.reachabilityFence0(key);
-    return txn.kv().valOut(); // marked as out in LMDB C docs
+    return result;
   }
 
   /**
@@ -366,8 +371,8 @@ public boolean put(final Txn<T> txn, final T key, final T val, final PutFlags...
       txn.checkReady();
       txn.checkWritesAllowed();
     }
-    txn.kv().keyIn(key);
-    txn.kv().valIn(val);
+    final Pointer transientKey = txn.kv().keyIn(key);
+    final Pointer transientVal = txn.kv().valIn(val);
     final int mask = mask(true, flags);
     final int rc =
         LIB.mdb_put(txn.pointer(), ptr, txn.kv().pointerKey(), txn.kv().pointerVal(), mask);
@@ -380,6 +385,8 @@ public boolean put(final Txn<T> txn, final T key, final T val, final PutFlags...
       return false;
     }
     checkRc(rc);
+    ReferenceUtil.reachabilityFence0(transientKey);
+    ReferenceUtil.reachabilityFence0(transientVal);
     ReferenceUtil.reachabilityFence0(key);
     ReferenceUtil.reachabilityFence0(val);
     return true;
@@ -408,11 +415,13 @@ public T reserve(final Txn<T> txn, final T key, final int size, final PutFlags..
       txn.checkReady();
       txn.checkWritesAllowed();
     }
-    txn.kv().keyIn(key);
-    txn.kv().valIn(size);
+    final Pointer transientKey = txn.kv().keyIn(key);
+    final Pointer transientVal = txn.kv().valIn(size);
     final int flags = mask(true, op) | MDB_RESERVE.getMask();
     checkRc(LIB.mdb_put(txn.pointer(), ptr, txn.kv().pointerKey(), txn.kv().pointerVal(), flags));
     txn.kv().valOut(); // marked as in,out in LMDB C docs
+    ReferenceUtil.reachabilityFence0(transientKey);
+    ReferenceUtil.reachabilityFence0(transientVal);
     ReferenceUtil.reachabilityFence0(key);
     return txn.val();
   }
diff --git a/src/main/java/org/lmdbjava/DirectBufferProxy.java b/src/main/java/org/lmdbjava/DirectBufferProxy.java
index 156e60e9..17b59b3d 100644
--- a/src/main/java/org/lmdbjava/DirectBufferProxy.java
+++ b/src/main/java/org/lmdbjava/DirectBufferProxy.java
@@ -134,23 +134,27 @@ protected byte[] getBytes(final DirectBuffer buffer) {
   }
 
   @Override
-  protected void in(final DirectBuffer buffer, final Pointer ptr, final long ptrAddr) {
+  protected Pointer in(final DirectBuffer buffer, final Pointer ptr) {
+    final long ptrAddr = ptr.address();
     final long addr = buffer.addressOffset();
     final long size = buffer.capacity();
     UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_DATA, addr);
     UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_SIZE, size);
+    return null;
   }
 
   @Override
-  protected void in(
-      final DirectBuffer buffer, final int size, final Pointer ptr, final long ptrAddr) {
+  protected Pointer in(final DirectBuffer buffer, final int size, final Pointer ptr) {
+    final long ptrAddr = ptr.address();
     final long addr = buffer.addressOffset();
     UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_DATA, addr);
     UNSAFE.putLong(ptrAddr + STRUCT_FIELD_OFFSET_SIZE, size);
+    return null;
   }
 
   @Override
-  protected DirectBuffer out(final DirectBuffer buffer, final Pointer ptr, final long ptrAddr) {
+  protected DirectBuffer out(final DirectBuffer buffer, final Pointer ptr) {
+    final long ptrAddr = ptr.address();
     final long addr = UNSAFE.getLong(ptrAddr + STRUCT_FIELD_OFFSET_DATA);
     final long size = UNSAFE.getLong(ptrAddr + STRUCT_FIELD_OFFSET_SIZE);
     buffer.wrap(addr, (int) size);
diff --git a/src/main/java/org/lmdbjava/KeyVal.java b/src/main/java/org/lmdbjava/KeyVal.java
index c6f2aae5..e2d2529f 100644
--- a/src/main/java/org/lmdbjava/KeyVal.java
+++ b/src/main/java/org/lmdbjava/KeyVal.java
@@ -36,9 +36,7 @@ final class KeyVal<T> implements AutoCloseable {
   private final BufferProxy<T> proxy;
   private final Pointer ptrArray;
   private final Pointer ptrKey;
-  private final long ptrKeyAddr;
   private final Pointer ptrVal;
-  private final long ptrValAddr;
   private T v;
 
   KeyVal(final BufferProxy<T> proxy) {
@@ -47,10 +45,8 @@ final class KeyVal<T> implements AutoCloseable {
     this.k = proxy.allocate();
     this.v = proxy.allocate();
     ptrKey = MEM_MGR.allocateTemporary(MDB_VAL_STRUCT_SIZE, false);
-    ptrKeyAddr = ptrKey.address();
     ptrArray = MEM_MGR.allocateTemporary(MDB_VAL_STRUCT_SIZE * 2, false);
     ptrVal = ptrArray.slice(0, MDB_VAL_STRUCT_SIZE);
-    ptrValAddr = ptrVal.address();
   }
 
   @Override
@@ -67,12 +63,12 @@ T key() {
     return k;
   }
 
-  void keyIn(final T key) {
-    proxy.in(key, ptrKey, ptrKeyAddr);
+  Pointer keyIn(final T key) {
+    return proxy.in(key, ptrKey);
   }
 
   T keyOut() {
-    k = proxy.out(k, ptrKey, ptrKeyAddr);
+    k = proxy.out(k, ptrKey);
     return k;
   }
 
@@ -88,12 +84,12 @@ T val() {
     return v;
   }
 
-  void valIn(final T val) {
-    proxy.in(val, ptrVal, ptrValAddr);
+  Pointer valIn(final T val) {
+    return proxy.in(val, ptrVal);
   }
 
-  void valIn(final int size) {
-    proxy.in(v, size, ptrVal, ptrValAddr);
+  Pointer valIn(final int size) {
+    return proxy.in(v, size, ptrVal);
   }
 
   /**
@@ -116,7 +112,7 @@ void valIn(final int size) {
   Pointer valInMulti(final T val, final int elements) {
     final long ptrVal2SizeOff = MDB_VAL_STRUCT_SIZE + STRUCT_FIELD_OFFSET_SIZE;
     ptrArray.putLong(ptrVal2SizeOff, elements); // ptrVal2.size
-    proxy.in(val, ptrVal, ptrValAddr); // ptrVal1.data
+    proxy.in(val, ptrVal); // ptrVal1.data
     final long totalBufferSize = ptrVal.getLong(STRUCT_FIELD_OFFSET_SIZE);
     final long elemSize = totalBufferSize / elements;
     ptrVal.putLong(STRUCT_FIELD_OFFSET_SIZE, elemSize); // ptrVal1.size
@@ -125,7 +121,7 @@ Pointer valInMulti(final T val, final int elements) {
   }
 
   T valOut() {
-    v = proxy.out(v, ptrVal, ptrValAddr);
+    v = proxy.out(v, ptrVal);
     return v;
   }
 }
diff --git a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
index 8044b9e8..b68f39ef 100644
--- a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
+++ b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
@@ -139,10 +139,10 @@ private void checkInOut(final BufferProxy<ByteBuffer> v) {
     b.position(BYTES); // skip 1
 
     final Pointer p = MEM_MGR.allocateTemporary(MDB_VAL_STRUCT_SIZE, false);
-    v.in(b, p, p.address());
+    v.in(b, p);
 
     final ByteBuffer bb = allocateDirect(1);
-    v.out(bb, p, p.address());
+    v.out(bb, p);
 
     assertThat(bb.getInt(), is(2));
     assertThat(bb.getInt(), is(3));

From a510be752f3d3546cd9fd7d016a374306bec1997 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Sat, 25 Oct 2025 19:37:00 +1100
Subject: [PATCH 219/322] Fix JavaDoc link

---
 src/main/java/org/lmdbjava/BufferProxy.java | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/main/java/org/lmdbjava/BufferProxy.java b/src/main/java/org/lmdbjava/BufferProxy.java
index 96d6aa1e..d4503731 100644
--- a/src/main/java/org/lmdbjava/BufferProxy.java
+++ b/src/main/java/org/lmdbjava/BufferProxy.java
@@ -48,8 +48,7 @@ public abstract class BufferProxy<T> {
   protected BufferProxy() {}
 
   /**
-   * Allocate a new buffer suitable for passing to {@link #out(java.lang.Object, jnr.ffi.Pointer,
-   * long)}.
+   * Allocate a new buffer suitable for passing to {@link #out(java.lang.Object, jnr.ffi.Pointer)}.
    *
    * @return a buffer for passing to the <code>out</code> method
    */

From a892768db1fedb5247e5ac8cc0346a8481f284ee Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Sun, 26 Oct 2025 09:27:28 +1100
Subject: [PATCH 220/322] Update GitHub Actions versions and zulu -> temurin
 JDK

---
 .github/workflows/maven.yml | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml
index 3b97a0c6..ee5726ce 100644
--- a/.github/workflows/maven.yml
+++ b/.github/workflows/maven.yml
@@ -13,17 +13,17 @@ jobs:
 
     steps:
     - name: Check out Git repository
-      uses: actions/checkout@v3
+      uses: actions/checkout@v5
 
     - name: Set up Java and Maven
-      uses: actions/setup-java@v3
+      uses: actions/setup-java@v5
       with:
-        distribution: zulu
+        distribution: temurin
         java-version: 25
         cache: maven
 
     - name: Install Zig
-      uses: goto-bus-stop/setup-zig@v2
+      uses: mlugg/setup-zig@v2
 
     - name: Cross compile using Zig
       run: ./cross-compile.sh
@@ -56,12 +56,12 @@ jobs:
 
     steps:
       - name: Check out Git repository
-        uses: actions/checkout@v3
+        uses: actions/checkout@v5
 
       - name: Set up Java and Maven
-        uses: actions/setup-java@v3
+        uses: actions/setup-java@v5
         with:
-          distribution: zulu
+          distribution: temurin
           java-version: ${{ matrix.java }}
           cache: maven
 
@@ -89,12 +89,12 @@ jobs:
 
     steps:
     - name: Check out Git repository
-      uses: actions/checkout@v3
+      uses: actions/checkout@v5
 
     - name: Set up Java and Maven
-      uses: actions/setup-java@v3
+      uses: actions/setup-java@v5
       with:
-        distribution: zulu
+        distribution: temurin
         # Java version 8 required due to https://github.com/lmdbjava/lmdbjava/issues/116
         java-version: 8
         cache: maven
@@ -105,7 +105,7 @@ jobs:
         gpg-passphrase: MAVEN_GPG_PASSPHRASE
 
     - name: Install Zig
-      uses: goto-bus-stop/setup-zig@v2
+      uses: mlugg/setup-zig@v2
 
     - name: Cross compile using Zig
       run: ./cross-compile.sh

From 60f5f17b54416495447ad8ee98c529ac8554dcd5 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Sun, 26 Oct 2025 09:33:42 +1100
Subject: [PATCH 221/322] Switch GitHub Actions back to zulu (needed for Java
 8)

---
 .github/workflows/maven.yml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml
index ee5726ce..372c0c88 100644
--- a/.github/workflows/maven.yml
+++ b/.github/workflows/maven.yml
@@ -18,7 +18,7 @@ jobs:
     - name: Set up Java and Maven
       uses: actions/setup-java@v5
       with:
-        distribution: temurin
+        distribution: zulu
         java-version: 25
         cache: maven
 
@@ -61,7 +61,7 @@ jobs:
       - name: Set up Java and Maven
         uses: actions/setup-java@v5
         with:
-          distribution: temurin
+          distribution: zulu
           java-version: ${{ matrix.java }}
           cache: maven
 
@@ -94,7 +94,7 @@ jobs:
     - name: Set up Java and Maven
       uses: actions/setup-java@v5
       with:
-        distribution: temurin
+        distribution: zulu
         # Java version 8 required due to https://github.com/lmdbjava/lmdbjava/issues/116
         java-version: 8
         cache: maven

From d109ee43b9a7e88f744223e314d5dec717a1abee Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Sun, 26 Oct 2025 09:47:37 +1100
Subject: [PATCH 222/322] POM to use property interpolation and version plugin

---
 .gitignore      |   1 +
 CONTRIBUTING.md |   8 ++-
 pom.xml         | 126 +++++++++++++++++++++++++++++++++++-------------
 3 files changed, 100 insertions(+), 35 deletions(-)

diff --git a/.gitignore b/.gitignore
index 0c771329..f46b8b6f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -17,3 +17,4 @@ gpg-sign.json
 mvn-sync.json
 secrets.tar
 lmdb
+pom.xml.versionsBackup
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index c37bf055..09448c03 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -6,13 +6,19 @@ We welcome patches and pull requests to improve LmdbJava.
 This will run:
 
 * Tests
-* Initial Test Coverage
 * Source Code Formatting
 * License Header Management
 
 `mvn clean verify` is also run by CI, but it's quicker and easier to run
 before submitting.
 
+### Version Management
+
+Update all dependency and plugin versions:
+```bash
+mvn versions:update-properties
+```
+
 ### Releasing
 
 GitHub Actions will perform an official release whenever a developer executes
diff --git a/pom.xml b/pom.xml
index 12af842d..f2a44fa3 100644
--- a/pom.xml
+++ b/pom.xml
@@ -25,47 +25,80 @@
   <name>LmdbJava</name>
   <description>Low latency Java API for the ultra-fast, embedded Symas Lightning Database (LMDB)</description>
   <properties>
+    <!-- Agrona 1.23+ requires Java 17+ -->
+    <agrona.version>1.22.0</agrona.version>
+    <buildnumber-maven-plugin.version>3.2.1</buildnumber-maven-plugin.version>
+    <byteunits.version>0.9.1</byteunits.version>
+    <central-publishing-maven-plugin.version>0.9.0</central-publishing-maven-plugin.version>
+    <fmt-maven-plugin.version>2.29</fmt-maven-plugin.version>
+    <google-java-format.version>1.28.0</google-java-format.version>
+    <guava.version>33.5.0-jre</guava.version>
+    <hamcrest.version>2.2</hamcrest.version>
+    <jacoco-maven-plugin.version>0.8.14</jacoco-maven-plugin.version>
+    <jnr-constants.version>0.10.4</jnr-constants.version>
+    <jnr-ffi.version>2.2.18</jnr-ffi.version>
+    <junit.version>4.13.2</junit.version>
+    <license-maven-plugin.version>4.6</license-maven-plugin.version>
+    <maven-clean-plugin.version>3.5.0</maven-clean-plugin.version>
+    <maven-compiler-plugin.version>3.14.1</maven-compiler-plugin.version>
+    <maven-dependency-plugin.version>3.9.0</maven-dependency-plugin.version>
+    <maven-deploy-plugin.version>3.1.4</maven-deploy-plugin.version>
+    <maven-enforcer-plugin.version>3.6.2</maven-enforcer-plugin.version>
+    <maven-gpg-plugin.version>3.2.7</maven-gpg-plugin.version>
+    <maven-install-plugin.version>3.1.4</maven-install-plugin.version>
+    <maven-jar-plugin.version>3.4.2</maven-jar-plugin.version>
+    <maven-javadoc-plugin.version>3.12.0</maven-javadoc-plugin.version>
+    <maven-release-plugin.version>3.1.1</maven-release-plugin.version>
+    <maven-resources-plugin.version>3.3.1</maven-resources-plugin.version>
+    <maven-scm-provider-jgit.version>2.2.1</maven-scm-provider-jgit.version>
+    <maven-site-plugin.version>3.21.0</maven-site-plugin.version>
+    <maven-source-plugin.version>3.3.1</maven-source-plugin.version>
+    <maven-surefire-plugin.version>3.5.4</maven-surefire-plugin.version>
     <maven.build.timestamp.format>yyyy-MM-dd'T'HH:mm:ss'Z'</maven.build.timestamp.format>
     <maven.compiler.source>1.8</maven.compiler.source>
     <maven.compiler.target>1.8</maven.compiler.target>
     <maven.enforcer.java>1.8</maven.enforcer.java>
     <maven.enforcer.mvn>3.5.4</maven.enforcer.mvn>
+    <mockito.version>4.11.0</mockito.version>
+    <netty-buffer.version>4.2.7.Final</netty-buffer.version>
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    <sortpom-maven-plugin.version>4.0.0</sortpom-maven-plugin.version>
     <trimStackTrace>false</trimStackTrace>
+    <versions-maven-plugin.version>2.19.1</versions-maven-plugin.version>
   </properties>
   <dependencies>
     <dependency>
       <groupId>com.github.jnr</groupId>
       <artifactId>jnr-constants</artifactId>
-      <version>0.10.4</version>
+      <version>${jnr-constants.version}</version>
     </dependency>
     <dependency>
       <groupId>com.github.jnr</groupId>
       <artifactId>jnr-ffi</artifactId>
-      <version>2.2.17</version>
+      <version>${jnr-ffi.version}</version>
     </dependency>
     <dependency>
       <groupId>com.google.guava</groupId>
       <artifactId>guava</artifactId>
-      <version>33.4.0-jre</version>
+      <version>${guava.version}</version>
       <scope>test</scope>
     </dependency>
     <dependency>
       <groupId>com.jakewharton.byteunits</groupId>
       <artifactId>byteunits</artifactId>
-      <version>0.9.1</version>
+      <version>${byteunits.version}</version>
       <scope>test</scope>
     </dependency>
     <dependency>
       <groupId>io.netty</groupId>
       <artifactId>netty-buffer</artifactId>
-      <version>4.1.118.Final</version>
+      <version>${netty-buffer.version}</version>
       <optional>true</optional>
     </dependency>
     <dependency>
       <groupId>junit</groupId>
       <artifactId>junit</artifactId>
-      <version>4.13.2</version>
+      <version>${junit.version}</version>
       <scope>test</scope>
       <exclusions>
         <exclusion>
@@ -77,20 +110,19 @@
     <dependency>
       <groupId>org.agrona</groupId>
       <artifactId>agrona</artifactId>
-      <!-- 1.23.0 requires Java 17+ -->
-      <version>1.22.0</version>
+      <version>${agrona.version}</version>
       <optional>true</optional>
     </dependency>
     <dependency>
       <groupId>org.hamcrest</groupId>
       <artifactId>hamcrest</artifactId>
-      <version>2.2</version>
+      <version>${hamcrest.version}</version>
       <scope>test</scope>
     </dependency>
     <dependency>
       <groupId>org.mockito</groupId>
       <artifactId>mockito-inline</artifactId>
-      <version>4.11.0</version>
+      <version>${mockito.version}</version>
       <scope>test</scope>
     </dependency>
   </dependencies>
@@ -99,7 +131,7 @@
       <plugin>
         <groupId>com.mycila</groupId>
         <artifactId>license-maven-plugin</artifactId>
-        <version>4.6</version>
+        <version>${license-maven-plugin.version}</version>
         <configuration>
           <licenseSets>
             <licenseSet>
@@ -118,7 +150,7 @@
           <dependency>
             <groupId>com.mycila</groupId>
             <artifactId>license-maven-plugin-git</artifactId>
-            <version>4.6</version>
+            <version>${license-maven-plugin.version}</version>
           </dependency>
         </dependencies>
         <executions>
@@ -137,7 +169,7 @@
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-clean-plugin</artifactId>
-        <version>3.4.0</version>
+        <version>${maven-clean-plugin.version}</version>
         <configuration>
           <failOnError>false</failOnError>
         </configuration>
@@ -145,12 +177,12 @@
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-compiler-plugin</artifactId>
-        <version>3.13.0</version>
+        <version>${maven-compiler-plugin.version}</version>
       </plugin>
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-dependency-plugin</artifactId>
-        <version>3.8.1</version>
+        <version>${maven-dependency-plugin.version}</version>
         <executions>
           <execution>
             <goals>
@@ -171,12 +203,12 @@
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-deploy-plugin</artifactId>
-        <version>3.1.3</version>
+        <version>${maven-deploy-plugin.version}</version>
       </plugin>
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-enforcer-plugin</artifactId>
-        <version>3.5.0</version>
+        <version>${maven-enforcer-plugin.version}</version>
         <executions>
           <execution>
             <id>config-enforcer</id>
@@ -206,12 +238,12 @@
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-install-plugin</artifactId>
-        <version>3.1.3</version>
+        <version>${maven-install-plugin.version}</version>
       </plugin>
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-jar-plugin</artifactId>
-        <version>3.4.2</version>
+        <version>${maven-jar-plugin.version}</version>
         <configuration>
           <archive>
             <manifest>
@@ -226,7 +258,7 @@
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-javadoc-plugin</artifactId>
-        <version>3.11.1</version>
+        <version>${maven-javadoc-plugin.version}</version>
         <executions>
           <execution>
             <id>attach-javadocs</id>
@@ -239,7 +271,7 @@
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-release-plugin</artifactId>
-        <version>3.1.1</version>
+        <version>${maven-release-plugin.version}</version>
         <configuration>
           <completionGoals>clean</completionGoals>
           <preparationGoals>clean</preparationGoals>
@@ -250,12 +282,12 @@
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-resources-plugin</artifactId>
-        <version>3.3.1</version>
+        <version>${maven-resources-plugin.version}</version>
       </plugin>
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-site-plugin</artifactId>
-        <version>3.21.0</version>
+        <version>${maven-site-plugin.version}</version>
         <configuration>
           <skipDeploy>true</skipDeploy>
         </configuration>
@@ -263,7 +295,7 @@
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-source-plugin</artifactId>
-        <version>3.3.1</version>
+        <version>${maven-source-plugin.version}</version>
         <executions>
           <execution>
             <id>attach-sources</id>
@@ -276,12 +308,12 @@
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-surefire-plugin</artifactId>
-        <version>3.5.2</version>
+        <version>${maven-surefire-plugin.version}</version>
       </plugin>
       <plugin>
         <groupId>org.codehaus.mojo</groupId>
         <artifactId>buildnumber-maven-plugin</artifactId>
-        <version>3.2.1</version>
+        <version>${buildnumber-maven-plugin.version}</version>
         <configuration>
           <doCheck>false</doCheck>
           <doUpdate>false</doUpdate>
@@ -296,7 +328,7 @@
           <dependency>
             <groupId>org.apache.maven.scm</groupId>
             <artifactId>maven-scm-provider-jgit</artifactId>
-            <version>2.1.0</version>
+            <version>${maven-scm-provider-jgit.version}</version>
           </dependency>
         </dependencies>
         <executions>
@@ -311,12 +343,38 @@
       <plugin>
         <groupId>org.codehaus.mojo</groupId>
         <artifactId>versions-maven-plugin</artifactId>
-        <version>2.18.0</version>
+        <version>${versions-maven-plugin.version}</version>
+        <configuration>
+          <allowSnapshots>false</allowSnapshots>
+          <allowDowngrade>false</allowDowngrade>
+          <allowMajorUpdates>false</allowMajorUpdates>
+          <excludeProperties>agrona.version</excludeProperties>
+          <ruleSet>
+            <ignoreVersions>
+              <ignoreVersion>
+                <type>regex</type>
+                <version>.*-alpha.*</version>
+              </ignoreVersion>
+              <ignoreVersion>
+                <type>regex</type>
+                <version>.*-beta.*</version>
+              </ignoreVersion>
+              <ignoreVersion>
+                <type>regex</type>
+                <version>.*-M.*</version>
+              </ignoreVersion>
+              <ignoreVersion>
+                <type>regex</type>
+                <version>.*-RC.*</version>
+              </ignoreVersion>
+            </ignoreVersions>
+          </ruleSet>
+        </configuration>
       </plugin>
       <plugin>
         <groupId>org.jacoco</groupId>
         <artifactId>jacoco-maven-plugin</artifactId>
-        <version>0.8.14</version>
+        <version>${jacoco-maven-plugin.version}</version>
         <executions>
           <execution>
             <id>config-jacoco-prepare-agent</id>
@@ -408,7 +466,7 @@
           <plugin>
             <groupId>com.github.ekryd.sortpom</groupId>
             <artifactId>sortpom-maven-plugin</artifactId>
-            <version>4.0.0</version>
+            <version>${sortpom-maven-plugin.version}</version>
             <configuration>
               <pomFile>${project.basedir}/pom.xml</pomFile>
               <encoding>${project.build.sourceEncoding}</encoding>
@@ -435,12 +493,12 @@
             <!-- https://github.com/spotify/fmt-maven-plugin/issues/210 -->
             <groupId>com.spotify.fmt</groupId>
             <artifactId>fmt-maven-plugin</artifactId>
-            <version>2.29</version>
+            <version>${fmt-maven-plugin.version}</version>
             <dependencies>
               <dependency>
                 <groupId>com.google.googlejavaformat</groupId>
                 <artifactId>google-java-format</artifactId>
-                <version>1.28.0</version>
+                <version>${google-java-format.version}</version>
               </dependency>
             </dependencies>
           </plugin>
@@ -454,7 +512,7 @@
           <plugin>
             <groupId>org.apache.maven.plugins</groupId>
             <artifactId>maven-gpg-plugin</artifactId>
-            <version>3.2.7</version>
+            <version>${maven-gpg-plugin.version}</version>
             <executions>
               <execution>
                 <id>sign-artifacts</id>
@@ -474,7 +532,7 @@
           <plugin>
             <groupId>org.sonatype.central</groupId>
             <artifactId>central-publishing-maven-plugin</artifactId>
-            <version>0.9.0</version>
+            <version>${central-publishing-maven-plugin.version}</version>
             <extensions>true</extensions>
             <configuration>
               <publishingServerId>central</publishingServerId>

From 0b741e8a72febcf37b1d3debc2a91aa3b2782ed9 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Sun, 26 Oct 2025 10:01:55 +1100
Subject: [PATCH 223/322] Pin Netty at 4.1.118.Final for now

---
 pom.xml | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/pom.xml b/pom.xml
index f2a44fa3..d59d1a1d 100644
--- a/pom.xml
+++ b/pom.xml
@@ -60,7 +60,8 @@
     <maven.enforcer.java>1.8</maven.enforcer.java>
     <maven.enforcer.mvn>3.5.4</maven.enforcer.mvn>
     <mockito.version>4.11.0</mockito.version>
-    <netty-buffer.version>4.2.7.Final</netty-buffer.version>
+    <!-- Netty pinned at 4.1.118.Final until further testing -->
+    <netty-buffer.version>4.1.118.Final</netty-buffer.version>
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     <sortpom-maven-plugin.version>4.0.0</sortpom-maven-plugin.version>
     <trimStackTrace>false</trimStackTrace>
@@ -348,7 +349,7 @@
           <allowSnapshots>false</allowSnapshots>
           <allowDowngrade>false</allowDowngrade>
           <allowMajorUpdates>false</allowMajorUpdates>
-          <excludeProperties>agrona.version</excludeProperties>
+          <excludeProperties>agrona.version,netty-buffer.version</excludeProperties>
           <ruleSet>
             <ignoreVersions>
               <ignoreVersion>

From 58a489f84ad5651caacc79c2019372535f085343 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Sun, 26 Oct 2025 20:12:13 +0000
Subject: [PATCH 224/322] Fix accidental change to import order

---
 src/main/java/org/lmdbjava/Dbi.java | 21 ++++++++++-----------
 1 file changed, 10 insertions(+), 11 deletions(-)

diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index f4d061f7..6b6eb266 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -15,17 +15,6 @@
  */
 package org.lmdbjava;
 
-import jnr.ffi.Pointer;
-import jnr.ffi.byref.IntByReference;
-import jnr.ffi.byref.PointerByReference;
-import org.lmdbjava.Library.ComparatorCallback;
-import org.lmdbjava.Library.MDB_stat;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Comparator;
-import java.util.List;
-
 import static java.util.Objects.requireNonNull;
 import static jnr.ffi.Memory.allocateDirect;
 import static jnr.ffi.NativeType.ADDRESS;
@@ -42,6 +31,16 @@
 import static org.lmdbjava.PutFlags.MDB_RESERVE;
 import static org.lmdbjava.ResultCodeMapper.checkRc;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+import jnr.ffi.Pointer;
+import jnr.ffi.byref.IntByReference;
+import jnr.ffi.byref.PointerByReference;
+import org.lmdbjava.Library.ComparatorCallback;
+import org.lmdbjava.Library.MDB_stat;
+
 /**
  * LMDB Database.
  *

From bfbf223031191e0bb13c7c32a58930c85e880f5c Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Mon, 27 Oct 2025 15:23:46 +0000
Subject: [PATCH 225/322] Add FlagSet, DbiFlagSet, PutFlagSet

Refactor DbiBuilder and Dbi ctor to use DbiFlagSet.
---
 src/main/java/org/lmdbjava/Dbi.java           |  29 ++-
 src/main/java/org/lmdbjava/DbiBuilder.java    |  42 ++--
 src/main/java/org/lmdbjava/DbiFlagSet.java    |  32 +++
 src/main/java/org/lmdbjava/Env.java           |   2 +-
 src/main/java/org/lmdbjava/FlagSet.java       | 192 ++++++++++++++++++
 src/main/java/org/lmdbjava/MaskedFlag.java    |  38 +++-
 src/main/java/org/lmdbjava/PutFlagSet.java    |  32 +++
 .../java/org/lmdbjava/DbiFlagSetTest.java     | 101 +++++++++
 .../java/org/lmdbjava/PutFlagSetTest.java     | 101 +++++++++
 9 files changed, 531 insertions(+), 38 deletions(-)
 create mode 100644 src/main/java/org/lmdbjava/DbiFlagSet.java
 create mode 100644 src/main/java/org/lmdbjava/FlagSet.java
 create mode 100644 src/main/java/org/lmdbjava/PutFlagSet.java
 create mode 100644 src/test/java/org/lmdbjava/DbiFlagSetTest.java
 create mode 100644 src/test/java/org/lmdbjava/PutFlagSetTest.java

diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index ba20c1a4..17fa4c46 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -31,6 +31,7 @@
 import static org.lmdbjava.PutFlags.MDB_RESERVE;
 import static org.lmdbjava.ResultCodeMapper.checkRc;
 
+import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Comparator;
@@ -55,6 +56,7 @@ public final class Dbi<T> {
   private final byte[] name;
   private final Pointer ptr;
   private final BufferProxy<T> proxy;
+  private final DbiFlagSet dbiFlagSet;
 
   Dbi(
       final Env<T> env,
@@ -63,7 +65,7 @@ public final class Dbi<T> {
       final Comparator<T> comparator,
       final boolean nativeCb,
       final BufferProxy<T> proxy,
-      final DbiFlags... flags) {
+      final DbiFlagSet dbiFlagSet) {
     if (SHOULD_CHECK) {
       requireNonNull(txn);
       txn.checkReady();
@@ -72,9 +74,9 @@ public final class Dbi<T> {
     this.name = name == null ? null : Arrays.copyOf(name, name.length);
     this.proxy = proxy;
     this.comparator = comparator;
-    final int flagsMask = mask(flags);
+    this.dbiFlagSet = dbiFlagSet;
     final Pointer dbiPtr = allocateDirect(RUNTIME, ADDRESS);
-    checkRc(LIB.mdb_dbi_open(txn.pointer(), name, flagsMask, dbiPtr));
+    checkRc(LIB.mdb_dbi_open(txn.pointer(), name, dbiFlagSet.getMask(), dbiPtr));
     ptr = dbiPtr.getPointer(0);
     if (nativeCb) {
       requireNonNull(comparator, "comparator cannot be null if nativeCb is set");
@@ -291,6 +293,7 @@ public CursorIterable<T> iterate(final Txn<T> txn, final KeyRange<T> range) {
    * @return the list of flags this Dbi was created with
    */
   public List<DbiFlags> listFlags(final Txn<T> txn) {
+    // TODO we could just return what is in dbiFlagSet, rather than hitting LMDB.
     if (SHOULD_CHECK) {
       env.checkNotClosed();
     }
@@ -457,6 +460,26 @@ private void clean() {
     cleaned = true;
   }
 
+  private String getNameAsString() {
+    if (name == null) {
+      return "";
+    } else {
+      try {
+        return new String(name, StandardCharsets.UTF_8);
+      } catch (Exception e) {
+        return "?";
+      }
+    }
+  }
+
+  @Override
+  public String toString() {
+    return "Dbi{" +
+            "name=" + getNameAsString() +
+            ", dbiFlagSet=" + dbiFlagSet +
+            '}';
+  }
+
   /** The specified DBI was changed unexpectedly. */
   public static final class BadDbiException extends LmdbNativeException {
 
diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
index 5deb2e38..1803d142 100644
--- a/src/main/java/org/lmdbjava/DbiBuilder.java
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -19,9 +19,7 @@
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Comparator;
-import java.util.EnumSet;
 import java.util.Objects;
-import java.util.Set;
 
 /**
  * Staged builder for building a {@link Dbi}
@@ -224,19 +222,13 @@ public DbiBuilderStage3<T> withIteratorComparator(final Comparator<T> comparator
   public static class DbiBuilderStage3<T> {
 
     private final DbiBuilderStage2<T> dbiBuilderStage2;
-    private Set<DbiFlags> dbiFlags = null;
+    private final FlagSet.Builder<DbiFlags, DbiFlagSet> flagSetBuilder = DbiFlagSet.builder();
     private Txn<T> txn = null;
 
     private DbiBuilderStage3(DbiBuilderStage2<T> dbiBuilderStage2) {
       this.dbiBuilderStage2 = dbiBuilderStage2;
     }
 
-    private void initDbiFlags() {
-      if (dbiFlags == null) {
-        dbiFlags = EnumSet.noneOf(DbiFlags.class);
-      }
-    }
-
     /**
      * <p>
      * Apply all the dbi flags supplied in dbiFlags.
@@ -244,15 +236,14 @@ private void initDbiFlags() {
      * <p>
      * Replaces any flags applies in previous calls to
      * {@link DbiBuilderStage3#withDbiFlags(Collection)}, {@link DbiBuilderStage3#withDbiFlags(DbiFlags...)}
-     * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
+     * or {@link DbiBuilderStage3#setDbiFlag(DbiFlags)}.
      * </p>
      *
      * @param dbiFlags to open the database with.
      */
     public DbiBuilderStage3<T> withDbiFlags(final Collection<DbiFlags> dbiFlags) {
-      initDbiFlags();
       if (dbiFlags != null) {
-        this.dbiFlags.stream()
+        dbiFlags.stream()
                 .filter(Objects::nonNull)
                 .forEach(dbiFlags::add);
       }
@@ -265,36 +256,35 @@ public DbiBuilderStage3<T> withDbiFlags(final Collection<DbiFlags> dbiFlags) {
      * </p>
      * <p>
      * Replaces any flags applies in previous calls to
-     * {@link DbiBuilderStage3#withDbiFlags(Collection)}, {@link DbiBuilderStage3#withDbiFlags(DbiFlags...)}
-     * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
+     * {@link DbiBuilderStage3#withDbiFlags(Collection)},
+     * {@link DbiBuilderStage3#withDbiFlags(DbiFlags...)}
+     * or {@link DbiBuilderStage3#setDbiFlag(DbiFlags)}.
      * </p>
      *
      * @param dbiFlags to open the database with.
      *                 A null array is a no-op. Null items are ignored.
      */
     public DbiBuilderStage3<T> withDbiFlags(final DbiFlags... dbiFlags) {
-      initDbiFlags();
+      flagSetBuilder.clear();
       if (dbiFlags != null) {
         Arrays.stream(dbiFlags)
             .filter(Objects::nonNull)
-            .forEach(this.dbiFlags::add);
+            .forEach(this.flagSetBuilder::setFlag);
       }
       return this;
     }
 
     /**
      * Adds dbiFlag to those flags already added to this builder by
-     * {@link DbiBuilderStage3#withDbiFlags(DbiFlags...)}, {@link DbiBuilderStage3#withDbiFlags(Collection)}
-     * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
+     * {@link DbiBuilderStage3#withDbiFlags(DbiFlags...)},
+     * {@link DbiBuilderStage3#withDbiFlags(Collection)}
+     * or {@link DbiBuilderStage3#setDbiFlag(DbiFlags)}.
      *
      * @param dbiFlag to open the database with. A null value is a no-op.
      * @return this builder instance.
      */
-    public DbiBuilderStage3<T> addDbiFlag(final DbiFlags dbiFlag) {
-      initDbiFlags();
-      if (dbiFlags != null) {
-        this.dbiFlags.add(dbiFlag);
-      }
+    public DbiBuilderStage3<T> setDbiFlag(final DbiFlags dbiFlag) {
+      this.flagSetBuilder.setFlag(dbiFlag);
       return this;
     }
 
@@ -341,9 +331,7 @@ private Txn<T> getTxn(final DbiBuilder<T> dbiBuilder) {
 
     private Dbi<T> open(final Txn<T> txn,
                         final DbiBuilder<T> dbiBuilder) {
-      final DbiFlags[] dbiFlagsArr = dbiFlags != null && !dbiFlags.isEmpty()
-          ? this.dbiFlags.toArray(new DbiFlags[0])
-          : null;
+      final DbiFlagSet dbiFlagSet = flagSetBuilder.build();
 
       return new Dbi<>(
           dbiBuilder.env,
@@ -352,7 +340,7 @@ private Dbi<T> open(final Txn<T> txn,
           dbiBuilderStage2.comparator,
           dbiBuilderStage2.useNativeCallback,
           dbiBuilder.proxy,
-          dbiFlagsArr);
+          dbiFlagSet);
     }
   }
 }
diff --git a/src/main/java/org/lmdbjava/DbiFlagSet.java b/src/main/java/org/lmdbjava/DbiFlagSet.java
new file mode 100644
index 00000000..2c6c5ac7
--- /dev/null
+++ b/src/main/java/org/lmdbjava/DbiFlagSet.java
@@ -0,0 +1,32 @@
+package org.lmdbjava;
+
+import java.util.EnumSet;
+import java.util.Objects;
+
+public class DbiFlagSet extends FlagSet<DbiFlags> {
+
+    public static final DbiFlagSet EMPTY = new DbiFlagSet(EnumSet.noneOf(DbiFlags.class));
+
+    private DbiFlagSet(final EnumSet<DbiFlags> flags) {
+        super(flags);
+    }
+
+    public static DbiFlagSet empty() {
+        return EMPTY;
+    }
+
+    public static DbiFlagSet of(final DbiFlags putFlag) {
+        Objects.requireNonNull(putFlag);
+        return new DbiFlagSet(EnumSet.of(putFlag));
+    }
+
+    public static DbiFlagSet of(final DbiFlags... DbiFlags) {
+        return builder()
+                .withFlags(DbiFlags)
+                .build();
+    }
+
+    public static Builder<DbiFlags, DbiFlagSet> builder() {
+        return new Builder<>(DbiFlags.class, DbiFlagSet::new);
+    }
+}
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index d7c7b269..5de0a7fd 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -405,7 +405,7 @@ public Dbi<T> openDbi(
       final Comparator<T> comparator,
       final boolean nativeCb,
       final DbiFlags... flags) {
-    return new Dbi<>(this, txn, name, comparator, nativeCb, proxy, flags);
+    return new Dbi<>(this, txn, name, comparator, nativeCb, proxy, DbiFlagSet.of(flags));
   }
 
   /**
diff --git a/src/main/java/org/lmdbjava/FlagSet.java b/src/main/java/org/lmdbjava/FlagSet.java
new file mode 100644
index 00000000..21132f8c
--- /dev/null
+++ b/src/main/java/org/lmdbjava/FlagSet.java
@@ -0,0 +1,192 @@
+package org.lmdbjava;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.EnumSet;
+import java.util.Iterator;
+import java.util.Objects;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+/**
+ * Encapsulates an immutable set of flags and the associated bit mask for the flags in the set.
+ *
+ * @param <T>
+ */
+public abstract class FlagSet<T extends Enum<T> & MaskedFlag> implements Iterable<T> {
+
+  private final Set<T> flags;
+  private final int mask;
+
+  protected FlagSet(final EnumSet<T> flags) {
+    Objects.requireNonNull(flags);
+    this.mask = MaskedFlag.mask(flags);
+    this.flags = Collections.unmodifiableSet(Objects.requireNonNull(flags));
+  }
+
+  /**
+   * @return THe combined bit mask for all flags in the set.
+   */
+  int getMask() {
+    return mask;
+  }
+
+  /**
+   * @return All flags in the set.
+   */
+  public Set<T> getFlags() {
+    return flags;
+  }
+
+  /**
+   * @return True if flag has been set, i.e. is contained in this set.
+   */
+  public boolean isSet(final T flag) {
+    return flag != null
+        && flags.contains(flag);
+  }
+
+  /**
+   * @return The number of flags in this set.
+   */
+  public int size() {
+    return flags.size();
+  }
+
+  /**
+   * @return True if this set is empty.
+   */
+  public boolean isEmpty() {
+    return flags.isEmpty();
+  }
+
+  /**
+   * @return The {@link Iterator} for this set.
+   */
+  @Override
+  public Iterator<T> iterator() {
+    return flags.iterator();
+  }
+
+  @Override
+  public boolean equals(Object object) {
+    if (this == object) return true;
+    if (object == null || getClass() != object.getClass()) return false;
+    FlagSet<?> flagSet = (FlagSet<?>) object;
+    return mask == flagSet.mask && Objects.equals(flags, flagSet.flags);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(flags, mask);
+  }
+
+  @Override
+  public String toString() {
+    final String flagsStr = flags.stream()
+        .sorted(Comparator.comparing(MaskedFlag::getMask))
+        .map(MaskedFlag::name)
+        .collect(Collectors.joining(", "));
+    return "FlagSet{" +
+        "flags=[" + flagsStr +
+        "], mask=" + mask +
+        '}';
+  }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  /**
+   * A builder for creating a {@link FlagSet}.
+   *
+   * @param <E> The type of flag to be held in the {@link FlagSet}
+   * @param <S> The type of the {@link FlagSet} implementation.
+   */
+  public static class Builder<E extends Enum<E> & MaskedFlag, S extends FlagSet<E>> {
+
+    final Class<E> type;
+    final EnumSet<E> enumSet;
+    final Function<EnumSet<E>, S> constructor;
+
+    protected Builder(final Class<E> type,
+                      final Function<EnumSet<E>, S> constructor) {
+      this.type = type;
+      this.enumSet = EnumSet.noneOf(type);
+      this.constructor = constructor;
+    }
+
+    /**
+     * Replaces any flags already set in the builder with the contents of the passed flags {@link Collection}
+     *
+     * @param flags The flags to set in the builder.
+     * @return this builder instance.
+     */
+    public Builder<E, S> withFlags(final Collection<E> flags) {
+      enumSet.clear();
+      if (flags != null) {
+        for (E flag : flags) {
+          if (flag != null) {
+            enumSet.add(flag);
+          }
+        }
+      }
+      return this;
+    }
+
+    /**
+     * @param flags The flags to set in the builder.
+     * @return this builder instance.
+     */
+    @SafeVarargs
+    public final Builder<E, S> withFlags(final E... flags) {
+      enumSet.clear();
+      if (flags != null) {
+        for (E flag : flags) {
+          if (flag != null) {
+            if (!type.equals(flag.getClass())) {
+              throw new IllegalArgumentException("Unexpected type " + flag.getClass());
+            }
+            enumSet.add(flag);
+          }
+        }
+      }
+      return this;
+    }
+
+    /**
+     * Sets a single flag in the builder.
+     *
+     * @param flag The flag to set in the builder.
+     * @return this builder instance.
+     */
+    public Builder<E, S> setFlag(final E flag) {
+      if (flag != null) {
+        enumSet.add(flag);
+      }
+      return this;
+    }
+
+    /**
+     * Clears any flags already set in this {@link Builder}
+     *
+     * @return this builder instance.
+     */
+    public Builder<E, S> clear() {
+      enumSet.clear();
+      return this;
+    }
+
+    /**
+     * Build the {@link DbiFlagSet}
+     *
+     * @return A
+     */
+    public S build() {
+      return constructor.apply(enumSet);
+    }
+  }
+}
+
diff --git a/src/main/java/org/lmdbjava/MaskedFlag.java b/src/main/java/org/lmdbjava/MaskedFlag.java
index 4dc47b20..f2f08274 100644
--- a/src/main/java/org/lmdbjava/MaskedFlag.java
+++ b/src/main/java/org/lmdbjava/MaskedFlag.java
@@ -17,9 +17,13 @@
 
 import static java.util.Objects.requireNonNull;
 
+import java.util.Collection;
+
 /** Indicates an enum that can provide integers for each of its values. */
 public interface MaskedFlag {
 
+  int EMPTY_MASK = 0;
+
   /**
    * Obtains the integer value for this enum which can be included in a mask.
    *
@@ -27,6 +31,11 @@ public interface MaskedFlag {
    */
   int getMask();
 
+  /**
+   * @return The name of the flag.
+   */
+  String name();
+
   /**
    * Fetch the integer mask for all presented flags.
    *
@@ -37,17 +46,32 @@ public interface MaskedFlag {
   @SafeVarargs
   static <M extends MaskedFlag> int mask(final M... flags) {
     if (flags == null || flags.length == 0) {
-      return 0;
+      return EMPTY_MASK;
+    } else {
+      int result = EMPTY_MASK;
+      for (MaskedFlag flag : flags) {
+        if (flag == null) {
+          continue;
+        }
+        result |= flag.getMask();
+      }
+      return result;
     }
+  }
 
-    int result = 0;
-    for (MaskedFlag flag : flags) {
-      if (flag == null) {
-        continue;
+  static <M extends MaskedFlag> int mask(final Collection<M> flags) {
+    if (flags == null || flags.isEmpty()) {
+      return EMPTY_MASK;
+    } else {
+      int result = EMPTY_MASK;
+      for (MaskedFlag flag : flags) {
+        if (flag == null) {
+          continue;
+        }
+        result |= flag.getMask();
       }
-      result |= flag.getMask();
+      return result;
     }
-    return result;
   }
 
   /**
diff --git a/src/main/java/org/lmdbjava/PutFlagSet.java b/src/main/java/org/lmdbjava/PutFlagSet.java
new file mode 100644
index 00000000..290f9729
--- /dev/null
+++ b/src/main/java/org/lmdbjava/PutFlagSet.java
@@ -0,0 +1,32 @@
+package org.lmdbjava;
+
+import java.util.EnumSet;
+import java.util.Objects;
+
+public class PutFlagSet extends FlagSet<PutFlags> {
+
+    public static final PutFlagSet EMPTY = new PutFlagSet(EnumSet.noneOf(PutFlags.class));
+
+    private PutFlagSet(final EnumSet<PutFlags> flags) {
+        super(flags);
+    }
+
+    public static PutFlagSet empty() {
+        return EMPTY;
+    }
+
+    public static PutFlagSet of(final PutFlags putFlag) {
+        Objects.requireNonNull(putFlag);
+        return new org.lmdbjava.PutFlagSet(EnumSet.of(putFlag));
+    }
+
+    public static PutFlagSet of(final PutFlags... putFlags) {
+        return builder()
+                .withFlags(putFlags)
+                .build();
+    }
+
+    public static Builder<PutFlags, PutFlagSet> builder() {
+        return new Builder<>(PutFlags.class, PutFlagSet::new);
+    }
+}
diff --git a/src/test/java/org/lmdbjava/DbiFlagSetTest.java b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
new file mode 100644
index 00000000..cfbda600
--- /dev/null
+++ b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
@@ -0,0 +1,101 @@
+package org.lmdbjava;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import org.junit.Test;
+
+public class DbiFlagSetTest {
+
+    @Test
+    public void testEmpty() {
+        final DbiFlagSet putFlagSet = DbiFlagSet.empty();
+        assertThat(
+                putFlagSet.getMask(),
+                is(0));
+        assertThat(
+                putFlagSet.size(),
+                is(0));
+        assertThat(
+                putFlagSet.isEmpty(),
+                is(true));
+        assertThat(
+                putFlagSet.isSet(DbiFlags.MDB_REVERSEDUP),
+                is(false));
+    }
+
+    @Test
+    public void testOf() {
+        final DbiFlags putFlag = DbiFlags.MDB_CREATE;
+        final DbiFlagSet putFlagSet = DbiFlagSet.of(putFlag);
+        assertThat(
+                putFlagSet.getMask(),
+                is(MaskedFlag.mask(putFlag)));
+        assertThat(
+                putFlagSet.size(),
+                is(1));
+        assertThat(
+                putFlagSet.isSet(DbiFlags.MDB_REVERSEDUP),
+                is(false));
+        for (DbiFlags flag : putFlagSet) {
+            assertThat(
+                    putFlagSet.isSet(flag),
+                    is(true));
+        }
+    }
+
+    @Test
+    public void testOf2() {
+        final DbiFlags putFlag1 = DbiFlags.MDB_CREATE;
+        final DbiFlags putFlag2 = DbiFlags.MDB_INTEGERKEY;
+        final DbiFlagSet putFlagSet = DbiFlagSet.of(putFlag1, putFlag2);
+        assertThat(
+                putFlagSet.getMask(),
+                is(MaskedFlag.mask(putFlag1, putFlag2)));
+        assertThat(
+                putFlagSet.size(),
+                is(2));
+        assertThat(
+                putFlagSet.isSet(DbiFlags.MDB_REVERSEDUP),
+                is(false));
+        for (DbiFlags flag : putFlagSet) {
+            assertThat(
+                    putFlagSet.isSet(flag),
+                    is(true));
+        }
+    }
+
+    @Test
+    public void testBuilder() {
+        final DbiFlags putFlag1 = DbiFlags.MDB_CREATE;
+        final DbiFlags putFlag2 = DbiFlags.MDB_INTEGERKEY;
+        final DbiFlagSet putFlagSet = DbiFlagSet.builder()
+                .setFlag(putFlag1)
+                .setFlag(putFlag2)
+                .build();
+        assertThat(
+                putFlagSet.getMask(),
+                is(MaskedFlag.mask(putFlag1, putFlag2)));
+        assertThat(
+                putFlagSet.size(),
+                is(2));
+        assertThat(
+                putFlagSet.isSet(DbiFlags.MDB_REVERSEDUP),
+                is(false));
+        for (DbiFlags flag : putFlagSet) {
+            assertThat(
+                    putFlagSet.isSet(flag),
+                    is(true));
+        }
+        final DbiFlagSet putFlagSet2 = DbiFlagSet.builder()
+                .withFlags(putFlag1, putFlag2)
+                .build();
+        final DbiFlagSet putFlagSet3 = DbiFlagSet.builder()
+                .withFlags(new HashSet<>(Arrays.asList(putFlag1, putFlag2)))
+                .build();
+        assertThat(putFlagSet, is(putFlagSet2));
+        assertThat(putFlagSet, is(putFlagSet3));
+    }
+}
diff --git a/src/test/java/org/lmdbjava/PutFlagSetTest.java b/src/test/java/org/lmdbjava/PutFlagSetTest.java
new file mode 100644
index 00000000..4826f436
--- /dev/null
+++ b/src/test/java/org/lmdbjava/PutFlagSetTest.java
@@ -0,0 +1,101 @@
+package org.lmdbjava;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import org.junit.Test;
+
+public class PutFlagSetTest {
+
+    @Test
+    public void testEmpty() {
+        final PutFlagSet putFlagSet = PutFlagSet.empty();
+        assertThat(
+                putFlagSet.getMask(),
+                is(0));
+        assertThat(
+                putFlagSet.size(),
+                is(0));
+        assertThat(
+                putFlagSet.isEmpty(),
+                is(true));
+        assertThat(
+                putFlagSet.isSet(PutFlags.MDB_MULTIPLE),
+                is(false));
+    }
+
+    @Test
+    public void testOf() {
+        final PutFlags putFlag = PutFlags.MDB_APPEND;
+        final PutFlagSet putFlagSet = PutFlagSet.of(putFlag);
+        assertThat(
+                putFlagSet.getMask(),
+                is(MaskedFlag.mask(putFlag)));
+        assertThat(
+                putFlagSet.size(),
+                is(1));
+        assertThat(
+                putFlagSet.isSet(PutFlags.MDB_MULTIPLE),
+                is(false));
+        for (PutFlags flag : putFlagSet) {
+            assertThat(
+                    putFlagSet.isSet(flag),
+                    is(true));
+        }
+    }
+
+    @Test
+    public void testOf2() {
+        final PutFlags putFlag1 = PutFlags.MDB_APPEND;
+        final PutFlags putFlag2 = PutFlags.MDB_NOOVERWRITE;
+        final PutFlagSet putFlagSet = PutFlagSet.of(putFlag1, putFlag2);
+        assertThat(
+                putFlagSet.getMask(),
+                is(MaskedFlag.mask(putFlag1, putFlag2)));
+        assertThat(
+                putFlagSet.size(),
+                is(2));
+        assertThat(
+                putFlagSet.isSet(PutFlags.MDB_MULTIPLE),
+                is(false));
+        for (PutFlags flag : putFlagSet) {
+            assertThat(
+                    putFlagSet.isSet(flag),
+                    is(true));
+        }
+    }
+
+    @Test
+    public void testBuilder() {
+        final PutFlags putFlag1 = PutFlags.MDB_APPEND;
+        final PutFlags putFlag2 = PutFlags.MDB_NOOVERWRITE;
+        final PutFlagSet putFlagSet = PutFlagSet.builder()
+                .setFlag(putFlag1)
+                .setFlag(putFlag2)
+                .build();
+        assertThat(
+                putFlagSet.getMask(),
+                is(MaskedFlag.mask(putFlag1, putFlag2)));
+        assertThat(
+                putFlagSet.size(),
+                is(2));
+        assertThat(
+                putFlagSet.isSet(PutFlags.MDB_MULTIPLE),
+                is(false));
+        for (PutFlags flag : putFlagSet) {
+            assertThat(
+                    putFlagSet.isSet(flag),
+                    is(true));
+        }
+        final PutFlagSet putFlagSet2 = PutFlagSet.builder()
+                .withFlags(putFlag1, putFlag2)
+                .build();
+        final PutFlagSet putFlagSet3 = PutFlagSet.builder()
+                .withFlags(new HashSet<>(Arrays.asList(putFlag1, putFlag2)))
+                .build();
+        assertThat(putFlagSet, is(putFlagSet2));
+        assertThat(putFlagSet, is(putFlagSet3));
+    }
+}

From 0f66aaf7021ebb25a295dc95ba56a8c78c6370d5 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Mon, 27 Oct 2025 15:27:35 +0000
Subject: [PATCH 226/322] Rename FlagSet to AbstractFlagSet

---
 .../{FlagSet.java => AbstractFlagSet.java}         | 14 +++++++-------
 src/main/java/org/lmdbjava/DbiBuilder.java         |  2 +-
 src/main/java/org/lmdbjava/DbiFlagSet.java         |  2 +-
 src/main/java/org/lmdbjava/PutFlagSet.java         |  2 +-
 4 files changed, 10 insertions(+), 10 deletions(-)
 rename src/main/java/org/lmdbjava/{FlagSet.java => AbstractFlagSet.java} (90%)

diff --git a/src/main/java/org/lmdbjava/FlagSet.java b/src/main/java/org/lmdbjava/AbstractFlagSet.java
similarity index 90%
rename from src/main/java/org/lmdbjava/FlagSet.java
rename to src/main/java/org/lmdbjava/AbstractFlagSet.java
index 21132f8c..3c21fb15 100644
--- a/src/main/java/org/lmdbjava/FlagSet.java
+++ b/src/main/java/org/lmdbjava/AbstractFlagSet.java
@@ -15,12 +15,12 @@
  *
  * @param <T>
  */
-public abstract class FlagSet<T extends Enum<T> & MaskedFlag> implements Iterable<T> {
+public abstract class AbstractFlagSet<T extends Enum<T> & MaskedFlag> implements Iterable<T> {
 
   private final Set<T> flags;
   private final int mask;
 
-  protected FlagSet(final EnumSet<T> flags) {
+  protected AbstractFlagSet(final EnumSet<T> flags) {
     Objects.requireNonNull(flags);
     this.mask = MaskedFlag.mask(flags);
     this.flags = Collections.unmodifiableSet(Objects.requireNonNull(flags));
@@ -74,7 +74,7 @@ public Iterator<T> iterator() {
   public boolean equals(Object object) {
     if (this == object) return true;
     if (object == null || getClass() != object.getClass()) return false;
-    FlagSet<?> flagSet = (FlagSet<?>) object;
+    AbstractFlagSet<?> flagSet = (AbstractFlagSet<?>) object;
     return mask == flagSet.mask && Objects.equals(flags, flagSet.flags);
   }
 
@@ -100,12 +100,12 @@ public String toString() {
 
 
   /**
-   * A builder for creating a {@link FlagSet}.
+   * A builder for creating a {@link AbstractFlagSet}.
    *
-   * @param <E> The type of flag to be held in the {@link FlagSet}
-   * @param <S> The type of the {@link FlagSet} implementation.
+   * @param <E> The type of flag to be held in the {@link AbstractFlagSet}
+   * @param <S> The type of the {@link AbstractFlagSet} implementation.
    */
-  public static class Builder<E extends Enum<E> & MaskedFlag, S extends FlagSet<E>> {
+  public static class Builder<E extends Enum<E> & MaskedFlag, S extends AbstractFlagSet<E>> {
 
     final Class<E> type;
     final EnumSet<E> enumSet;
diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
index 1803d142..7d05a51e 100644
--- a/src/main/java/org/lmdbjava/DbiBuilder.java
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -222,7 +222,7 @@ public DbiBuilderStage3<T> withIteratorComparator(final Comparator<T> comparator
   public static class DbiBuilderStage3<T> {
 
     private final DbiBuilderStage2<T> dbiBuilderStage2;
-    private final FlagSet.Builder<DbiFlags, DbiFlagSet> flagSetBuilder = DbiFlagSet.builder();
+    private final AbstractFlagSet.Builder<DbiFlags, DbiFlagSet> flagSetBuilder = DbiFlagSet.builder();
     private Txn<T> txn = null;
 
     private DbiBuilderStage3(DbiBuilderStage2<T> dbiBuilderStage2) {
diff --git a/src/main/java/org/lmdbjava/DbiFlagSet.java b/src/main/java/org/lmdbjava/DbiFlagSet.java
index 2c6c5ac7..cd1db934 100644
--- a/src/main/java/org/lmdbjava/DbiFlagSet.java
+++ b/src/main/java/org/lmdbjava/DbiFlagSet.java
@@ -3,7 +3,7 @@
 import java.util.EnumSet;
 import java.util.Objects;
 
-public class DbiFlagSet extends FlagSet<DbiFlags> {
+public class DbiFlagSet extends AbstractFlagSet<DbiFlags> {
 
     public static final DbiFlagSet EMPTY = new DbiFlagSet(EnumSet.noneOf(DbiFlags.class));
 
diff --git a/src/main/java/org/lmdbjava/PutFlagSet.java b/src/main/java/org/lmdbjava/PutFlagSet.java
index 290f9729..8820fe92 100644
--- a/src/main/java/org/lmdbjava/PutFlagSet.java
+++ b/src/main/java/org/lmdbjava/PutFlagSet.java
@@ -3,7 +3,7 @@
 import java.util.EnumSet;
 import java.util.Objects;
 
-public class PutFlagSet extends FlagSet<PutFlags> {
+public class PutFlagSet extends AbstractFlagSet<PutFlags> {
 
     public static final PutFlagSet EMPTY = new PutFlagSet(EnumSet.noneOf(PutFlags.class));
 

From aa000a1389755dc8f2de4152d149fa6da09b6d22 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Mon, 27 Oct 2025 21:19:27 +0000
Subject: [PATCH 227/322] Add remaining FlagSet impls

Replace Env#copy(File, CopyFlags...) with copy(File, CopyFlagSet).
As there is only one flag this should not be a breaking change.

Deprecate Env#txn(Txn, TxnFlags...) as there is now
Env#txn(Txn)
Env#txn(Txn, TxnFlags)
Env#txn(Txn, TxnFlagSet)
---
 .../java/org/lmdbjava/AbstractFlagSet.java    | 186 +++++++++++++++---
 src/main/java/org/lmdbjava/CopyFlagSet.java   |  59 ++++++
 src/main/java/org/lmdbjava/CopyFlags.java     |  30 ++-
 src/main/java/org/lmdbjava/DbiFlagSet.java    |  63 ++++--
 src/main/java/org/lmdbjava/DbiFlags.java      |  30 ++-
 src/main/java/org/lmdbjava/Env.java           |  77 +++++++-
 src/main/java/org/lmdbjava/EnvFlagSet.java    |  57 ++++++
 src/main/java/org/lmdbjava/EnvFlags.java      |  30 ++-
 src/main/java/org/lmdbjava/FlagSet.java       |  61 ++++++
 src/main/java/org/lmdbjava/PutFlagSet.java    |  53 +++--
 src/main/java/org/lmdbjava/PutFlags.java      |  30 ++-
 src/main/java/org/lmdbjava/Txn.java           |  12 +-
 src/main/java/org/lmdbjava/TxnFlagSet.java    |  63 ++++++
 src/main/java/org/lmdbjava/TxnFlags.java      |  30 ++-
 .../java/org/lmdbjava/CopyFlagSetTest.java    |  88 +++++++++
 .../java/org/lmdbjava/DbiFlagSetTest.java     |  93 +++++----
 .../java/org/lmdbjava/EnvFlagSetTest.java     | 116 +++++++++++
 .../java/org/lmdbjava/PutFlagSetTest.java     |  15 ++
 .../java/org/lmdbjava/TxnFlagSetTest.java     |  88 +++++++++
 19 files changed, 1066 insertions(+), 115 deletions(-)
 create mode 100644 src/main/java/org/lmdbjava/CopyFlagSet.java
 create mode 100644 src/main/java/org/lmdbjava/EnvFlagSet.java
 create mode 100644 src/main/java/org/lmdbjava/FlagSet.java
 create mode 100644 src/main/java/org/lmdbjava/TxnFlagSet.java
 create mode 100644 src/test/java/org/lmdbjava/CopyFlagSetTest.java
 create mode 100644 src/test/java/org/lmdbjava/EnvFlagSetTest.java
 create mode 100644 src/test/java/org/lmdbjava/TxnFlagSetTest.java

diff --git a/src/main/java/org/lmdbjava/AbstractFlagSet.java b/src/main/java/org/lmdbjava/AbstractFlagSet.java
index 3c21fb15..7ea413fb 100644
--- a/src/main/java/org/lmdbjava/AbstractFlagSet.java
+++ b/src/main/java/org/lmdbjava/AbstractFlagSet.java
@@ -2,20 +2,19 @@
 
 import java.util.Collection;
 import java.util.Collections;
-import java.util.Comparator;
 import java.util.EnumSet;
 import java.util.Iterator;
 import java.util.Objects;
 import java.util.Set;
 import java.util.function.Function;
-import java.util.stream.Collectors;
+import java.util.function.Supplier;
 
 /**
  * Encapsulates an immutable set of flags and the associated bit mask for the flags in the set.
  *
  * @param <T>
  */
-public abstract class AbstractFlagSet<T extends Enum<T> & MaskedFlag> implements Iterable<T> {
+public abstract class AbstractFlagSet<T extends Enum<T> & MaskedFlag> implements FlagSet<T> {
 
   private final Set<T> flags;
   private final int mask;
@@ -29,13 +28,15 @@ protected AbstractFlagSet(final EnumSet<T> flags) {
   /**
    * @return THe combined bit mask for all flags in the set.
    */
-  int getMask() {
+  @Override
+  public int getMask() {
     return mask;
   }
 
   /**
    * @return All flags in the set.
    */
+  @Override
   public Set<T> getFlags() {
     return flags;
   }
@@ -43,14 +44,18 @@ public Set<T> getFlags() {
   /**
    * @return True if flag has been set, i.e. is contained in this set.
    */
+  @Override
   public boolean isSet(final T flag) {
+    // Probably cheaper to compare the masks than to use EnumSet.contains()
     return flag != null
-        && flags.contains(flag);
+        && MaskedFlag.isSet(mask, flag);
+
   }
 
   /**
    * @return The number of flags in this set.
    */
+  @Override
   public int size() {
     return flags.size();
   }
@@ -58,6 +63,7 @@ public int size() {
   /**
    * @return True if this set is empty.
    */
+  @Override
   public boolean isEmpty() {
     return flags.isEmpty();
   }
@@ -73,9 +79,8 @@ public Iterator<T> iterator() {
   @Override
   public boolean equals(Object object) {
     if (this == object) return true;
-    if (object == null || getClass() != object.getClass()) return false;
-    AbstractFlagSet<?> flagSet = (AbstractFlagSet<?>) object;
-    return mask == flagSet.mask && Objects.equals(flags, flagSet.flags);
+//    if (object == null || getClass() != object.getClass()) return false;
+    return FlagSet.equals(this, (FlagSet<?>) object);
   }
 
   @Override
@@ -85,14 +90,137 @@ public int hashCode() {
 
   @Override
   public String toString() {
-    final String flagsStr = flags.stream()
-        .sorted(Comparator.comparing(MaskedFlag::getMask))
-        .map(MaskedFlag::name)
-        .collect(Collectors.joining(", "));
-    return "FlagSet{" +
-        "flags=[" + flagsStr +
-        "], mask=" + mask +
-        '}';
+    return FlagSet.asString(this);
+  }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  static abstract class AbstractSingleFlagSet<T extends Enum<T> & MaskedFlag> implements FlagSet<T> {
+
+    private final T flag;
+    // Only holding this for iterator() and getFlags() so make it lazy.
+    private EnumSet<T> enumSet;
+
+    public AbstractSingleFlagSet(final T flag) {
+      this.flag = Objects.requireNonNull(flag);
+    }
+
+    @Override
+    public int getMask() {
+      return flag.getMask();
+    }
+
+    @Override
+    public Set<T> getFlags() {
+      if (enumSet == null) {
+        return initSet();
+      } else {
+        return this.enumSet;
+      }
+    }
+
+    @Override
+    public boolean isSet(final T flag) {
+      return this.flag == flag;
+    }
+
+    @Override
+    public int size() {
+      return 1;
+    }
+
+    @Override
+    public boolean isEmpty() {
+      return false;
+    }
+
+    @Override
+    public Iterator<T> iterator() {
+      if (enumSet == null) {
+        return initSet().iterator();
+      } else {
+        return this.enumSet.iterator();
+      }
+    }
+
+    @Override
+    public String toString() {
+      return FlagSet.asString(this);
+    }
+
+    @Override
+    public boolean equals(Object object) {
+      if (this == object) return true;
+//      if (object == null || getClass() != object.getClass()) return false;
+      return FlagSet.equals(this, (FlagSet<?>) object);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(flag, getFlags());
+    }
+
+    private Set<T> initSet() {
+      final EnumSet<T> set = EnumSet.of(this.flag);
+      this.enumSet = set;
+      return set;
+    }
+  }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  static class AbstractEmptyFlagSet<T extends MaskedFlag> implements FlagSet<T> {
+
+    @Override
+    public int getMask() {
+      return MaskedFlag.EMPTY_MASK;
+    }
+
+    @Override
+    public Set<T> getFlags() {
+      return Collections.emptySet();
+    }
+
+    @Override
+    public boolean isSet(final T flag) {
+      return false;
+    }
+
+    @Override
+    public int size() {
+      return 0;
+    }
+
+    @Override
+    public boolean isEmpty() {
+      return true;
+    }
+
+    @Override
+    public Iterator<T> iterator() {
+      return Collections.emptyIterator();
+    }
+
+    @Override
+    public String toString() {
+      return FlagSet.asString(this);
+    }
+
+    @Override
+    public boolean equals(Object object) {
+      if (this == object) return true;
+//      if (object == null || getClass() != object.getClass()) return false;
+      return FlagSet.equals(this, (FlagSet<?>) object);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(getMask(), getFlags());
+    }
   }
 
 
@@ -105,17 +233,23 @@ public String toString() {
    * @param <E> The type of flag to be held in the {@link AbstractFlagSet}
    * @param <S> The type of the {@link AbstractFlagSet} implementation.
    */
-  public static class Builder<E extends Enum<E> & MaskedFlag, S extends AbstractFlagSet<E>> {
+  public static class Builder<E extends Enum<E> & MaskedFlag, S extends FlagSet<E>> {
 
     final Class<E> type;
     final EnumSet<E> enumSet;
     final Function<EnumSet<E>, S> constructor;
+    final Function<E, S> singletonSetConstructor;
+    final Supplier<S> emptySetSupplier;
 
     protected Builder(final Class<E> type,
-                      final Function<EnumSet<E>, S> constructor) {
+                      final Function<EnumSet<E>, S> constructor,
+                      final Function<E, S> singletonSetConstructor,
+                      final Supplier<S> emptySetSupplier) {
       this.type = type;
       this.enumSet = EnumSet.noneOf(type);
-      this.constructor = constructor;
+      this.constructor = Objects.requireNonNull(constructor);
+      this.singletonSetConstructor = Objects.requireNonNull(singletonSetConstructor);
+      this.emptySetSupplier = Objects.requireNonNull(emptySetSupplier);
     }
 
     /**
@@ -125,7 +259,7 @@ protected Builder(final Class<E> type,
      * @return this builder instance.
      */
     public Builder<E, S> withFlags(final Collection<E> flags) {
-      enumSet.clear();
+      clear();
       if (flags != null) {
         for (E flag : flags) {
           if (flag != null) {
@@ -142,7 +276,7 @@ public Builder<E, S> withFlags(final Collection<E> flags) {
      */
     @SafeVarargs
     public final Builder<E, S> withFlags(final E... flags) {
-      enumSet.clear();
+      clear();
       if (flags != null) {
         for (E flag : flags) {
           if (flag != null) {
@@ -185,8 +319,14 @@ public Builder<E, S> clear() {
      * @return A
      */
     public S build() {
-      return constructor.apply(enumSet);
+      final int size = enumSet.size();
+      if (size == 0) {
+        return emptySetSupplier.get();
+      } else if (size == 1) {
+        return singletonSetConstructor.apply(enumSet.stream().findFirst().get());
+      } else {
+        return constructor.apply(enumSet);
+      }
     }
   }
 }
-
diff --git a/src/main/java/org/lmdbjava/CopyFlagSet.java b/src/main/java/org/lmdbjava/CopyFlagSet.java
new file mode 100644
index 00000000..62c73c8d
--- /dev/null
+++ b/src/main/java/org/lmdbjava/CopyFlagSet.java
@@ -0,0 +1,59 @@
+package org.lmdbjava;
+
+import java.util.Collection;
+import java.util.EnumSet;
+import java.util.Objects;
+
+public interface CopyFlagSet extends FlagSet<CopyFlags> {
+
+  static CopyFlagSet EMPTY = CopyFlagSetImpl.EMPTY;
+
+  static CopyFlagSet empty() {
+    return CopyFlagSetImpl.EMPTY;
+  }
+
+  static CopyFlagSet of(final CopyFlags dbiFlag) {
+    Objects.requireNonNull(dbiFlag);
+    return dbiFlag;
+  }
+
+  static CopyFlagSet of(final CopyFlags... CopyFlags) {
+    return builder()
+        .withFlags(CopyFlags)
+        .build();
+  }
+
+  static CopyFlagSet of(final Collection<CopyFlags> CopyFlags) {
+    return builder()
+        .withFlags(CopyFlags)
+        .build();
+  }
+
+  static AbstractFlagSet.Builder<CopyFlags, CopyFlagSet> builder() {
+    return new AbstractFlagSet.Builder<>(
+        CopyFlags.class,
+        CopyFlagSetImpl::new,
+        copyFlag -> copyFlag,
+        () -> CopyFlagSetImpl.EMPTY);
+  }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  class CopyFlagSetImpl extends AbstractFlagSet<CopyFlags> implements CopyFlagSet {
+
+    static final CopyFlagSet EMPTY = new EmptyCopyFlagSet();
+
+    private CopyFlagSetImpl(final EnumSet<CopyFlags> flags) {
+      super(flags);
+    }
+  }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  class EmptyCopyFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<CopyFlags> implements CopyFlagSet {
+  }
+}
diff --git a/src/main/java/org/lmdbjava/CopyFlags.java b/src/main/java/org/lmdbjava/CopyFlags.java
index 4365563c..fbd4d171 100644
--- a/src/main/java/org/lmdbjava/CopyFlags.java
+++ b/src/main/java/org/lmdbjava/CopyFlags.java
@@ -15,8 +15,11 @@
  */
 package org.lmdbjava;
 
+import java.util.EnumSet;
+import java.util.Set;
+
 /** Flags for use when performing a {@link Env#copy(java.io.File, org.lmdbjava.CopyFlags...)}. */
-public enum CopyFlags implements MaskedFlag {
+public enum CopyFlags implements MaskedFlag, CopyFlagSet {
 
   /** Compacting copy: Omit free space from copy, and renumber all pages sequentially. */
   MDB_CP_COMPACT(0x01);
@@ -31,4 +34,29 @@ public enum CopyFlags implements MaskedFlag {
   public int getMask() {
     return mask;
   }
+
+  @Override
+  public Set<CopyFlags> getFlags() {
+    return EnumSet.of(this);
+  }
+
+  @Override
+  public boolean isSet(final CopyFlags flag) {
+    return flag != null && mask == flag.getMask();
+  }
+
+  @Override
+  public int size() {
+    return 1;
+  }
+
+  @Override
+  public boolean isEmpty() {
+    return false;
+  }
+
+  @Override
+  public String toString() {
+    return FlagSet.asString(this);
+  }
 }
diff --git a/src/main/java/org/lmdbjava/DbiFlagSet.java b/src/main/java/org/lmdbjava/DbiFlagSet.java
index cd1db934..e5c97544 100644
--- a/src/main/java/org/lmdbjava/DbiFlagSet.java
+++ b/src/main/java/org/lmdbjava/DbiFlagSet.java
@@ -1,32 +1,57 @@
 package org.lmdbjava;
 
+import java.util.Collection;
 import java.util.EnumSet;
 import java.util.Objects;
 
-public class DbiFlagSet extends AbstractFlagSet<DbiFlags> {
+public interface DbiFlagSet extends FlagSet<DbiFlags> {
 
-    public static final DbiFlagSet EMPTY = new DbiFlagSet(EnumSet.noneOf(DbiFlags.class));
+  static DbiFlagSet empty() {
+    return DbiFlagSetImpl.EMPTY;
+  }
 
-    private DbiFlagSet(final EnumSet<DbiFlags> flags) {
-        super(flags);
-    }
+  static DbiFlagSet of(final DbiFlags dbiFlag) {
+    Objects.requireNonNull(dbiFlag);
+    return dbiFlag;
+  }
 
-    public static DbiFlagSet empty() {
-        return EMPTY;
-    }
+  static DbiFlagSet of(final DbiFlags... DbiFlags) {
+    return builder()
+        .withFlags(DbiFlags)
+        .build();
+  }
 
-    public static DbiFlagSet of(final DbiFlags putFlag) {
-        Objects.requireNonNull(putFlag);
-        return new DbiFlagSet(EnumSet.of(putFlag));
-    }
+  static DbiFlagSet of(final Collection<DbiFlags> DbiFlags) {
+    return builder()
+        .withFlags(DbiFlags)
+        .build();
+  }
+
+  static AbstractFlagSet.Builder<DbiFlags, DbiFlagSet> builder() {
+    return new AbstractFlagSet.Builder<>(
+        DbiFlags.class,
+        DbiFlagSetImpl::new,
+        dbiFlag -> dbiFlag,
+        () -> DbiFlagSetImpl.EMPTY);
+  }
+
+
+  // --------------------------------------------------------------------------------
 
-    public static DbiFlagSet of(final DbiFlags... DbiFlags) {
-        return builder()
-                .withFlags(DbiFlags)
-                .build();
-    }
 
-    public static Builder<DbiFlags, DbiFlagSet> builder() {
-        return new Builder<>(DbiFlags.class, DbiFlagSet::new);
+  class DbiFlagSetImpl extends AbstractFlagSet<DbiFlags> implements DbiFlagSet {
+
+    static final DbiFlagSet EMPTY = new EmptyDbiFlagSet();
+
+    private DbiFlagSetImpl(final EnumSet<DbiFlags> flags) {
+      super(flags);
     }
+  }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  class EmptyDbiFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<DbiFlags> implements DbiFlagSet {
+  }
 }
diff --git a/src/main/java/org/lmdbjava/DbiFlags.java b/src/main/java/org/lmdbjava/DbiFlags.java
index af6eaeaa..6e4b723d 100644
--- a/src/main/java/org/lmdbjava/DbiFlags.java
+++ b/src/main/java/org/lmdbjava/DbiFlags.java
@@ -15,8 +15,11 @@
  */
 package org.lmdbjava;
 
+import java.util.EnumSet;
+import java.util.Set;
+
 /** Flags for use when opening a {@link Dbi}. */
-public enum DbiFlags implements MaskedFlag {
+public enum DbiFlags implements MaskedFlag, DbiFlagSet {
 
   /**
    * Use reverse string keys.
@@ -82,4 +85,29 @@ public enum DbiFlags implements MaskedFlag {
   public int getMask() {
     return mask;
   }
+
+  @Override
+  public Set<DbiFlags> getFlags() {
+    return EnumSet.of(this);
+  }
+
+  @Override
+  public boolean isSet(final DbiFlags flag) {
+    return flag != null && mask == flag.getMask();
+  }
+
+  @Override
+  public int size() {
+    return 1;
+  }
+
+  @Override
+  public boolean isEmpty() {
+    return false;
+  }
+
+  @Override
+  public String toString() {
+    return FlagSet.asString(this);
+  }
 }
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 5de0a7fd..2ad929ad 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -26,7 +26,6 @@
 import static org.lmdbjava.MaskedFlag.isSet;
 import static org.lmdbjava.MaskedFlag.mask;
 import static org.lmdbjava.ResultCodeMapper.checkRc;
-import static org.lmdbjava.TxnFlags.MDB_RDONLY_TXN;
 
 import java.io.File;
 import java.nio.ByteBuffer;
@@ -124,6 +123,27 @@ public void close() {
     LIB.mdb_env_close(ptr);
   }
 
+  /**
+   * Copies an LMDB environment to the specified destination path.
+   *
+   * <p>This function may be used to make a backup of an existing environment. No lockfile is
+   * created, since it gets recreated at need.
+   *
+   * <p>If this environment was created using {@link EnvFlags#MDB_NOSUBDIR}, the destination path
+   * must be a directory that exists but contains no files. If {@link EnvFlags#MDB_NOSUBDIR} was
+   * used, the destination path must not exist, but it must be possible to create a file at the
+   * provided path.
+   *
+   * <p>Note: This call can trigger significant file size growth if run in parallel with write
+   * transactions, because it employs a read-only transaction. See long-lived transactions under
+   * "Caveats" in the LMDB native documentation.
+   *
+   * @param path writable destination path as described above
+   */
+  public void copy(final File path) {
+    copy(path, CopyFlagSet.EMPTY);
+  }
+
   /**
    * Copies an LMDB environment to the specified destination path.
    *
@@ -142,11 +162,10 @@ public void close() {
    * @param path writable destination path as described above
    * @param flags special options for this copy
    */
-  public void copy(final File path, final CopyFlags... flags) {
+  public void copy(final File path, final CopyFlagSet flags) {
     requireNonNull(path);
     validatePath(path);
-    final int flagsMask = mask(flags);
-    checkRc(LIB.mdb_env_copy2(ptr, path.getAbsolutePath(), flagsMask));
+    checkRc(LIB.mdb_env_copy2(ptr, path.getAbsolutePath(), flags.getMask()));
   }
 
   /**
@@ -443,16 +462,54 @@ public void sync(final boolean force) {
   }
 
   /**
+   * @deprecated Instead use {@link Env#txn(Txn, TxnFlagSet)}
+   *
    * Obtain a transaction with the requested parent and flags.
    *
    * @param parent parent transaction (may be null if no parent)
    * @param flags applicable flags (eg for a reusable, read-only transaction)
    * @return a transaction (never null)
    */
+  @Deprecated
   public Txn<T> txn(final Txn<T> parent, final TxnFlags... flags) {
-    if (closed) {
-      throw new AlreadyClosedException();
-    }
+    checkNotClosed();
+    return new Txn<>(this, parent, proxy, TxnFlagSet.of(flags));
+  }
+
+  /**
+   * Obtain a transaction with the requested parent and flags.
+   *
+   * @param parent parent transaction (may be null if no parent)
+   * @return a transaction (never null)
+   */
+  public Txn<T> txn(final Txn<T> parent) {
+    checkNotClosed();
+    return new Txn<>(this, parent, proxy, TxnFlagSet.EMPTY);
+  }
+
+  /**
+   * Obtain a transaction with the requested parent and flags.
+   *
+   * @param parent parent transaction (may be null if no parent)
+   * @param flag applicable flag (eg for a reusable, read-only transaction)
+   * @return a transaction (never null)
+   */
+  public Txn<T> txn(final Txn<T> parent, final TxnFlags flag) {
+    checkNotClosed();
+    return new Txn<>(this, parent, proxy, flag);
+  }
+
+  /**
+   * Obtain a transaction with the requested parent and flags.
+   *
+   * @param parent parent transaction (may be null if no parent)
+   * @param flags applicable flags (e.g. for a reusable, read-only transaction).
+   *              If the set of flags is used frequently it is recommended to hold
+   *              a static instance of the {@link TxnFlagSet} for re-use.
+   * @return a transaction (never null)
+   */
+  public Txn<T> txn(final Txn<T> parent, final TxnFlagSet flags) {
+    checkNotClosed();
     return new Txn<>(this, parent, proxy, flags);
   }
 
@@ -462,7 +519,8 @@ public Txn<T> txn(final Txn<T> parent, final TxnFlags... flags) {
    * @return a read-only transaction
    */
   public Txn<T> txnRead() {
-    return txn(null, MDB_RDONLY_TXN);
+    checkNotClosed();
+    return new Txn<>(this, null, proxy, TxnFlags.MDB_RDONLY_TXN);
   }
 
   /**
@@ -471,7 +529,8 @@ public Txn<T> txnRead() {
    * @return a read-write transaction
    */
   public Txn<T> txnWrite() {
-    return txn(null);
+    checkNotClosed();
+    return new Txn<>(this, null, proxy, TxnFlagSet.EMPTY);
   }
 
   Pointer pointer() {
diff --git a/src/main/java/org/lmdbjava/EnvFlagSet.java b/src/main/java/org/lmdbjava/EnvFlagSet.java
new file mode 100644
index 00000000..944496e6
--- /dev/null
+++ b/src/main/java/org/lmdbjava/EnvFlagSet.java
@@ -0,0 +1,57 @@
+package org.lmdbjava;
+
+import java.util.Collection;
+import java.util.EnumSet;
+import java.util.Objects;
+
+public interface EnvFlagSet extends FlagSet<EnvFlags> {
+
+  static EnvFlagSet empty() {
+    return EnvFlagSetImpl.EMPTY;
+  }
+
+  static EnvFlagSet of(final EnvFlags envFlag) {
+    Objects.requireNonNull(envFlag);
+    return envFlag;
+  }
+
+  static EnvFlagSet of(final EnvFlags... EnvFlags) {
+    return builder()
+        .withFlags(EnvFlags)
+        .build();
+  }
+
+  static EnvFlagSet of(final Collection<EnvFlags> EnvFlags) {
+    return builder()
+        .withFlags(EnvFlags)
+        .build();
+  }
+
+  static AbstractFlagSet.Builder<EnvFlags, EnvFlagSet> builder() {
+    return new AbstractFlagSet.Builder<>(
+        EnvFlags.class,
+        EnvFlagSetImpl::new,
+        envFlag -> envFlag,
+        () -> EnvFlagSetImpl.EMPTY);
+  }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  class EnvFlagSetImpl extends AbstractFlagSet<EnvFlags> implements EnvFlagSet {
+
+    static final EnvFlagSet EMPTY = new EmptyEnvFlagSet();
+
+    private EnvFlagSetImpl(final EnumSet<EnvFlags> flags) {
+      super(flags);
+    }
+  }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  class EmptyEnvFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<EnvFlags> implements EnvFlagSet {
+  }
+}
diff --git a/src/main/java/org/lmdbjava/EnvFlags.java b/src/main/java/org/lmdbjava/EnvFlags.java
index 4ce555a8..7fb4a29b 100644
--- a/src/main/java/org/lmdbjava/EnvFlags.java
+++ b/src/main/java/org/lmdbjava/EnvFlags.java
@@ -15,8 +15,11 @@
  */
 package org.lmdbjava;
 
+import java.util.EnumSet;
+import java.util.Set;
+
 /** Flags for use when opening the {@link Env}. */
-public enum EnvFlags implements MaskedFlag {
+public enum EnvFlags implements MaskedFlag, EnvFlagSet {
 
   /**
    * Mmap at a fixed address (experimental).
@@ -144,4 +147,29 @@ public enum EnvFlags implements MaskedFlag {
   public int getMask() {
     return mask;
   }
+
+  @Override
+  public Set<EnvFlags> getFlags() {
+    return EnumSet.of(this);
+  }
+
+  @Override
+  public boolean isSet(final EnvFlags flag) {
+    return flag != null && mask == flag.getMask();
+  }
+
+  @Override
+  public int size() {
+    return 1;
+  }
+
+  @Override
+  public boolean isEmpty() {
+    return false;
+  }
+
+  @Override
+  public String toString() {
+    return FlagSet.asString(this);
+  }
 }
diff --git a/src/main/java/org/lmdbjava/FlagSet.java b/src/main/java/org/lmdbjava/FlagSet.java
new file mode 100644
index 00000000..80a4c19e
--- /dev/null
+++ b/src/main/java/org/lmdbjava/FlagSet.java
@@ -0,0 +1,61 @@
+package org.lmdbjava;
+
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+/**
+ * A set of flags, each with a bit mask value.
+ * Flags can be combined in a set such that the set has a combined bit mask value.
+ * @param <T>
+ */
+public interface FlagSet<T extends MaskedFlag> extends Iterable<T> {
+
+  int getMask();
+
+  Set<T> getFlags();
+
+  boolean isSet(T flag);
+
+  default int size() {
+    return getFlags().size();
+  }
+
+  default boolean isEmpty() {
+    return getFlags().isEmpty();
+  }
+
+  default Iterator<T> iterator() {
+    return getFlags().iterator();
+  }
+
+  static <T extends MaskedFlag> String asString(final FlagSet<T> flagSet) {
+    Objects.requireNonNull(flagSet);
+    final String flagsStr = flagSet.getFlags()
+        .stream()
+        .sorted(Comparator.comparing(MaskedFlag::getMask))
+        .map(MaskedFlag::name)
+        .collect(Collectors.joining(", "));
+    return "FlagSet{" +
+        "flags=[" + flagsStr +
+        "], mask=" + flagSet.getMask() +
+        '}';
+  }
+
+  static boolean equals(final FlagSet<?> flagSet1,
+                        final FlagSet<?> flagSet2) {
+    if (flagSet1 == flagSet2) {
+      return true;
+    } else if (flagSet1 != null && flagSet2 == null) {
+      return false;
+    } else if (flagSet1 == null) {
+      return false;
+    } else {
+      return flagSet1.getMask() == flagSet2.getMask()
+          && Objects.equals(flagSet1.getFlags(), flagSet2.getFlags());
+    }
+  }
+
+}
diff --git a/src/main/java/org/lmdbjava/PutFlagSet.java b/src/main/java/org/lmdbjava/PutFlagSet.java
index 8820fe92..1eedaf10 100644
--- a/src/main/java/org/lmdbjava/PutFlagSet.java
+++ b/src/main/java/org/lmdbjava/PutFlagSet.java
@@ -1,32 +1,57 @@
 package org.lmdbjava;
 
+import java.util.Collection;
 import java.util.EnumSet;
 import java.util.Objects;
 
-public class PutFlagSet extends AbstractFlagSet<PutFlags> {
+public interface PutFlagSet extends FlagSet<PutFlags> {
 
-    public static final PutFlagSet EMPTY = new PutFlagSet(EnumSet.noneOf(PutFlags.class));
-
-    private PutFlagSet(final EnumSet<PutFlags> flags) {
-        super(flags);
-    }
-
-    public static PutFlagSet empty() {
-        return EMPTY;
+    static PutFlagSet empty() {
+        return PutFlagSetImpl.EMPTY;
     }
 
-    public static PutFlagSet of(final PutFlags putFlag) {
+    static PutFlagSet of(final PutFlags putFlag) {
         Objects.requireNonNull(putFlag);
-        return new org.lmdbjava.PutFlagSet(EnumSet.of(putFlag));
+        return putFlag;
     }
 
-    public static PutFlagSet of(final PutFlags... putFlags) {
+    static PutFlagSet of(final PutFlags... putFlags) {
         return builder()
                 .withFlags(putFlags)
                 .build();
     }
 
-    public static Builder<PutFlags, PutFlagSet> builder() {
-        return new Builder<>(PutFlags.class, PutFlagSet::new);
+    static PutFlagSet of(final Collection<PutFlags> putFlags) {
+        return builder()
+            .withFlags(putFlags)
+            .build();
+    }
+
+    static AbstractFlagSet.Builder<PutFlags, PutFlagSet> builder() {
+        return new AbstractFlagSet.Builder<>(
+            PutFlags.class,
+            PutFlagSetImpl::new,
+            putFlag -> putFlag,
+            EmptyPutFlagSet::new);
+    }
+
+
+    // --------------------------------------------------------------------------------
+
+
+    class PutFlagSetImpl extends AbstractFlagSet<PutFlags> implements PutFlagSet {
+
+        public static final PutFlagSet EMPTY = new EmptyPutFlagSet();
+
+        private PutFlagSetImpl(final EnumSet<PutFlags> flags) {
+            super(flags);
+        }
+    }
+
+
+    // --------------------------------------------------------------------------------
+
+
+    class EmptyPutFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<PutFlags> implements PutFlagSet {
     }
 }
diff --git a/src/main/java/org/lmdbjava/PutFlags.java b/src/main/java/org/lmdbjava/PutFlags.java
index 809103de..03fa916a 100644
--- a/src/main/java/org/lmdbjava/PutFlags.java
+++ b/src/main/java/org/lmdbjava/PutFlags.java
@@ -15,8 +15,11 @@
  */
 package org.lmdbjava;
 
+import java.util.EnumSet;
+import java.util.Set;
+
 /** Flags for use when performing a "put". */
-public enum PutFlags implements MaskedFlag {
+public enum PutFlags implements MaskedFlag, PutFlagSet {
 
   /** For put: Don't write if the key already exists. */
   MDB_NOOVERWRITE(0x10),
@@ -49,4 +52,29 @@ public enum PutFlags implements MaskedFlag {
   public int getMask() {
     return mask;
   }
+
+  @Override
+  public Set<PutFlags> getFlags() {
+    return EnumSet.of(this);
+  }
+
+  @Override
+  public boolean isSet(PutFlags flag) {
+    return flag != null && mask == flag.getMask();
+  }
+
+  @Override
+  public int size() {
+    return 1;
+  }
+
+  @Override
+  public boolean isEmpty() {
+    return false;
+  }
+
+  @Override
+  public String toString() {
+    return FlagSet.asString(this);
+  }
 }
diff --git a/src/main/java/org/lmdbjava/Txn.java b/src/main/java/org/lmdbjava/Txn.java
index 1d5d4860..5c8440fd 100644
--- a/src/main/java/org/lmdbjava/Txn.java
+++ b/src/main/java/org/lmdbjava/Txn.java
@@ -20,8 +20,6 @@
 import static org.lmdbjava.Env.SHOULD_CHECK;
 import static org.lmdbjava.Library.LIB;
 import static org.lmdbjava.Library.RUNTIME;
-import static org.lmdbjava.MaskedFlag.isSet;
-import static org.lmdbjava.MaskedFlag.mask;
 import static org.lmdbjava.ResultCodeMapper.checkRc;
 import static org.lmdbjava.Txn.State.DONE;
 import static org.lmdbjava.Txn.State.READY;
@@ -46,11 +44,13 @@ public final class Txn<T> implements AutoCloseable {
   private final Env<T> env;
   private State state;
 
-  Txn(final Env<T> env, final Txn<T> parent, final BufferProxy<T> proxy, final TxnFlags... flags) {
+  Txn(final Env<T> env, final Txn<T> parent, final BufferProxy<T> proxy, final TxnFlagSet flags) {
+    final TxnFlagSet flagSet = flags != null
+        ? flags
+        : TxnFlagSet.EMPTY;
     this.proxy = proxy;
     this.keyVal = proxy.keyVal();
-    final int flagsMask = mask(flags);
-    this.readOnly = isSet(flagsMask, MDB_RDONLY_TXN);
+    this.readOnly = flagSet.isSet(MDB_RDONLY_TXN);
     if (env.isReadOnly() && !this.readOnly) {
       throw new EnvIsReadOnly();
     }
@@ -61,7 +61,7 @@ public final class Txn<T> implements AutoCloseable {
     }
     final Pointer txnPtr = allocateDirect(RUNTIME, ADDRESS);
     final Pointer txnParentPtr = parent == null ? null : parent.ptr;
-    checkRc(LIB.mdb_txn_begin(env.pointer(), txnParentPtr, flagsMask, txnPtr));
+    checkRc(LIB.mdb_txn_begin(env.pointer(), txnParentPtr, flagSet.getMask(), txnPtr));
     ptr = txnPtr.getPointer(0);
 
     state = READY;
diff --git a/src/main/java/org/lmdbjava/TxnFlagSet.java b/src/main/java/org/lmdbjava/TxnFlagSet.java
new file mode 100644
index 00000000..6320eece
--- /dev/null
+++ b/src/main/java/org/lmdbjava/TxnFlagSet.java
@@ -0,0 +1,63 @@
+package org.lmdbjava;
+
+import java.util.EnumSet;
+import java.util.Objects;
+
+public interface TxnFlagSet extends FlagSet<TxnFlags> {
+
+  TxnFlagSet EMPTY = TxnFlagSetImpl.EMPTY;
+
+  static TxnFlagSet empty() {
+    return TxnFlagSetImpl.EMPTY;
+  }
+
+  static TxnFlagSet of(final TxnFlags putFlag) {
+    Objects.requireNonNull(putFlag);
+    return new SingleTxnFlagSet(putFlag);
+  }
+
+  static TxnFlagSet of(final TxnFlags... TxnFlags) {
+    return builder()
+        .withFlags(TxnFlags)
+        .build();
+  }
+
+  static AbstractFlagSet.Builder<TxnFlags, TxnFlagSet> builder() {
+    return new AbstractFlagSet.Builder<>(
+        TxnFlags.class,
+        TxnFlagSetImpl::new,
+        SingleTxnFlagSet::new,
+        () -> TxnFlagSetImpl.EMPTY);
+  }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  class TxnFlagSetImpl extends AbstractFlagSet<TxnFlags> implements TxnFlagSet {
+
+    static final TxnFlagSet EMPTY = new EmptyTxnFlagSet();
+
+    private TxnFlagSetImpl(final EnumSet<TxnFlags> flags) {
+      super(flags);
+    }
+  }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  class SingleTxnFlagSet extends AbstractFlagSet.AbstractSingleFlagSet<TxnFlags> implements TxnFlagSet {
+
+    SingleTxnFlagSet(final TxnFlags flag) {
+      super(flag);
+    }
+  }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  class EmptyTxnFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<TxnFlags> implements TxnFlagSet {
+  }
+}
diff --git a/src/main/java/org/lmdbjava/TxnFlags.java b/src/main/java/org/lmdbjava/TxnFlags.java
index 26caf6f1..8e4ea757 100644
--- a/src/main/java/org/lmdbjava/TxnFlags.java
+++ b/src/main/java/org/lmdbjava/TxnFlags.java
@@ -15,8 +15,11 @@
  */
 package org.lmdbjava;
 
+import java.util.EnumSet;
+import java.util.Set;
+
 /** Flags for use when creating a {@link Txn}. */
-public enum TxnFlags implements MaskedFlag {
+public enum TxnFlags implements MaskedFlag, TxnFlagSet {
   /** Read only. */
   MDB_RDONLY_TXN(0x2_0000);
 
@@ -30,4 +33,29 @@ public enum TxnFlags implements MaskedFlag {
   public int getMask() {
     return mask;
   }
+
+  @Override
+  public Set<TxnFlags> getFlags() {
+    return EnumSet.of(this);
+  }
+
+  @Override
+  public boolean isSet(final TxnFlags flag) {
+    return flag != null && mask == flag.getMask();
+  }
+
+  @Override
+  public int size() {
+    return 1;
+  }
+
+  @Override
+  public boolean isEmpty() {
+    return false;
+  }
+
+  @Override
+  public String toString() {
+    return FlagSet.asString(this);
+  }
 }
diff --git a/src/test/java/org/lmdbjava/CopyFlagSetTest.java b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
new file mode 100644
index 00000000..1ea44b7e
--- /dev/null
+++ b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
@@ -0,0 +1,88 @@
+package org.lmdbjava;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import java.util.Collections;
+import java.util.HashSet;
+import org.junit.Test;
+
+public class CopyFlagSetTest {
+
+    @Test
+    public void testEmpty() {
+        final CopyFlagSet copyFlagSet = CopyFlagSet.empty();
+        assertThat(
+                copyFlagSet.getMask(),
+                is(0));
+        assertThat(
+                copyFlagSet.size(),
+                is(0));
+        assertThat(
+                copyFlagSet.isEmpty(),
+                is(true));
+        assertThat(
+                copyFlagSet.isSet(CopyFlags.MDB_CP_COMPACT),
+                is(false));
+        final CopyFlagSet copyFlagSet2 = CopyFlagSet.builder()
+            .build();
+        assertThat(copyFlagSet, is(copyFlagSet2));
+        assertThat(copyFlagSet, not(CopyFlagSet.of(CopyFlags.MDB_CP_COMPACT)));
+        assertThat(copyFlagSet, not(CopyFlagSet.builder()
+            .setFlag(CopyFlags.MDB_CP_COMPACT)
+            .build()));
+    }
+
+    @Test
+    public void testOf() {
+        final CopyFlags copyFlag = CopyFlags.MDB_CP_COMPACT;
+        final CopyFlagSet copyFlagSet = CopyFlagSet.of(copyFlag);
+        assertThat(
+                copyFlagSet.getMask(),
+                is(MaskedFlag.mask(copyFlag)));
+        assertThat(
+                copyFlagSet.size(),
+                is(1));
+        for (CopyFlags flag : copyFlagSet) {
+            assertThat(
+                    copyFlagSet.isSet(flag),
+                    is(true));
+        }
+
+        final CopyFlagSet copyFlagSet2 = CopyFlagSet.builder()
+            .setFlag(copyFlag)
+            .build();
+        assertThat(copyFlagSet, is(copyFlagSet2));
+    }
+
+    @Test
+    public void testBuilder() {
+        final CopyFlags copyFlag1 = CopyFlags.MDB_CP_COMPACT;
+        final CopyFlagSet copyFlagSet = CopyFlagSet.builder()
+                .setFlag(copyFlag1)
+                .build();
+        assertThat(
+                copyFlagSet.getMask(),
+                is(MaskedFlag.mask(copyFlag1)));
+        assertThat(
+                copyFlagSet.size(),
+                is(1));
+        assertThat(
+                copyFlagSet.isSet(CopyFlags.MDB_CP_COMPACT),
+                is(true));
+        for (CopyFlags flag : copyFlagSet) {
+            assertThat(
+                    copyFlagSet.isSet(flag),
+                    is(true));
+        }
+        final CopyFlagSet copyFlagSet2 = CopyFlagSet.builder()
+                .withFlags(copyFlag1)
+                .build();
+        final CopyFlagSet copyFlagSet3 = CopyFlagSet.builder()
+                .withFlags(new HashSet<>(Collections.singletonList(copyFlag1)))
+                .build();
+        assertThat(copyFlagSet, is(copyFlagSet2));
+        assertThat(copyFlagSet, is(copyFlagSet3));
+    }
+}
diff --git a/src/test/java/org/lmdbjava/DbiFlagSetTest.java b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
index cfbda600..323a2ed4 100644
--- a/src/test/java/org/lmdbjava/DbiFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
@@ -1,6 +1,7 @@
 package org.lmdbjava;
 
 import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.MatcherAssert.assertThat;
 
 import java.util.Arrays;
@@ -11,91 +12,105 @@ public class DbiFlagSetTest {
 
     @Test
     public void testEmpty() {
-        final DbiFlagSet putFlagSet = DbiFlagSet.empty();
+        final DbiFlagSet dbiFlagSet = DbiFlagSet.empty();
         assertThat(
-                putFlagSet.getMask(),
+                dbiFlagSet.getMask(),
                 is(0));
         assertThat(
-                putFlagSet.size(),
+                dbiFlagSet.size(),
                 is(0));
         assertThat(
-                putFlagSet.isEmpty(),
+                dbiFlagSet.isEmpty(),
                 is(true));
         assertThat(
-                putFlagSet.isSet(DbiFlags.MDB_REVERSEDUP),
+                dbiFlagSet.isSet(DbiFlags.MDB_REVERSEDUP),
                 is(false));
+        final DbiFlagSet dbiFlagSet2 = DbiFlagSet.builder()
+            .build();
+        assertThat(dbiFlagSet, is(dbiFlagSet2));
+        assertThat(dbiFlagSet, not(DbiFlagSet.of(DbiFlags.MDB_CREATE)));
+        assertThat(dbiFlagSet, not(DbiFlagSet.of(DbiFlags.MDB_CREATE, DbiFlags.MDB_DUPSORT)));
+        assertThat(dbiFlagSet, not(DbiFlagSet.builder()
+            .setFlag(DbiFlags.MDB_CREATE)
+            .setFlag(DbiFlags.MDB_DUPFIXED)
+            .build()));
     }
 
     @Test
     public void testOf() {
-        final DbiFlags putFlag = DbiFlags.MDB_CREATE;
-        final DbiFlagSet putFlagSet = DbiFlagSet.of(putFlag);
+        final DbiFlags dbiFlag = DbiFlags.MDB_CREATE;
+        final DbiFlagSet dbiFlagSet = DbiFlagSet.of(dbiFlag);
         assertThat(
-                putFlagSet.getMask(),
-                is(MaskedFlag.mask(putFlag)));
+                dbiFlagSet.getMask(),
+                is(MaskedFlag.mask(dbiFlag)));
         assertThat(
-                putFlagSet.size(),
+                dbiFlagSet.size(),
                 is(1));
         assertThat(
-                putFlagSet.isSet(DbiFlags.MDB_REVERSEDUP),
+                dbiFlagSet.isSet(DbiFlags.MDB_REVERSEDUP),
                 is(false));
-        for (DbiFlags flag : putFlagSet) {
+        for (DbiFlags flag : dbiFlagSet) {
             assertThat(
-                    putFlagSet.isSet(flag),
+                    dbiFlagSet.isSet(flag),
                     is(true));
         }
+
+        final DbiFlagSet dbiFlagSet2 = DbiFlagSet.builder()
+            .setFlag(dbiFlag)
+            .build();
+        assertThat(dbiFlagSet, is(dbiFlagSet2));
     }
 
     @Test
     public void testOf2() {
-        final DbiFlags putFlag1 = DbiFlags.MDB_CREATE;
-        final DbiFlags putFlag2 = DbiFlags.MDB_INTEGERKEY;
-        final DbiFlagSet putFlagSet = DbiFlagSet.of(putFlag1, putFlag2);
+        final DbiFlags dbiFlag1 = DbiFlags.MDB_CREATE;
+        final DbiFlags dbiFlag2 = DbiFlags.MDB_INTEGERKEY;
+        final DbiFlagSet dbiFlagSet = DbiFlagSet.of(dbiFlag1, dbiFlag2);
         assertThat(
-                putFlagSet.getMask(),
-                is(MaskedFlag.mask(putFlag1, putFlag2)));
+                dbiFlagSet.getMask(),
+                is(MaskedFlag.mask(dbiFlag1, dbiFlag2)));
         assertThat(
-                putFlagSet.size(),
+                dbiFlagSet.size(),
                 is(2));
         assertThat(
-                putFlagSet.isSet(DbiFlags.MDB_REVERSEDUP),
+                dbiFlagSet.isSet(DbiFlags.MDB_REVERSEDUP),
                 is(false));
-        for (DbiFlags flag : putFlagSet) {
+        for (DbiFlags flag : dbiFlagSet) {
             assertThat(
-                    putFlagSet.isSet(flag),
+                    dbiFlagSet.isSet(flag),
                     is(true));
         }
     }
 
     @Test
     public void testBuilder() {
-        final DbiFlags putFlag1 = DbiFlags.MDB_CREATE;
-        final DbiFlags putFlag2 = DbiFlags.MDB_INTEGERKEY;
-        final DbiFlagSet putFlagSet = DbiFlagSet.builder()
-                .setFlag(putFlag1)
-                .setFlag(putFlag2)
+        final DbiFlags dbiFlag1 = DbiFlags.MDB_CREATE;
+        final DbiFlags dbiFlag2 = DbiFlags.MDB_INTEGERKEY;
+        final DbiFlagSet dbiFlagSet = DbiFlagSet.builder()
+                .setFlag(dbiFlag1)
+                .setFlag(dbiFlag2)
                 .build();
         assertThat(
-                putFlagSet.getMask(),
-                is(MaskedFlag.mask(putFlag1, putFlag2)));
+                dbiFlagSet.getMask(),
+                is(MaskedFlag.mask(dbiFlag1, dbiFlag2)));
         assertThat(
-                putFlagSet.size(),
+                dbiFlagSet.size(),
                 is(2));
         assertThat(
-                putFlagSet.isSet(DbiFlags.MDB_REVERSEDUP),
+                dbiFlagSet.isSet(DbiFlags.MDB_REVERSEDUP),
                 is(false));
-        for (DbiFlags flag : putFlagSet) {
+        for (DbiFlags flag : dbiFlagSet) {
             assertThat(
-                    putFlagSet.isSet(flag),
+                    dbiFlagSet.isSet(flag),
                     is(true));
         }
-        final DbiFlagSet putFlagSet2 = DbiFlagSet.builder()
-                .withFlags(putFlag1, putFlag2)
+        final DbiFlagSet dbiFlagSet2 = DbiFlagSet.builder()
+                .withFlags(dbiFlag1, dbiFlag2)
                 .build();
-        final DbiFlagSet putFlagSet3 = DbiFlagSet.builder()
-                .withFlags(new HashSet<>(Arrays.asList(putFlag1, putFlag2)))
+        final DbiFlagSet dbiFlagSet3 = DbiFlagSet.builder()
+                .withFlags(new HashSet<>(Arrays.asList(dbiFlag1, dbiFlag2)))
                 .build();
-        assertThat(putFlagSet, is(putFlagSet2));
-        assertThat(putFlagSet, is(putFlagSet3));
+        assertThat(dbiFlagSet, is(dbiFlagSet2));
+        assertThat(dbiFlagSet, is(dbiFlagSet3));
     }
 }
diff --git a/src/test/java/org/lmdbjava/EnvFlagSetTest.java b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
new file mode 100644
index 00000000..ed6a0fea
--- /dev/null
+++ b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
@@ -0,0 +1,116 @@
+package org.lmdbjava;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import org.junit.Test;
+
+public class EnvFlagSetTest {
+
+    @Test
+    public void testEmpty() {
+        final EnvFlagSet envFlagSet = EnvFlagSet.empty();
+        assertThat(
+                envFlagSet.getMask(),
+                is(0));
+        assertThat(
+                envFlagSet.size(),
+                is(0));
+        assertThat(
+                envFlagSet.isEmpty(),
+                is(true));
+        assertThat(
+                envFlagSet.isSet(EnvFlags.MDB_NOSUBDIR),
+                is(false));
+        final EnvFlagSet envFlagSet2 = EnvFlagSet.builder()
+            .build();
+        assertThat(envFlagSet, is(envFlagSet2));
+        assertThat(envFlagSet, not(EnvFlagSet.of(EnvFlags.MDB_FIXEDMAP)));
+        assertThat(envFlagSet, not(EnvFlagSet.of(EnvFlags.MDB_FIXEDMAP, EnvFlags.MDB_NORDAHEAD)));
+        assertThat(envFlagSet, not(EnvFlagSet.builder()
+            .setFlag(EnvFlags.MDB_FIXEDMAP)
+            .setFlag(EnvFlags.MDB_NORDAHEAD)
+            .build()));
+    }
+
+    @Test
+    public void testOf() {
+        final EnvFlags envFlag = EnvFlags.MDB_FIXEDMAP;
+        final EnvFlagSet envFlagSet = EnvFlagSet.of(envFlag);
+        assertThat(
+                envFlagSet.getMask(),
+                is(MaskedFlag.mask(envFlag)));
+        assertThat(
+                envFlagSet.size(),
+                is(1));
+        assertThat(
+                envFlagSet.isSet(EnvFlags.MDB_NOSUBDIR),
+                is(false));
+        for (EnvFlags flag : envFlagSet) {
+            assertThat(
+                    envFlagSet.isSet(flag),
+                    is(true));
+        }
+
+        final EnvFlagSet envFlagSet2 = EnvFlagSet.builder()
+            .setFlag(envFlag)
+            .build();
+        assertThat(envFlagSet, is(envFlagSet2));
+    }
+
+    @Test
+    public void testOf2() {
+        final EnvFlags envFlag1 = EnvFlags.MDB_FIXEDMAP;
+        final EnvFlags envFlag2 = EnvFlags.MDB_NORDAHEAD;
+        final EnvFlagSet envFlagSet = EnvFlagSet.of(envFlag1, envFlag2);
+        assertThat(
+                envFlagSet.getMask(),
+                is(MaskedFlag.mask(envFlag1, envFlag2)));
+        assertThat(
+                envFlagSet.size(),
+                is(2));
+        assertThat(
+                envFlagSet.isSet(EnvFlags.MDB_WRITEMAP),
+                is(false));
+        for (EnvFlags flag : envFlagSet) {
+            assertThat(
+                    envFlagSet.isSet(flag),
+                    is(true));
+        }
+    }
+
+    @Test
+    public void testBuilder() {
+        final EnvFlags envFlag1 = EnvFlags.MDB_FIXEDMAP;
+        final EnvFlags envFlag2 = EnvFlags.MDB_NORDAHEAD;
+        final EnvFlagSet envFlagSet = EnvFlagSet.builder()
+                .setFlag(envFlag1)
+                .setFlag(envFlag2)
+                .build();
+        assertThat(
+                envFlagSet.getMask(),
+                is(MaskedFlag.mask(envFlag1, envFlag2)));
+        assertThat(
+                envFlagSet.size(),
+                is(2));
+        assertThat(
+                envFlagSet.isSet(EnvFlags.MDB_NOTLS),
+                is(false));
+        for (EnvFlags flag : envFlagSet) {
+            assertThat(
+                    envFlagSet.isSet(flag),
+                    is(true));
+        }
+        final EnvFlagSet envFlagSet2 = EnvFlagSet.builder()
+                .withFlags(envFlag1, envFlag2)
+                .build();
+        final EnvFlagSet envFlagSet3 = EnvFlagSet.builder()
+                .withFlags(new HashSet<>(Arrays.asList(envFlag1, envFlag2)))
+                .build();
+        assertThat(envFlagSet, is(envFlagSet2));
+        assertThat(envFlagSet, is(envFlagSet3));
+    }
+}
diff --git a/src/test/java/org/lmdbjava/PutFlagSetTest.java b/src/test/java/org/lmdbjava/PutFlagSetTest.java
index 4826f436..8cf1efe0 100644
--- a/src/test/java/org/lmdbjava/PutFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/PutFlagSetTest.java
@@ -1,6 +1,7 @@
 package org.lmdbjava;
 
 import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.MatcherAssert.assertThat;
 
 import java.util.Arrays;
@@ -24,6 +25,15 @@ public void testEmpty() {
         assertThat(
                 putFlagSet.isSet(PutFlags.MDB_MULTIPLE),
                 is(false));
+        final PutFlagSet putFlagSet2 = PutFlagSet.builder()
+            .build();
+        assertThat(putFlagSet, is(putFlagSet2));
+        assertThat(putFlagSet, not(PutFlagSet.of(PutFlags.MDB_APPEND)));
+        assertThat(putFlagSet, not(PutFlagSet.of(PutFlags.MDB_APPEND, PutFlags.MDB_RESERVE)));
+        assertThat(putFlagSet, not(PutFlagSet.builder()
+            .setFlag(PutFlags.MDB_CURRENT)
+            .setFlag(PutFlags.MDB_MULTIPLE)
+            .build()));
     }
 
     @Test
@@ -44,6 +54,11 @@ public void testOf() {
                     putFlagSet.isSet(flag),
                     is(true));
         }
+
+        final PutFlagSet putFlagSet2 = PutFlagSet.builder()
+            .setFlag(putFlag)
+            .build();
+        assertThat(putFlagSet, is(putFlagSet2));
     }
 
     @Test
diff --git a/src/test/java/org/lmdbjava/TxnFlagSetTest.java b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
new file mode 100644
index 00000000..b526ceeb
--- /dev/null
+++ b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
@@ -0,0 +1,88 @@
+package org.lmdbjava;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.CoreMatchers.not;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import java.util.Collections;
+import java.util.HashSet;
+import org.junit.Test;
+
+public class TxnFlagSetTest {
+
+    @Test
+    public void testEmpty() {
+        final TxnFlagSet txnFlagSet = TxnFlagSet.empty();
+        assertThat(
+                txnFlagSet.getMask(),
+                is(0));
+        assertThat(
+                txnFlagSet.size(),
+                is(0));
+        assertThat(
+                txnFlagSet.isEmpty(),
+                is(true));
+        assertThat(
+                txnFlagSet.isSet(TxnFlags.MDB_RDONLY_TXN),
+                is(false));
+        final TxnFlagSet txnFlagSet2 = TxnFlagSet.builder()
+            .build();
+        assertThat(txnFlagSet, is(txnFlagSet2));
+        assertThat(txnFlagSet, not(TxnFlagSet.of(TxnFlags.MDB_RDONLY_TXN)));
+        assertThat(txnFlagSet, not(TxnFlagSet.builder()
+            .setFlag(TxnFlags.MDB_RDONLY_TXN)
+            .build()));
+    }
+
+    @Test
+    public void testOf() {
+        final TxnFlags txnFlag = TxnFlags.MDB_RDONLY_TXN;
+        final TxnFlagSet txnFlagSet = TxnFlagSet.of(txnFlag);
+        assertThat(
+                txnFlagSet.getMask(),
+                is(MaskedFlag.mask(txnFlag)));
+        assertThat(
+                txnFlagSet.size(),
+                is(1));
+        for (TxnFlags flag : txnFlagSet) {
+            assertThat(
+                    txnFlagSet.isSet(flag),
+                    is(true));
+        }
+
+        final TxnFlagSet txnFlagSet2 = TxnFlagSet.builder()
+            .setFlag(txnFlag)
+            .build();
+        assertThat(txnFlagSet, is(txnFlagSet2));
+    }
+
+    @Test
+    public void testBuilder() {
+        final TxnFlags txnFlag1 = TxnFlags.MDB_RDONLY_TXN;
+        final TxnFlagSet txnFlagSet = TxnFlagSet.builder()
+                .setFlag(txnFlag1)
+                .build();
+        assertThat(
+                txnFlagSet.getMask(),
+                is(MaskedFlag.mask(txnFlag1)));
+        assertThat(
+                txnFlagSet.size(),
+                is(1));
+        assertThat(
+                txnFlagSet.isSet(TxnFlags.MDB_RDONLY_TXN),
+                is(true));
+        for (TxnFlags flag : txnFlagSet) {
+            assertThat(
+                    txnFlagSet.isSet(flag),
+                    is(true));
+        }
+        final TxnFlagSet txnFlagSet2 = TxnFlagSet.builder()
+                .withFlags(txnFlag1)
+                .build();
+        final TxnFlagSet txnFlagSet3 = TxnFlagSet.builder()
+                .withFlags(new HashSet<>(Collections.singletonList(txnFlag1)))
+                .build();
+        assertThat(txnFlagSet, is(txnFlagSet2));
+        assertThat(txnFlagSet, is(txnFlagSet3));
+    }
+}

From 667dab37ccce1c8d79307c01ab1f1d130082cd84 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Mon, 27 Oct 2025 21:25:11 +0000
Subject: [PATCH 228/322] Fix Javadoc

---
 src/main/java/org/lmdbjava/CopyFlags.java | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/main/java/org/lmdbjava/CopyFlags.java b/src/main/java/org/lmdbjava/CopyFlags.java
index fbd4d171..b45dc87c 100644
--- a/src/main/java/org/lmdbjava/CopyFlags.java
+++ b/src/main/java/org/lmdbjava/CopyFlags.java
@@ -15,10 +15,11 @@
  */
 package org.lmdbjava;
 
+import java.io.File;
 import java.util.EnumSet;
 import java.util.Set;
 
-/** Flags for use when performing a {@link Env#copy(java.io.File, org.lmdbjava.CopyFlags...)}. */
+/** Flags for use when performing a {@link Env#copy(File, CopyFlagSet)}. */
 public enum CopyFlags implements MaskedFlag, CopyFlagSet {
 
   /** Compacting copy: Omit free space from copy, and renumber all pages sequentially. */

From b46c9164c4154bcb0dc78b675556b25d85390b1d Mon Sep 17 00:00:00 2001
From: stroomdev66 <stroomdev66@gmail.com>
Date: Tue, 28 Oct 2025 11:40:20 +0000
Subject: [PATCH 229/322] Add more cursor tests to protect against future
 regression

---
 .../org/lmdbjava/CursorIterableRangeTest.java | 188 ++++++++++++++++++
 .../java/org/lmdbjava/CursorIterableTest.java |  52 ++---
 .../testSignedComparator.actual               |  49 +++++
 .../testSignedComparator.expected             |  49 +++++
 .../testSignedComparatorDupsort.actual        |  49 +++++
 .../testSignedComparatorDupsort.expected      |  49 +++++
 .../testUnsignedComparator.actual             |  49 +++++
 .../testUnsignedComparator.expected           |  49 +++++
 .../testUnsignedComparatorDupsort.actual      |  49 +++++
 .../testUnsignedComparatorDupsort.expected    |  49 +++++
 .../CursorIterableRangeTest/tests.csv         |  49 +++++
 11 files changed, 655 insertions(+), 26 deletions(-)
 create mode 100644 src/test/java/org/lmdbjava/CursorIterableRangeTest.java
 create mode 100644 src/test/resources/CursorIterableRangeTest/testSignedComparator.actual
 create mode 100644 src/test/resources/CursorIterableRangeTest/testSignedComparator.expected
 create mode 100644 src/test/resources/CursorIterableRangeTest/testSignedComparatorDupsort.actual
 create mode 100644 src/test/resources/CursorIterableRangeTest/testSignedComparatorDupsort.expected
 create mode 100644 src/test/resources/CursorIterableRangeTest/testUnsignedComparator.actual
 create mode 100644 src/test/resources/CursorIterableRangeTest/testUnsignedComparator.expected
 create mode 100644 src/test/resources/CursorIterableRangeTest/testUnsignedComparatorDupsort.actual
 create mode 100644 src/test/resources/CursorIterableRangeTest/testUnsignedComparatorDupsort.expected
 create mode 100644 src/test/resources/CursorIterableRangeTest/tests.csv

diff --git a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
new file mode 100644
index 00000000..03f9a82d
--- /dev/null
+++ b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
@@ -0,0 +1,188 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.lmdbjava;
+
+import org.junit.Test;
+import org.lmdbjava.ByteBufferProxy.AbstractByteBufferProxy;
+import org.lmdbjava.CursorIterable.KeyVal;
+
+import java.io.File;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.Reader;
+import java.io.Writer;
+import java.nio.ByteBuffer;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Comparator;
+import java.util.stream.Stream;
+
+import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.lmdbjava.DbiFlags.MDB_CREATE;
+import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
+import static org.lmdbjava.Env.create;
+import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
+import static org.lmdbjava.TestUtils.DB_1;
+import static org.lmdbjava.TestUtils.POSIX_MODE;
+import static org.lmdbjava.TestUtils.bb;
+
+/**
+ * Test {@link CursorIterable}.
+ */
+public final class CursorIterableRangeTest {
+
+    @Test
+    public void testSignedComparator() throws IOException {
+        test(ByteBuffer::compareTo, true, "testSignedComparator", 1, MDB_CREATE);
+    }
+
+    @Test
+    public void testUnsignedComparator() throws IOException {
+        test(AbstractByteBufferProxy::compareBuff, false, "testUnsignedComparator", 1, MDB_CREATE);
+    }
+
+    @Test
+    public void testSignedComparatorDupsort() throws IOException {
+        test(ByteBuffer::compareTo, true, "testSignedComparatorDupsort", 2,MDB_CREATE, MDB_DUPSORT);
+    }
+
+    @Test
+    public void testUnsignedComparatorDupsort() throws IOException {
+        test(AbstractByteBufferProxy::compareBuff, false, "testUnsignedComparatorDupsort",2, MDB_CREATE, MDB_DUPSORT);
+    }
+
+    private void test(final Comparator<ByteBuffer> comparator,
+                      final boolean nativeCb,
+                      final String testName,
+                      final int copies,
+                      final DbiFlags... flags) throws IOException {
+        final Path dbPath = Files.createTempFile("test", "db");
+        try (final Env<ByteBuffer> env =
+                create()
+                        .setMapSize(KIBIBYTES.toBytes(256))
+                        .setMaxReaders(1)
+                        .setMaxDbs(1)
+                        .open(dbPath.toFile(), POSIX_MODE, MDB_NOSUBDIR)) {
+            final Dbi<ByteBuffer> dbi = env.openDbi(DB_1, comparator, nativeCb, flags);
+            populateDatabase(env, dbi, copies);
+
+            final File tests = new File("src/test/resources/CursorIterableRangeTest/tests.csv");
+            final File actual = tests.getParentFile().toPath().resolve(testName + ".actual").toFile();
+            final File expected = tests.getParentFile().toPath().resolve(testName + ".expected").toFile();
+            final String csv = readFile(tests);
+            final String[] parts = csv.split("\n");
+            try (final Writer writer = new FileWriter(actual)) {
+                for (final String part : parts) {
+                    writer.append(part);
+                    writer.append(" =>");
+
+                    final String[] params = part.split(",");
+                    final KeyRangeType keyRangeType = KeyRangeType.valueOf(params[0].trim());
+                    ByteBuffer start = null;
+                    ByteBuffer stop = null;
+                    if (params.length > 1 && params[1].trim().length() > 0) {
+                        start = bb(Integer.parseInt(params[1].trim()));
+                    }
+                    if (params.length > 2 && params[2].trim().length() > 0) {
+                        stop = bb(Integer.parseInt(params[2].trim()));
+                    }
+                    final KeyRange<ByteBuffer> keyRange = new KeyRange<>(keyRangeType, start, stop);
+                    boolean first = true;
+                    try (Txn<ByteBuffer> txn = env.txnRead();
+                            CursorIterable<ByteBuffer> c = dbi.iterate(txn, keyRange)) {
+                        for (final KeyVal<ByteBuffer> kv : c) {
+                            if (first) {
+                                first = false;
+                            } else {
+                                writer.append(",");
+                            }
+
+                            final int key = kv.key().getInt();
+                            final int val = kv.val().getInt();
+                            writer.append(" [");
+                            writer.append(String.valueOf(key));
+                            writer.append(",");
+                            writer.append(String.valueOf(val));
+                            writer.append("]");
+                        }
+                    }
+                    writer.append("\n");
+                }
+            }
+
+            // Compare files.
+            final String act = readFile(actual);
+            final String exp = readFile(expected);
+            assertThat("Files are not equal", act.equals(exp));
+        } finally {
+            deleteFile(dbPath);
+        }
+    }
+
+    private void populateDatabase(final Env<ByteBuffer> env,
+                                  final Dbi<ByteBuffer> dbi,
+                                  final int copies) {
+        try (Txn<ByteBuffer> txn = env.txnWrite()) {
+            final Cursor<ByteBuffer> c = dbi.openCursor(txn);
+            for (int i = 0; i < copies; i++) {
+                c.put(bb(0), bb(1 + i));
+                c.put(bb(2), bb(3 + i));
+                c.put(bb(4), bb(5 + i));
+                c.put(bb(6), bb(7 + i));
+                c.put(bb(8), bb(9 + i));
+                c.put(bb(-2), bb(-1 + i));
+            }
+            txn.commit();
+        }
+    }
+
+    private String readFile(final File file) throws IOException {
+        final StringBuilder result = new StringBuilder();
+        try (final Reader reader = new FileReader(file)) {
+            final char[] cbuf = new char[4096];
+            int nread;
+            while ((nread = reader.read(cbuf, 0, cbuf.length)) != -1) {
+                result.append(cbuf, 0, nread);
+            }
+        }
+        return result.toString();
+    }
+
+    private boolean recursiveDeleteFiles(Path file) {
+        if (deleteFile(file)) {
+            return true;
+        } else {
+            try (final Stream<Path> stream = Files.list(file)) {
+                stream.forEach(this::recursiveDeleteFiles);
+            } catch (final IOException e) {
+                return false;
+            }
+            return deleteFile(file);
+        }
+    }
+
+    private boolean deleteFile(Path file) {
+        try {
+            Files.delete(file);
+        } catch (final IOException e) {
+            return false;
+        }
+        return true;
+    }
+}
diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index bd23bc55..595898e2 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -73,6 +73,32 @@ public final class CursorIterableTest {
   private Env<ByteBuffer> env;
   private Deque<Integer> list;
 
+    @Before
+    public void before() throws IOException {
+        final File path = tmp.newFile();
+        env =
+                create()
+                        .setMapSize(KIBIBYTES.toBytes(256))
+                        .setMaxReaders(1)
+                        .setMaxDbs(1)
+                        .open(path, POSIX_MODE, MDB_NOSUBDIR);
+        db = env.openDbi(DB_1, MDB_CREATE);
+        populateDatabase(db);
+    }
+
+    private void populateDatabase(final Dbi<ByteBuffer> dbi) {
+        list = new LinkedList<>();
+        list.addAll(asList(2, 3, 4, 5, 6, 7, 8, 9));
+        try (Txn<ByteBuffer> txn = env.txnWrite()) {
+            final Cursor<ByteBuffer> c = dbi.openCursor(txn);
+            c.put(bb(2), bb(3), MDB_NOOVERWRITE);
+            c.put(bb(4), bb(5));
+            c.put(bb(6), bb(7));
+            c.put(bb(8), bb(9));
+            txn.commit();
+        }
+    }
+
   @After
   public void after() {
     env.close();
@@ -113,32 +139,6 @@ public void atMostTest() {
     verify(atMost(bb(6)), 2, 4, 6);
   }
 
-  @Before
-  public void before() throws IOException {
-    final File path = tmp.newFile();
-    env =
-        create()
-            .setMapSize(KIBIBYTES.toBytes(256))
-            .setMaxReaders(1)
-            .setMaxDbs(1)
-            .open(path, POSIX_MODE, MDB_NOSUBDIR);
-    db = env.openDbi(DB_1, MDB_CREATE);
-    populateDatabase(db);
-  }
-
-  private void populateDatabase(final Dbi<ByteBuffer> dbi) {
-    list = new LinkedList<>();
-    list.addAll(asList(2, 3, 4, 5, 6, 7, 8, 9));
-    try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      final Cursor<ByteBuffer> c = dbi.openCursor(txn);
-      c.put(bb(2), bb(3), MDB_NOOVERWRITE);
-      c.put(bb(4), bb(5));
-      c.put(bb(6), bb(7));
-      c.put(bb(8), bb(9));
-      txn.commit();
-    }
-  }
-
   @Test
   public void closedBackwardTest() {
     verify(closedBackward(bb(7), bb(3)), 6, 4);
diff --git a/src/test/resources/CursorIterableRangeTest/testSignedComparator.actual b/src/test/resources/CursorIterableRangeTest/testSignedComparator.actual
new file mode 100644
index 00000000..5968c07f
--- /dev/null
+++ b/src/test/resources/CursorIterableRangeTest/testSignedComparator.actual
@@ -0,0 +1,49 @@
+FORWARD_ALL, , => [-2,-1], [0,1], [2,3], [4,5], [6,7], [8,9]
+FORWARD_AT_LEAST, 5, => [6,7], [8,9]
+FORWARD_AT_LEAST, 6, => [6,7], [8,9]
+FORWARD_AT_MOST, , 5 => [-2,-1], [0,1], [2,3], [4,5]
+FORWARD_AT_MOST, , 6 => [-2,-1], [0,1], [2,3], [4,5], [6,7]
+FORWARD_CLOSED, 3, 7 => [4,5], [6,7]
+FORWARD_CLOSED, 2, 6 => [2,3], [4,5], [6,7]
+FORWARD_CLOSED, 1, 7 => [2,3], [4,5], [6,7]
+FORWARD_CLOSED_OPEN, 3, 8 => [4,5], [6,7]
+FORWARD_CLOSED_OPEN, 2, 6 => [2,3], [4,5]
+FORWARD_GREATER_THAN, 4, => [6,7], [8,9]
+FORWARD_GREATER_THAN, 3, => [4,5], [6,7], [8,9]
+FORWARD_LESS_THAN, , 5 => [-2,-1], [0,1], [2,3], [4,5]
+FORWARD_LESS_THAN, , 8 => [-2,-1], [0,1], [2,3], [4,5], [6,7]
+FORWARD_OPEN, 3, 7 => [4,5], [6,7]
+FORWARD_OPEN, 2, 8 => [4,5], [6,7]
+FORWARD_OPEN_CLOSED, 3, 8 => [4,5], [6,7], [8,9]
+FORWARD_OPEN_CLOSED, 2, 6 => [4,5], [6,7]
+BACKWARD_ALL, , => [8,9], [6,7], [4,5], [2,3], [0,1], [-2,-1]
+BACKWARD_AT_LEAST, 5, => [4,5], [2,3], [0,1], [-2,-1]
+BACKWARD_AT_LEAST, 6, => [6,7], [4,5], [2,3], [0,1], [-2,-1]
+BACKWARD_AT_LEAST, 9, => [8,9], [6,7], [4,5], [2,3], [0,1], [-2,-1]
+BACKWARD_AT_LEAST, -1, => [-2,-1]
+BACKWARD_AT_MOST, , 5 => [8,9], [6,7]
+BACKWARD_AT_MOST, , 6 => [8,9], [6,7]
+BACKWARD_AT_MOST, , -1 => [8,9], [6,7], [4,5], [2,3], [0,1]
+BACKWARD_CLOSED, 7, 3 => [6,7], [4,5]
+BACKWARD_CLOSED, 6, 2 => [6,7], [4,5], [2,3]
+BACKWARD_CLOSED, 9, 3 => [8,9], [6,7], [4,5]
+BACKWARD_CLOSED, 9, -1 => [8,9], [6,7], [4,5], [2,3], [0,1]
+BACKWARD_CLOSED_OPEN, 8, 3 => [8,9], [6,7], [4,5]
+BACKWARD_CLOSED_OPEN, 7, 2 => [6,7], [4,5]
+BACKWARD_CLOSED_OPEN, 9, 3 => [8,9], [6,7], [4,5]
+BACKWARD_CLOSED_OPEN, 9, -1 => [8,9], [6,7], [4,5], [2,3], [0,1]
+BACKWARD_GREATER_THAN, 6, => [4,5], [2,3], [0,1], [-2,-1]
+BACKWARD_GREATER_THAN, 7, => [6,7], [4,5], [2,3], [0,1], [-2,-1]
+BACKWARD_GREATER_THAN, 9, => [8,9], [6,7], [4,5], [2,3], [0,1], [-2,-1]
+BACKWARD_GREATER_THAN, -1, => [-2,-1]
+BACKWARD_LESS_THAN, , 5 => [8,9], [6,7]
+BACKWARD_LESS_THAN, , 2 => [8,9], [6,7], [4,5]
+BACKWARD_LESS_THAN, , -1 => [8,9], [6,7], [4,5], [2,3], [0,1]
+BACKWARD_OPEN, 7, 2 => [6,7], [4,5]
+BACKWARD_OPEN, 8, 1 => [6,7], [4,5], [2,3]
+BACKWARD_OPEN, 9, 4 => [8,9], [6,7]
+BACKWARD_OPEN, 9, -1 => [8,9], [6,7], [4,5], [2,3], [0,1]
+BACKWARD_OPEN_CLOSED, 7, 2 => [6,7], [4,5], [2,3]
+BACKWARD_OPEN_CLOSED, 8, 4 => [6,7], [4,5]
+BACKWARD_OPEN_CLOSED, 9, 4 => [8,9], [6,7], [4,5]
+BACKWARD_OPEN_CLOSED, 9, -1 => [8,9], [6,7], [4,5], [2,3], [0,1]
diff --git a/src/test/resources/CursorIterableRangeTest/testSignedComparator.expected b/src/test/resources/CursorIterableRangeTest/testSignedComparator.expected
new file mode 100644
index 00000000..5968c07f
--- /dev/null
+++ b/src/test/resources/CursorIterableRangeTest/testSignedComparator.expected
@@ -0,0 +1,49 @@
+FORWARD_ALL, , => [-2,-1], [0,1], [2,3], [4,5], [6,7], [8,9]
+FORWARD_AT_LEAST, 5, => [6,7], [8,9]
+FORWARD_AT_LEAST, 6, => [6,7], [8,9]
+FORWARD_AT_MOST, , 5 => [-2,-1], [0,1], [2,3], [4,5]
+FORWARD_AT_MOST, , 6 => [-2,-1], [0,1], [2,3], [4,5], [6,7]
+FORWARD_CLOSED, 3, 7 => [4,5], [6,7]
+FORWARD_CLOSED, 2, 6 => [2,3], [4,5], [6,7]
+FORWARD_CLOSED, 1, 7 => [2,3], [4,5], [6,7]
+FORWARD_CLOSED_OPEN, 3, 8 => [4,5], [6,7]
+FORWARD_CLOSED_OPEN, 2, 6 => [2,3], [4,5]
+FORWARD_GREATER_THAN, 4, => [6,7], [8,9]
+FORWARD_GREATER_THAN, 3, => [4,5], [6,7], [8,9]
+FORWARD_LESS_THAN, , 5 => [-2,-1], [0,1], [2,3], [4,5]
+FORWARD_LESS_THAN, , 8 => [-2,-1], [0,1], [2,3], [4,5], [6,7]
+FORWARD_OPEN, 3, 7 => [4,5], [6,7]
+FORWARD_OPEN, 2, 8 => [4,5], [6,7]
+FORWARD_OPEN_CLOSED, 3, 8 => [4,5], [6,7], [8,9]
+FORWARD_OPEN_CLOSED, 2, 6 => [4,5], [6,7]
+BACKWARD_ALL, , => [8,9], [6,7], [4,5], [2,3], [0,1], [-2,-1]
+BACKWARD_AT_LEAST, 5, => [4,5], [2,3], [0,1], [-2,-1]
+BACKWARD_AT_LEAST, 6, => [6,7], [4,5], [2,3], [0,1], [-2,-1]
+BACKWARD_AT_LEAST, 9, => [8,9], [6,7], [4,5], [2,3], [0,1], [-2,-1]
+BACKWARD_AT_LEAST, -1, => [-2,-1]
+BACKWARD_AT_MOST, , 5 => [8,9], [6,7]
+BACKWARD_AT_MOST, , 6 => [8,9], [6,7]
+BACKWARD_AT_MOST, , -1 => [8,9], [6,7], [4,5], [2,3], [0,1]
+BACKWARD_CLOSED, 7, 3 => [6,7], [4,5]
+BACKWARD_CLOSED, 6, 2 => [6,7], [4,5], [2,3]
+BACKWARD_CLOSED, 9, 3 => [8,9], [6,7], [4,5]
+BACKWARD_CLOSED, 9, -1 => [8,9], [6,7], [4,5], [2,3], [0,1]
+BACKWARD_CLOSED_OPEN, 8, 3 => [8,9], [6,7], [4,5]
+BACKWARD_CLOSED_OPEN, 7, 2 => [6,7], [4,5]
+BACKWARD_CLOSED_OPEN, 9, 3 => [8,9], [6,7], [4,5]
+BACKWARD_CLOSED_OPEN, 9, -1 => [8,9], [6,7], [4,5], [2,3], [0,1]
+BACKWARD_GREATER_THAN, 6, => [4,5], [2,3], [0,1], [-2,-1]
+BACKWARD_GREATER_THAN, 7, => [6,7], [4,5], [2,3], [0,1], [-2,-1]
+BACKWARD_GREATER_THAN, 9, => [8,9], [6,7], [4,5], [2,3], [0,1], [-2,-1]
+BACKWARD_GREATER_THAN, -1, => [-2,-1]
+BACKWARD_LESS_THAN, , 5 => [8,9], [6,7]
+BACKWARD_LESS_THAN, , 2 => [8,9], [6,7], [4,5]
+BACKWARD_LESS_THAN, , -1 => [8,9], [6,7], [4,5], [2,3], [0,1]
+BACKWARD_OPEN, 7, 2 => [6,7], [4,5]
+BACKWARD_OPEN, 8, 1 => [6,7], [4,5], [2,3]
+BACKWARD_OPEN, 9, 4 => [8,9], [6,7]
+BACKWARD_OPEN, 9, -1 => [8,9], [6,7], [4,5], [2,3], [0,1]
+BACKWARD_OPEN_CLOSED, 7, 2 => [6,7], [4,5], [2,3]
+BACKWARD_OPEN_CLOSED, 8, 4 => [6,7], [4,5]
+BACKWARD_OPEN_CLOSED, 9, 4 => [8,9], [6,7], [4,5]
+BACKWARD_OPEN_CLOSED, 9, -1 => [8,9], [6,7], [4,5], [2,3], [0,1]
diff --git a/src/test/resources/CursorIterableRangeTest/testSignedComparatorDupsort.actual b/src/test/resources/CursorIterableRangeTest/testSignedComparatorDupsort.actual
new file mode 100644
index 00000000..9f7a6709
--- /dev/null
+++ b/src/test/resources/CursorIterableRangeTest/testSignedComparatorDupsort.actual
@@ -0,0 +1,49 @@
+FORWARD_ALL, , => [-2,0], [-2,-1], [0,1], [0,2], [2,3], [2,4], [4,5], [4,6], [6,7], [6,8], [8,9], [8,10]
+FORWARD_AT_LEAST, 5, => [6,7], [6,8], [8,9], [8,10]
+FORWARD_AT_LEAST, 6, => [6,7], [6,8], [8,9], [8,10]
+FORWARD_AT_MOST, , 5 => [-2,0], [-2,-1], [0,1], [0,2], [2,3], [2,4], [4,5], [4,6]
+FORWARD_AT_MOST, , 6 => [-2,0], [-2,-1], [0,1], [0,2], [2,3], [2,4], [4,5], [4,6], [6,7], [6,8]
+FORWARD_CLOSED, 3, 7 => [4,5], [4,6], [6,7], [6,8]
+FORWARD_CLOSED, 2, 6 => [2,3], [2,4], [4,5], [4,6], [6,7], [6,8]
+FORWARD_CLOSED, 1, 7 => [2,3], [2,4], [4,5], [4,6], [6,7], [6,8]
+FORWARD_CLOSED_OPEN, 3, 8 => [4,5], [4,6], [6,7], [6,8]
+FORWARD_CLOSED_OPEN, 2, 6 => [2,3], [2,4], [4,5], [4,6]
+FORWARD_GREATER_THAN, 4, => [6,7], [6,8], [8,9], [8,10]
+FORWARD_GREATER_THAN, 3, => [4,5], [4,6], [6,7], [6,8], [8,9], [8,10]
+FORWARD_LESS_THAN, , 5 => [-2,0], [-2,-1], [0,1], [0,2], [2,3], [2,4], [4,5], [4,6]
+FORWARD_LESS_THAN, , 8 => [-2,0], [-2,-1], [0,1], [0,2], [2,3], [2,4], [4,5], [4,6], [6,7], [6,8]
+FORWARD_OPEN, 3, 7 => [4,5], [4,6], [6,7], [6,8]
+FORWARD_OPEN, 2, 8 => [4,5], [4,6], [6,7], [6,8]
+FORWARD_OPEN_CLOSED, 3, 8 => [4,5], [4,6], [6,7], [6,8], [8,9], [8,10]
+FORWARD_OPEN_CLOSED, 2, 6 => [4,5], [4,6], [6,7], [6,8]
+BACKWARD_ALL, , => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1], [-2,-1], [-2,0]
+BACKWARD_AT_LEAST, 5, => [4,6], [4,5], [2,4], [2,3], [0,2], [0,1], [-2,-1], [-2,0]
+BACKWARD_AT_LEAST, 6, => [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1], [-2,-1], [-2,0]
+BACKWARD_AT_LEAST, 9, => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1], [-2,-1], [-2,0]
+BACKWARD_AT_LEAST, -1, => [-2,-1], [-2,0]
+BACKWARD_AT_MOST, , 5 => [8,10], [8,9], [6,8], [6,7]
+BACKWARD_AT_MOST, , 6 => [8,10], [8,9], [6,8], [6,7]
+BACKWARD_AT_MOST, , -1 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_CLOSED, 7, 3 => [6,8], [6,7], [4,6], [4,5]
+BACKWARD_CLOSED, 6, 2 => [6,7], [4,6], [4,5], [2,4], [2,3]
+BACKWARD_CLOSED, 9, 3 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5]
+BACKWARD_CLOSED, 9, -1 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_CLOSED_OPEN, 8, 3 => [8,9], [6,8], [6,7], [4,6], [4,5]
+BACKWARD_CLOSED_OPEN, 7, 2 => [6,8], [6,7], [4,6], [4,5]
+BACKWARD_CLOSED_OPEN, 9, 3 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5]
+BACKWARD_CLOSED_OPEN, 9, -1 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_GREATER_THAN, 6, => [4,6], [4,5], [2,4], [2,3], [0,2], [0,1], [-2,-1], [-2,0]
+BACKWARD_GREATER_THAN, 7, => [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1], [-2,-1], [-2,0]
+BACKWARD_GREATER_THAN, 9, => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1], [-2,-1], [-2,0]
+BACKWARD_GREATER_THAN, -1, => [-2,-1], [-2,0]
+BACKWARD_LESS_THAN, , 5 => [8,10], [8,9], [6,8], [6,7]
+BACKWARD_LESS_THAN, , 2 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5]
+BACKWARD_LESS_THAN, , -1 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_OPEN, 7, 2 => [6,8], [6,7], [4,6], [4,5]
+BACKWARD_OPEN, 8, 1 => [6,8], [6,7], [4,6], [4,5], [2,4], [2,3]
+BACKWARD_OPEN, 9, 4 => [8,10], [8,9], [6,8], [6,7]
+BACKWARD_OPEN, 9, -1 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_OPEN_CLOSED, 7, 2 => [6,8], [6,7], [4,6], [4,5], [2,4], [2,3]
+BACKWARD_OPEN_CLOSED, 8, 4 => [6,8], [6,7], [4,6], [4,5]
+BACKWARD_OPEN_CLOSED, 9, 4 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5]
+BACKWARD_OPEN_CLOSED, 9, -1 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
diff --git a/src/test/resources/CursorIterableRangeTest/testSignedComparatorDupsort.expected b/src/test/resources/CursorIterableRangeTest/testSignedComparatorDupsort.expected
new file mode 100644
index 00000000..9f7a6709
--- /dev/null
+++ b/src/test/resources/CursorIterableRangeTest/testSignedComparatorDupsort.expected
@@ -0,0 +1,49 @@
+FORWARD_ALL, , => [-2,0], [-2,-1], [0,1], [0,2], [2,3], [2,4], [4,5], [4,6], [6,7], [6,8], [8,9], [8,10]
+FORWARD_AT_LEAST, 5, => [6,7], [6,8], [8,9], [8,10]
+FORWARD_AT_LEAST, 6, => [6,7], [6,8], [8,9], [8,10]
+FORWARD_AT_MOST, , 5 => [-2,0], [-2,-1], [0,1], [0,2], [2,3], [2,4], [4,5], [4,6]
+FORWARD_AT_MOST, , 6 => [-2,0], [-2,-1], [0,1], [0,2], [2,3], [2,4], [4,5], [4,6], [6,7], [6,8]
+FORWARD_CLOSED, 3, 7 => [4,5], [4,6], [6,7], [6,8]
+FORWARD_CLOSED, 2, 6 => [2,3], [2,4], [4,5], [4,6], [6,7], [6,8]
+FORWARD_CLOSED, 1, 7 => [2,3], [2,4], [4,5], [4,6], [6,7], [6,8]
+FORWARD_CLOSED_OPEN, 3, 8 => [4,5], [4,6], [6,7], [6,8]
+FORWARD_CLOSED_OPEN, 2, 6 => [2,3], [2,4], [4,5], [4,6]
+FORWARD_GREATER_THAN, 4, => [6,7], [6,8], [8,9], [8,10]
+FORWARD_GREATER_THAN, 3, => [4,5], [4,6], [6,7], [6,8], [8,9], [8,10]
+FORWARD_LESS_THAN, , 5 => [-2,0], [-2,-1], [0,1], [0,2], [2,3], [2,4], [4,5], [4,6]
+FORWARD_LESS_THAN, , 8 => [-2,0], [-2,-1], [0,1], [0,2], [2,3], [2,4], [4,5], [4,6], [6,7], [6,8]
+FORWARD_OPEN, 3, 7 => [4,5], [4,6], [6,7], [6,8]
+FORWARD_OPEN, 2, 8 => [4,5], [4,6], [6,7], [6,8]
+FORWARD_OPEN_CLOSED, 3, 8 => [4,5], [4,6], [6,7], [6,8], [8,9], [8,10]
+FORWARD_OPEN_CLOSED, 2, 6 => [4,5], [4,6], [6,7], [6,8]
+BACKWARD_ALL, , => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1], [-2,-1], [-2,0]
+BACKWARD_AT_LEAST, 5, => [4,6], [4,5], [2,4], [2,3], [0,2], [0,1], [-2,-1], [-2,0]
+BACKWARD_AT_LEAST, 6, => [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1], [-2,-1], [-2,0]
+BACKWARD_AT_LEAST, 9, => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1], [-2,-1], [-2,0]
+BACKWARD_AT_LEAST, -1, => [-2,-1], [-2,0]
+BACKWARD_AT_MOST, , 5 => [8,10], [8,9], [6,8], [6,7]
+BACKWARD_AT_MOST, , 6 => [8,10], [8,9], [6,8], [6,7]
+BACKWARD_AT_MOST, , -1 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_CLOSED, 7, 3 => [6,8], [6,7], [4,6], [4,5]
+BACKWARD_CLOSED, 6, 2 => [6,7], [4,6], [4,5], [2,4], [2,3]
+BACKWARD_CLOSED, 9, 3 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5]
+BACKWARD_CLOSED, 9, -1 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_CLOSED_OPEN, 8, 3 => [8,9], [6,8], [6,7], [4,6], [4,5]
+BACKWARD_CLOSED_OPEN, 7, 2 => [6,8], [6,7], [4,6], [4,5]
+BACKWARD_CLOSED_OPEN, 9, 3 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5]
+BACKWARD_CLOSED_OPEN, 9, -1 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_GREATER_THAN, 6, => [4,6], [4,5], [2,4], [2,3], [0,2], [0,1], [-2,-1], [-2,0]
+BACKWARD_GREATER_THAN, 7, => [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1], [-2,-1], [-2,0]
+BACKWARD_GREATER_THAN, 9, => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1], [-2,-1], [-2,0]
+BACKWARD_GREATER_THAN, -1, => [-2,-1], [-2,0]
+BACKWARD_LESS_THAN, , 5 => [8,10], [8,9], [6,8], [6,7]
+BACKWARD_LESS_THAN, , 2 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5]
+BACKWARD_LESS_THAN, , -1 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_OPEN, 7, 2 => [6,8], [6,7], [4,6], [4,5]
+BACKWARD_OPEN, 8, 1 => [6,8], [6,7], [4,6], [4,5], [2,4], [2,3]
+BACKWARD_OPEN, 9, 4 => [8,10], [8,9], [6,8], [6,7]
+BACKWARD_OPEN, 9, -1 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_OPEN_CLOSED, 7, 2 => [6,8], [6,7], [4,6], [4,5], [2,4], [2,3]
+BACKWARD_OPEN_CLOSED, 8, 4 => [6,8], [6,7], [4,6], [4,5]
+BACKWARD_OPEN_CLOSED, 9, 4 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5]
+BACKWARD_OPEN_CLOSED, 9, -1 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
diff --git a/src/test/resources/CursorIterableRangeTest/testUnsignedComparator.actual b/src/test/resources/CursorIterableRangeTest/testUnsignedComparator.actual
new file mode 100644
index 00000000..1be8d951
--- /dev/null
+++ b/src/test/resources/CursorIterableRangeTest/testUnsignedComparator.actual
@@ -0,0 +1,49 @@
+FORWARD_ALL, , => [0,1], [2,3], [4,5], [6,7], [8,9], [-2,-1]
+FORWARD_AT_LEAST, 5, => [6,7], [8,9], [-2,-1]
+FORWARD_AT_LEAST, 6, => [6,7], [8,9], [-2,-1]
+FORWARD_AT_MOST, , 5 => [0,1], [2,3], [4,5]
+FORWARD_AT_MOST, , 6 => [0,1], [2,3], [4,5], [6,7]
+FORWARD_CLOSED, 3, 7 => [4,5], [6,7]
+FORWARD_CLOSED, 2, 6 => [2,3], [4,5], [6,7]
+FORWARD_CLOSED, 1, 7 => [2,3], [4,5], [6,7]
+FORWARD_CLOSED_OPEN, 3, 8 => [4,5], [6,7]
+FORWARD_CLOSED_OPEN, 2, 6 => [2,3], [4,5]
+FORWARD_GREATER_THAN, 4, => [6,7], [8,9], [-2,-1]
+FORWARD_GREATER_THAN, 3, => [4,5], [6,7], [8,9], [-2,-1]
+FORWARD_LESS_THAN, , 5 => [0,1], [2,3], [4,5]
+FORWARD_LESS_THAN, , 8 => [0,1], [2,3], [4,5], [6,7]
+FORWARD_OPEN, 3, 7 => [4,5], [6,7]
+FORWARD_OPEN, 2, 8 => [4,5], [6,7]
+FORWARD_OPEN_CLOSED, 3, 8 => [4,5], [6,7], [8,9]
+FORWARD_OPEN_CLOSED, 2, 6 => [4,5], [6,7]
+BACKWARD_ALL, , => [-2,-1], [8,9], [6,7], [4,5], [2,3], [0,1]
+BACKWARD_AT_LEAST, 5, => [4,5], [2,3], [0,1]
+BACKWARD_AT_LEAST, 6, => [6,7], [4,5], [2,3], [0,1]
+BACKWARD_AT_LEAST, 9, => [8,9], [6,7], [4,5], [2,3], [0,1]
+BACKWARD_AT_LEAST, -1, => [-2,-1], [8,9], [6,7], [4,5], [2,3], [0,1]
+BACKWARD_AT_MOST, , 5 => [-2,-1], [8,9], [6,7]
+BACKWARD_AT_MOST, , 6 => [-2,-1], [8,9], [6,7]
+BACKWARD_AT_MOST, , -1 =>
+BACKWARD_CLOSED, 7, 3 => [6,7], [4,5]
+BACKWARD_CLOSED, 6, 2 => [6,7], [4,5], [2,3]
+BACKWARD_CLOSED, 9, 3 => [8,9], [6,7], [4,5]
+BACKWARD_CLOSED, 9, -1 =>
+BACKWARD_CLOSED_OPEN, 8, 3 => [8,9], [6,7], [4,5]
+BACKWARD_CLOSED_OPEN, 7, 2 => [6,7], [4,5]
+BACKWARD_CLOSED_OPEN, 9, 3 => [8,9], [6,7], [4,5]
+BACKWARD_CLOSED_OPEN, 9, -1 =>
+BACKWARD_GREATER_THAN, 6, => [4,5], [2,3], [0,1]
+BACKWARD_GREATER_THAN, 7, => [6,7], [4,5], [2,3], [0,1]
+BACKWARD_GREATER_THAN, 9, => [8,9], [6,7], [4,5], [2,3], [0,1]
+BACKWARD_GREATER_THAN, -1, => [-2,-1], [8,9], [6,7], [4,5], [2,3], [0,1]
+BACKWARD_LESS_THAN, , 5 => [-2,-1], [8,9], [6,7]
+BACKWARD_LESS_THAN, , 2 => [-2,-1], [8,9], [6,7], [4,5]
+BACKWARD_LESS_THAN, , -1 =>
+BACKWARD_OPEN, 7, 2 => [6,7], [4,5]
+BACKWARD_OPEN, 8, 1 => [6,7], [4,5], [2,3]
+BACKWARD_OPEN, 9, 4 => [8,9], [6,7]
+BACKWARD_OPEN, 9, -1 =>
+BACKWARD_OPEN_CLOSED, 7, 2 => [6,7], [4,5], [2,3]
+BACKWARD_OPEN_CLOSED, 8, 4 => [6,7], [4,5]
+BACKWARD_OPEN_CLOSED, 9, 4 => [8,9], [6,7], [4,5]
+BACKWARD_OPEN_CLOSED, 9, -1 =>
diff --git a/src/test/resources/CursorIterableRangeTest/testUnsignedComparator.expected b/src/test/resources/CursorIterableRangeTest/testUnsignedComparator.expected
new file mode 100644
index 00000000..1be8d951
--- /dev/null
+++ b/src/test/resources/CursorIterableRangeTest/testUnsignedComparator.expected
@@ -0,0 +1,49 @@
+FORWARD_ALL, , => [0,1], [2,3], [4,5], [6,7], [8,9], [-2,-1]
+FORWARD_AT_LEAST, 5, => [6,7], [8,9], [-2,-1]
+FORWARD_AT_LEAST, 6, => [6,7], [8,9], [-2,-1]
+FORWARD_AT_MOST, , 5 => [0,1], [2,3], [4,5]
+FORWARD_AT_MOST, , 6 => [0,1], [2,3], [4,5], [6,7]
+FORWARD_CLOSED, 3, 7 => [4,5], [6,7]
+FORWARD_CLOSED, 2, 6 => [2,3], [4,5], [6,7]
+FORWARD_CLOSED, 1, 7 => [2,3], [4,5], [6,7]
+FORWARD_CLOSED_OPEN, 3, 8 => [4,5], [6,7]
+FORWARD_CLOSED_OPEN, 2, 6 => [2,3], [4,5]
+FORWARD_GREATER_THAN, 4, => [6,7], [8,9], [-2,-1]
+FORWARD_GREATER_THAN, 3, => [4,5], [6,7], [8,9], [-2,-1]
+FORWARD_LESS_THAN, , 5 => [0,1], [2,3], [4,5]
+FORWARD_LESS_THAN, , 8 => [0,1], [2,3], [4,5], [6,7]
+FORWARD_OPEN, 3, 7 => [4,5], [6,7]
+FORWARD_OPEN, 2, 8 => [4,5], [6,7]
+FORWARD_OPEN_CLOSED, 3, 8 => [4,5], [6,7], [8,9]
+FORWARD_OPEN_CLOSED, 2, 6 => [4,5], [6,7]
+BACKWARD_ALL, , => [-2,-1], [8,9], [6,7], [4,5], [2,3], [0,1]
+BACKWARD_AT_LEAST, 5, => [4,5], [2,3], [0,1]
+BACKWARD_AT_LEAST, 6, => [6,7], [4,5], [2,3], [0,1]
+BACKWARD_AT_LEAST, 9, => [8,9], [6,7], [4,5], [2,3], [0,1]
+BACKWARD_AT_LEAST, -1, => [-2,-1], [8,9], [6,7], [4,5], [2,3], [0,1]
+BACKWARD_AT_MOST, , 5 => [-2,-1], [8,9], [6,7]
+BACKWARD_AT_MOST, , 6 => [-2,-1], [8,9], [6,7]
+BACKWARD_AT_MOST, , -1 =>
+BACKWARD_CLOSED, 7, 3 => [6,7], [4,5]
+BACKWARD_CLOSED, 6, 2 => [6,7], [4,5], [2,3]
+BACKWARD_CLOSED, 9, 3 => [8,9], [6,7], [4,5]
+BACKWARD_CLOSED, 9, -1 =>
+BACKWARD_CLOSED_OPEN, 8, 3 => [8,9], [6,7], [4,5]
+BACKWARD_CLOSED_OPEN, 7, 2 => [6,7], [4,5]
+BACKWARD_CLOSED_OPEN, 9, 3 => [8,9], [6,7], [4,5]
+BACKWARD_CLOSED_OPEN, 9, -1 =>
+BACKWARD_GREATER_THAN, 6, => [4,5], [2,3], [0,1]
+BACKWARD_GREATER_THAN, 7, => [6,7], [4,5], [2,3], [0,1]
+BACKWARD_GREATER_THAN, 9, => [8,9], [6,7], [4,5], [2,3], [0,1]
+BACKWARD_GREATER_THAN, -1, => [-2,-1], [8,9], [6,7], [4,5], [2,3], [0,1]
+BACKWARD_LESS_THAN, , 5 => [-2,-1], [8,9], [6,7]
+BACKWARD_LESS_THAN, , 2 => [-2,-1], [8,9], [6,7], [4,5]
+BACKWARD_LESS_THAN, , -1 =>
+BACKWARD_OPEN, 7, 2 => [6,7], [4,5]
+BACKWARD_OPEN, 8, 1 => [6,7], [4,5], [2,3]
+BACKWARD_OPEN, 9, 4 => [8,9], [6,7]
+BACKWARD_OPEN, 9, -1 =>
+BACKWARD_OPEN_CLOSED, 7, 2 => [6,7], [4,5], [2,3]
+BACKWARD_OPEN_CLOSED, 8, 4 => [6,7], [4,5]
+BACKWARD_OPEN_CLOSED, 9, 4 => [8,9], [6,7], [4,5]
+BACKWARD_OPEN_CLOSED, 9, -1 =>
diff --git a/src/test/resources/CursorIterableRangeTest/testUnsignedComparatorDupsort.actual b/src/test/resources/CursorIterableRangeTest/testUnsignedComparatorDupsort.actual
new file mode 100644
index 00000000..15dcb9f9
--- /dev/null
+++ b/src/test/resources/CursorIterableRangeTest/testUnsignedComparatorDupsort.actual
@@ -0,0 +1,49 @@
+FORWARD_ALL, , => [0,1], [0,2], [2,3], [2,4], [4,5], [4,6], [6,7], [6,8], [8,9], [8,10], [-2,0], [-2,-1]
+FORWARD_AT_LEAST, 5, => [6,7], [6,8], [8,9], [8,10], [-2,0], [-2,-1]
+FORWARD_AT_LEAST, 6, => [6,7], [6,8], [8,9], [8,10], [-2,0], [-2,-1]
+FORWARD_AT_MOST, , 5 => [0,1], [0,2], [2,3], [2,4], [4,5], [4,6]
+FORWARD_AT_MOST, , 6 => [0,1], [0,2], [2,3], [2,4], [4,5], [4,6], [6,7], [6,8]
+FORWARD_CLOSED, 3, 7 => [4,5], [4,6], [6,7], [6,8]
+FORWARD_CLOSED, 2, 6 => [2,3], [2,4], [4,5], [4,6], [6,7], [6,8]
+FORWARD_CLOSED, 1, 7 => [2,3], [2,4], [4,5], [4,6], [6,7], [6,8]
+FORWARD_CLOSED_OPEN, 3, 8 => [4,5], [4,6], [6,7], [6,8]
+FORWARD_CLOSED_OPEN, 2, 6 => [2,3], [2,4], [4,5], [4,6]
+FORWARD_GREATER_THAN, 4, => [6,7], [6,8], [8,9], [8,10], [-2,0], [-2,-1]
+FORWARD_GREATER_THAN, 3, => [4,5], [4,6], [6,7], [6,8], [8,9], [8,10], [-2,0], [-2,-1]
+FORWARD_LESS_THAN, , 5 => [0,1], [0,2], [2,3], [2,4], [4,5], [4,6]
+FORWARD_LESS_THAN, , 8 => [0,1], [0,2], [2,3], [2,4], [4,5], [4,6], [6,7], [6,8]
+FORWARD_OPEN, 3, 7 => [4,5], [4,6], [6,7], [6,8]
+FORWARD_OPEN, 2, 8 => [4,5], [4,6], [6,7], [6,8]
+FORWARD_OPEN_CLOSED, 3, 8 => [4,5], [4,6], [6,7], [6,8], [8,9], [8,10]
+FORWARD_OPEN_CLOSED, 2, 6 => [4,5], [4,6], [6,7], [6,8]
+BACKWARD_ALL, , => [-2,-1], [-2,0], [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_AT_LEAST, 5, => [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_AT_LEAST, 6, => [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_AT_LEAST, 9, => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_AT_LEAST, -1, => [-2,-1], [-2,0], [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_AT_MOST, , 5 => [-2,-1], [-2,0], [8,10], [8,9], [6,8], [6,7]
+BACKWARD_AT_MOST, , 6 => [-2,-1], [-2,0], [8,10], [8,9], [6,8], [6,7]
+BACKWARD_AT_MOST, , -1 =>
+BACKWARD_CLOSED, 7, 3 => [6,8], [6,7], [4,6], [4,5]
+BACKWARD_CLOSED, 6, 2 => [6,7], [4,6], [4,5], [2,4], [2,3]
+BACKWARD_CLOSED, 9, 3 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5]
+BACKWARD_CLOSED, 9, -1 =>
+BACKWARD_CLOSED_OPEN, 8, 3 => [8,9], [6,8], [6,7], [4,6], [4,5]
+BACKWARD_CLOSED_OPEN, 7, 2 => [6,8], [6,7], [4,6], [4,5]
+BACKWARD_CLOSED_OPEN, 9, 3 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5]
+BACKWARD_CLOSED_OPEN, 9, -1 =>
+BACKWARD_GREATER_THAN, 6, => [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_GREATER_THAN, 7, => [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_GREATER_THAN, 9, => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_GREATER_THAN, -1, => [-2,-1], [-2,0], [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_LESS_THAN, , 5 => [-2,-1], [-2,0], [8,10], [8,9], [6,8], [6,7]
+BACKWARD_LESS_THAN, , 2 => [-2,-1], [-2,0], [8,10], [8,9], [6,8], [6,7], [4,6], [4,5]
+BACKWARD_LESS_THAN, , -1 =>
+BACKWARD_OPEN, 7, 2 => [6,8], [6,7], [4,6], [4,5]
+BACKWARD_OPEN, 8, 1 => [6,8], [6,7], [4,6], [4,5], [2,4], [2,3]
+BACKWARD_OPEN, 9, 4 => [8,10], [8,9], [6,8], [6,7]
+BACKWARD_OPEN, 9, -1 =>
+BACKWARD_OPEN_CLOSED, 7, 2 => [6,8], [6,7], [4,6], [4,5], [2,4], [2,3]
+BACKWARD_OPEN_CLOSED, 8, 4 => [6,8], [6,7], [4,6], [4,5]
+BACKWARD_OPEN_CLOSED, 9, 4 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5]
+BACKWARD_OPEN_CLOSED, 9, -1 =>
diff --git a/src/test/resources/CursorIterableRangeTest/testUnsignedComparatorDupsort.expected b/src/test/resources/CursorIterableRangeTest/testUnsignedComparatorDupsort.expected
new file mode 100644
index 00000000..15dcb9f9
--- /dev/null
+++ b/src/test/resources/CursorIterableRangeTest/testUnsignedComparatorDupsort.expected
@@ -0,0 +1,49 @@
+FORWARD_ALL, , => [0,1], [0,2], [2,3], [2,4], [4,5], [4,6], [6,7], [6,8], [8,9], [8,10], [-2,0], [-2,-1]
+FORWARD_AT_LEAST, 5, => [6,7], [6,8], [8,9], [8,10], [-2,0], [-2,-1]
+FORWARD_AT_LEAST, 6, => [6,7], [6,8], [8,9], [8,10], [-2,0], [-2,-1]
+FORWARD_AT_MOST, , 5 => [0,1], [0,2], [2,3], [2,4], [4,5], [4,6]
+FORWARD_AT_MOST, , 6 => [0,1], [0,2], [2,3], [2,4], [4,5], [4,6], [6,7], [6,8]
+FORWARD_CLOSED, 3, 7 => [4,5], [4,6], [6,7], [6,8]
+FORWARD_CLOSED, 2, 6 => [2,3], [2,4], [4,5], [4,6], [6,7], [6,8]
+FORWARD_CLOSED, 1, 7 => [2,3], [2,4], [4,5], [4,6], [6,7], [6,8]
+FORWARD_CLOSED_OPEN, 3, 8 => [4,5], [4,6], [6,7], [6,8]
+FORWARD_CLOSED_OPEN, 2, 6 => [2,3], [2,4], [4,5], [4,6]
+FORWARD_GREATER_THAN, 4, => [6,7], [6,8], [8,9], [8,10], [-2,0], [-2,-1]
+FORWARD_GREATER_THAN, 3, => [4,5], [4,6], [6,7], [6,8], [8,9], [8,10], [-2,0], [-2,-1]
+FORWARD_LESS_THAN, , 5 => [0,1], [0,2], [2,3], [2,4], [4,5], [4,6]
+FORWARD_LESS_THAN, , 8 => [0,1], [0,2], [2,3], [2,4], [4,5], [4,6], [6,7], [6,8]
+FORWARD_OPEN, 3, 7 => [4,5], [4,6], [6,7], [6,8]
+FORWARD_OPEN, 2, 8 => [4,5], [4,6], [6,7], [6,8]
+FORWARD_OPEN_CLOSED, 3, 8 => [4,5], [4,6], [6,7], [6,8], [8,9], [8,10]
+FORWARD_OPEN_CLOSED, 2, 6 => [4,5], [4,6], [6,7], [6,8]
+BACKWARD_ALL, , => [-2,-1], [-2,0], [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_AT_LEAST, 5, => [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_AT_LEAST, 6, => [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_AT_LEAST, 9, => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_AT_LEAST, -1, => [-2,-1], [-2,0], [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_AT_MOST, , 5 => [-2,-1], [-2,0], [8,10], [8,9], [6,8], [6,7]
+BACKWARD_AT_MOST, , 6 => [-2,-1], [-2,0], [8,10], [8,9], [6,8], [6,7]
+BACKWARD_AT_MOST, , -1 =>
+BACKWARD_CLOSED, 7, 3 => [6,8], [6,7], [4,6], [4,5]
+BACKWARD_CLOSED, 6, 2 => [6,7], [4,6], [4,5], [2,4], [2,3]
+BACKWARD_CLOSED, 9, 3 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5]
+BACKWARD_CLOSED, 9, -1 =>
+BACKWARD_CLOSED_OPEN, 8, 3 => [8,9], [6,8], [6,7], [4,6], [4,5]
+BACKWARD_CLOSED_OPEN, 7, 2 => [6,8], [6,7], [4,6], [4,5]
+BACKWARD_CLOSED_OPEN, 9, 3 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5]
+BACKWARD_CLOSED_OPEN, 9, -1 =>
+BACKWARD_GREATER_THAN, 6, => [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_GREATER_THAN, 7, => [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_GREATER_THAN, 9, => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_GREATER_THAN, -1, => [-2,-1], [-2,0], [8,10], [8,9], [6,8], [6,7], [4,6], [4,5], [2,4], [2,3], [0,2], [0,1]
+BACKWARD_LESS_THAN, , 5 => [-2,-1], [-2,0], [8,10], [8,9], [6,8], [6,7]
+BACKWARD_LESS_THAN, , 2 => [-2,-1], [-2,0], [8,10], [8,9], [6,8], [6,7], [4,6], [4,5]
+BACKWARD_LESS_THAN, , -1 =>
+BACKWARD_OPEN, 7, 2 => [6,8], [6,7], [4,6], [4,5]
+BACKWARD_OPEN, 8, 1 => [6,8], [6,7], [4,6], [4,5], [2,4], [2,3]
+BACKWARD_OPEN, 9, 4 => [8,10], [8,9], [6,8], [6,7]
+BACKWARD_OPEN, 9, -1 =>
+BACKWARD_OPEN_CLOSED, 7, 2 => [6,8], [6,7], [4,6], [4,5], [2,4], [2,3]
+BACKWARD_OPEN_CLOSED, 8, 4 => [6,8], [6,7], [4,6], [4,5]
+BACKWARD_OPEN_CLOSED, 9, 4 => [8,10], [8,9], [6,8], [6,7], [4,6], [4,5]
+BACKWARD_OPEN_CLOSED, 9, -1 =>
diff --git a/src/test/resources/CursorIterableRangeTest/tests.csv b/src/test/resources/CursorIterableRangeTest/tests.csv
new file mode 100644
index 00000000..0e103152
--- /dev/null
+++ b/src/test/resources/CursorIterableRangeTest/tests.csv
@@ -0,0 +1,49 @@
+FORWARD_ALL, ,
+FORWARD_AT_LEAST, 5,
+FORWARD_AT_LEAST, 6,
+FORWARD_AT_MOST, , 5
+FORWARD_AT_MOST, , 6
+FORWARD_CLOSED, 3, 7
+FORWARD_CLOSED, 2, 6
+FORWARD_CLOSED, 1, 7
+FORWARD_CLOSED_OPEN, 3, 8
+FORWARD_CLOSED_OPEN, 2, 6
+FORWARD_GREATER_THAN, 4,
+FORWARD_GREATER_THAN, 3,
+FORWARD_LESS_THAN, , 5
+FORWARD_LESS_THAN, , 8
+FORWARD_OPEN, 3, 7
+FORWARD_OPEN, 2, 8
+FORWARD_OPEN_CLOSED, 3, 8
+FORWARD_OPEN_CLOSED, 2, 6
+BACKWARD_ALL, ,
+BACKWARD_AT_LEAST, 5,
+BACKWARD_AT_LEAST, 6,
+BACKWARD_AT_LEAST, 9,
+BACKWARD_AT_LEAST, -1,
+BACKWARD_AT_MOST, , 5
+BACKWARD_AT_MOST, , 6
+BACKWARD_AT_MOST, , -1
+BACKWARD_CLOSED, 7, 3
+BACKWARD_CLOSED, 6, 2
+BACKWARD_CLOSED, 9, 3
+BACKWARD_CLOSED, 9, -1
+BACKWARD_CLOSED_OPEN, 8, 3
+BACKWARD_CLOSED_OPEN, 7, 2
+BACKWARD_CLOSED_OPEN, 9, 3
+BACKWARD_CLOSED_OPEN, 9, -1
+BACKWARD_GREATER_THAN, 6,
+BACKWARD_GREATER_THAN, 7,
+BACKWARD_GREATER_THAN, 9,
+BACKWARD_GREATER_THAN, -1,
+BACKWARD_LESS_THAN, , 5
+BACKWARD_LESS_THAN, , 2
+BACKWARD_LESS_THAN, , -1
+BACKWARD_OPEN, 7, 2
+BACKWARD_OPEN, 8, 1
+BACKWARD_OPEN, 9, 4
+BACKWARD_OPEN, 9, -1
+BACKWARD_OPEN_CLOSED, 7, 2
+BACKWARD_OPEN_CLOSED, 8, 4
+BACKWARD_OPEN_CLOSED, 9, 4
+BACKWARD_OPEN_CLOSED, 9, -1
\ No newline at end of file

From 0234d323244f874ccf12945949e6352879c5a3b3 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Tue, 28 Oct 2025 16:34:03 +0000
Subject: [PATCH 230/322] Replace get(Uns|S)ignedComparator with
 getComparator(DbiFlagSet)

Also improve javadoc and refactor some tests to use DbiBuilder.

Some tests are failing.
---
 src/main/java/org/lmdbjava/BufferProxy.java   |  45 +++-
 .../java/org/lmdbjava/ByteArrayProxy.java     |  17 +-
 src/main/java/org/lmdbjava/ByteBufProxy.java  |  15 +-
 .../java/org/lmdbjava/ByteBufferProxy.java    |  46 +++-
 .../java/org/lmdbjava/CursorIterable.java     |   4 +-
 src/main/java/org/lmdbjava/Dbi.java           |   7 +-
 src/main/java/org/lmdbjava/DbiBuilder.java    | 196 +++++++++++++-----
 src/main/java/org/lmdbjava/DbiFlags.java      |  20 +-
 .../java/org/lmdbjava/DirectBufferProxy.java  |  17 +-
 src/main/java/org/lmdbjava/Env.java           |  20 +-
 src/main/java/org/lmdbjava/Txn.java           |   2 +-
 src/main/java/org/lmdbjava/TxnFlags.java      |   1 +
 .../java/org/lmdbjava/ComparatorTest.java     |  10 +-
 .../CursorIterableIntegerKeyTest.java         | 121 ++++++-----
 .../org/lmdbjava/CursorIterablePerfTest.java  |  22 +-
 .../java/org/lmdbjava/CursorIterableTest.java | 111 +++++-----
 src/test/java/org/lmdbjava/DbiTest.java       |   8 +-
 .../java/org/lmdbjava/TestDbiBuilder.java     |   6 +-
 18 files changed, 448 insertions(+), 220 deletions(-)

diff --git a/src/main/java/org/lmdbjava/BufferProxy.java b/src/main/java/org/lmdbjava/BufferProxy.java
index 2ff5a8fc..60272209 100644
--- a/src/main/java/org/lmdbjava/BufferProxy.java
+++ b/src/main/java/org/lmdbjava/BufferProxy.java
@@ -66,26 +66,49 @@ protected BufferProxy() {}
   protected abstract byte[] getBytes(T buffer);
 
   /**
-   * Get a suitable default {@link Comparator} to compare numeric key values as signed.
+   * Get a suitable default {@link Comparator} given the provided flags.
    *
-   * <p>Note: LMDB's default comparator is unsigned so if this is used only for the {@link
-   * CursorIterable} start/stop key comparisons then its behaviour will differ from the iteration
-   * order. Use with caution.
+   * <p>The provided comparator must strictly match the lexicographical order of keys in the native
+   * LMDB database.
    *
+   * @param dbiFlagSet The {@link DbiFlags} set for the database.
    * @return a comparator that can be used (never null)
    */
-  public abstract Comparator<T> getSignedComparator();
+  public abstract Comparator<T> getComparator(final DbiFlagSet dbiFlagSet);
 
   /**
-   * Get a suitable default {@link Comparator} to compare numeric key values as unsigned.
-   * <p>
-   * This should match the behaviour of the LMDB's mdb_cmp comparator as it may be used for
-   * {@link CursorIterable} start/stop keys comparisons, which must match LMDB's insertion order.
-   * </p>
+   * Get a suitable default {@link Comparator}
+   *
+   * <p>The provided comparator must strictly match the lexicographical order of keys in the native
+   * LMDB database.
    *
    * @return a comparator that can be used (never null)
    */
-  public abstract Comparator<T> getUnsignedComparator();
+  public Comparator<T> getComparator() {
+    return getComparator(DbiFlagSet.empty());
+  }
+
+//  /**
+//   * Get a suitable default {@link Comparator} to compare numeric key values as signed.
+//   *
+//   * <p>Note: LMDB's default comparator is unsigned so if this is used only for the {@link
+//   * CursorIterable} start/stop key comparisons then its behaviour will differ from the iteration
+//   * order. Use with caution.
+//   *
+//   * @return a comparator that can be used (never null)
+//   */
+//  public abstract Comparator<T> getSignedComparator();
+//
+//  /**
+//   * Get a suitable default {@link Comparator} to compare numeric key values as unsigned.
+//   * <p>
+//   * This should match the behaviour of the LMDB's mdb_cmp comparator as it may be used for
+//   * {@link CursorIterable} start/stop keys comparisons, which must match LMDB's insertion order.
+//   * </p>
+//   *
+//   * @return a comparator that can be used (never null)
+//   */
+//  public abstract Comparator<T> getUnsignedComparator(final DbiFlagSet dbiFlagSet);
 
   /**
    * Called when the <code>MDB_val</code> should be set to reflect the passed buffer. This buffer
diff --git a/src/main/java/org/lmdbjava/ByteArrayProxy.java b/src/main/java/org/lmdbjava/ByteArrayProxy.java
index b4fb1e7b..5231ed51 100644
--- a/src/main/java/org/lmdbjava/ByteArrayProxy.java
+++ b/src/main/java/org/lmdbjava/ByteArrayProxy.java
@@ -104,15 +104,20 @@ protected byte[] getBytes(final byte[] buffer) {
   }
 
   @Override
-  public Comparator<byte[]> getSignedComparator() {
-    return signedComparator;
-  }
-
-  @Override
-  public Comparator<byte[]> getUnsignedComparator() {
+  public Comparator<byte[]> getComparator(final DbiFlagSet dbiFlagSet) {
     return unsignedComparator;
   }
 
+  //  @Override
+//  public Comparator<byte[]> getSignedComparator() {
+//    return signedComparator;
+//  }
+//
+//  @Override
+//  public Comparator<byte[]> getUnsignedComparator() {
+//    return unsignedComparator;
+//  }
+
   @Override
   protected Pointer in(final byte[] buffer, final Pointer ptr) {
     final Pointer pointer = MEM_MGR.allocateDirect(buffer.length);
diff --git a/src/main/java/org/lmdbjava/ByteBufProxy.java b/src/main/java/org/lmdbjava/ByteBufProxy.java
index e26bcb07..fc14b58f 100644
--- a/src/main/java/org/lmdbjava/ByteBufProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufProxy.java
@@ -114,14 +114,19 @@ protected ByteBuf allocate() {
   }
 
   @Override
-  public Comparator<ByteBuf> getSignedComparator() {
+  public Comparator<ByteBuf> getComparator(final DbiFlagSet dbiFlagSet) {
     return comparator;
   }
 
-  @Override
-  public Comparator<ByteBuf> getUnsignedComparator() {
-    return comparator;
-  }
+  //  @Override
+//  public Comparator<ByteBuf> getSignedComparator() {
+//    return comparator;
+//  }
+//
+//  @Override
+//  public Comparator<ByteBuf> getUnsignedComparator() {
+//    return comparator;
+//  }
 
   @Override
   protected void deallocate(final ByteBuf buff) {
diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
index d9edb6a8..4875572b 100644
--- a/src/main/java/org/lmdbjava/ByteBufferProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -148,6 +148,35 @@ public static int compareBuff(final ByteBuffer o1, final ByteBuffer o2) {
       return o1.remaining() - o2.remaining();
     }
 
+//    /**
+//     * Possible compareBuff method specifically for 4/8 byte keys when using MDB_INTEGER_KEY
+//     */
+//    public static int compareBuff(final ByteBuffer o1, final ByteBuffer o2) {
+//      requireNonNull(o1);
+//      requireNonNull(o2);
+//      // Both buffers should be same len
+//      final int len1 = o1.limit();
+//      final int len2 = o2.limit();
+//      if (len1 != len2) {
+//        throw new RuntimeException("Length mismatch, len1: " + len1 + ", len2: " + len2
+//            + ". Lengths must be identical and either 4 or 8 bytes.");
+//      }
+//      final boolean reverse1 = o1.order() == LITTLE_ENDIAN;
+//      final boolean reverse2 = o2.order() == LITTLE_ENDIAN;
+//      if (len1 == 8) {
+//          final long lw = reverse1 ? Long.reverseBytes(o1.getLong()) : o1.getLong();
+//          final long rw = reverse2 ? Long.reverseBytes(o2.getLong()) : o2.getLong();
+//          return Long.compareUnsigned(lw, rw);
+//      } else if (len1 == 4) {
+//        final int lw = reverse1 ? Integer.reverseBytes(o1.getInt()) : o1.getInt();
+//        final int rw = reverse2 ? Integer.reverseBytes(o2.getInt()) : o2.getInt();
+//          return Integer.compareUnsigned(lw, rw);
+//      } else {
+//        throw new RuntimeException("Unexpected length len1: " + len1 + ", len2: " + len2
+//            + ". Lengths must be identical and either 4 or 8 bytes.");
+//      }
+//    }
+
     static Field findField(final Class<?> c, final String name) {
       Class<?> clazz = c;
       do {
@@ -182,15 +211,20 @@ protected final ByteBuffer allocate() {
     }
 
     @Override
-    public Comparator<ByteBuffer> getSignedComparator() {
-      return signedComparator;
-    }
-
-    @Override
-    public Comparator<ByteBuffer> getUnsignedComparator() {
+    public Comparator<ByteBuffer> getComparator(DbiFlagSet dbiFlagSet) {
       return unsignedComparator;
     }
 
+    //    @Override
+//    public Comparator<ByteBuffer> getSignedComparator() {
+//      return signedComparator;
+//    }
+//
+//    @Override
+//    public Comparator<ByteBuffer> getUnsignedComparator(final DbiFlagSet dbiFlagSet) {
+//      return unsignedComparator;
+//    }
+
     @Override
     protected final void deallocate(final ByteBuffer buff) {
       buff.order(BIG_ENDIAN);
diff --git a/src/main/java/org/lmdbjava/CursorIterable.java b/src/main/java/org/lmdbjava/CursorIterable.java
index dd11a468..69d43fcd 100644
--- a/src/main/java/org/lmdbjava/CursorIterable.java
+++ b/src/main/java/org/lmdbjava/CursorIterable.java
@@ -60,10 +60,10 @@ public final class CursorIterable<T> implements Iterable<CursorIterable.KeyVal<T
     this.entry = new KeyVal<>();
 
     if (comparator != null) {
-      // User supplied java-side comparator so use that
+      // User supplied Java-side comparator so use that
       this.rangeComparator = new JavaRangeComparator<>(range, comparator, entry::key);
     } else {
-      // No java-side comparator so call down to LMDB to do the comparison
+      // No Java-side comparator, so call down to LMDB to do the comparison
       this.rangeComparator = new LmdbRangeComparator<>(txn, dbi, cursor, range, proxy);
     }
   }
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index 17fa4c46..9cdc03ee 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -51,6 +51,7 @@ public final class Dbi<T> {
 
   private final ComparatorCallback ccb;
   private boolean cleaned;
+  // Used for CursorIterable KeyRange testing and/or native callbacks
   private final Comparator<T> comparator;
   private final Env<T> env;
   private final byte[] name;
@@ -80,6 +81,7 @@ public final class Dbi<T> {
     ptr = dbiPtr.getPointer(0);
     if (nativeCb) {
       requireNonNull(comparator, "comparator cannot be null if nativeCb is set");
+      // LMDB will call back to this comparator for insertion/iteration order
       this.ccb =
           (keyA, keyB) -> {
             final T compKeyA  = proxy.out(proxy.allocate(), keyA);
@@ -465,6 +467,7 @@ private String getNameAsString() {
       return "";
     } else {
       try {
+        // Assume a UTF8 encoding as we don't know, thus swallow if it fails
         return new String(name, StandardCharsets.UTF_8);
       } catch (Exception e) {
         return "?";
@@ -475,8 +478,8 @@ private String getNameAsString() {
   @Override
   public String toString() {
     return "Dbi{" +
-            "name=" + getNameAsString() +
-            ", dbiFlagSet=" + dbiFlagSet +
+            "name='" + getNameAsString() +
+            "', dbiFlagSet=" + dbiFlagSet +
             '}';
   }
 
diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
index 7d05a51e..f2f925ce 100644
--- a/src/main/java/org/lmdbjava/DbiBuilder.java
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -98,8 +98,8 @@ public static class DbiBuilderStage2<T> {
 
     private final DbiBuilder<T> dbiBuilder;
 
-    private Comparator<T> comparator;
-    private boolean useNativeCallback;
+    private java.util.Comparator<T> customComparator;
+    private ComparatorType comparatorType;
 
     private DbiBuilderStage2(final DbiBuilder<T> dbiBuilder) {
       this.dbiBuilder = dbiBuilder;
@@ -107,95 +107,110 @@ private DbiBuilderStage2(final DbiBuilder<T> dbiBuilder) {
 
     /**
      * <p>
-     * {@link CursorIterable} will call down to LMDB's {@code mdb_cmp} method when
-     * comparing entries to start/stop keys. This ensures LmdbJava is comparing start/stop
-     * keys using the same comparator that is used for insert order into the db.
+     * This is the <strong>default</strong> choice when it comes to choosing a comparator.
+     * If you are not sure of the implications of the other methods then use this one as it
+     * is likely what you want and also probably the most performant.
      * </p>
      * <p>
-     * This option may be slightly less performant than when using
-     * {@link DbiBuilderStage2#withDefaultIteratorComparator()} as it need to call down
-     * to LMDB to perform the comparisons, however it guarantees that {@link CursorIterable}
-     * key comparison matches LMDB key comparison.
+     * With this option, {@link CursorIterable} will make use of the LmdbJava's default
+     * Java-side comparators when comparing iteration keys to the start/stop keys.
+     * LMDB will use its own comparator for controlling insertion order in the database.
+     * The two comparators are functionally identical.
+     * </p>
+     * <p>
+     * This option may be slightly more performant than when using
+     * {@link DbiBuilderStage2#withNativeComparator()} which calls down to LMDB for ALL
+     * comparison operations.
      * </p>
      * <p>
      * If you do not intend to use {@link CursorIterable} then it doesn't matter whether
      * you choose {@link DbiBuilderStage2#withNativeComparator()},
-     * {@link DbiBuilderStage2#withDefaultIteratorComparator()} or
+     * {@link DbiBuilderStage2#withDefaultComparator()} or
      * {@link DbiBuilderStage2#withIteratorComparator(Comparator)} as these comparators will
      * never be used.
      * </p>
      *
      * @return The next builder stage.
      */
-    public DbiBuilderStage3<T> withNativeComparator() {
-      this.comparator = null;
-      this.useNativeCallback = false;
+    public DbiBuilderStage3<T> withDefaultComparator() {
+      this.comparatorType = ComparatorType.DEFAULT;
       return new DbiBuilderStage3<>(this);
     }
 
     /**
      * <p>
-     * {@link CursorIterable} will make use of the default Java-side comparators when
-     * comparing entries to start/stop keys.
+     * With this option, {@link CursorIterable} will call down to LMDB's {@code mdb_cmp} method when
+     * comparing iteration keys to start/stop keys. This ensures LmdbJava is comparing start/stop
+     * keys using the same comparator that is used for insertion order into the db.
      * </p>
      * <p>
-     * This option may be slightly more performant than when using
-     * {@link DbiBuilderStage2#withNativeComparator()} but it relies on the default comparator
-     * in LmdbJava behaving identically to the comparator in LMDB.
+     * This option may be slightly less performant than when using
+     * {@link DbiBuilderStage2#withDefaultComparator()} as it needs to call down
+     * to LMDB to perform the comparisons, however it guarantees that {@link CursorIterable}
+     * key comparison matches LMDB key comparison.
      * </p>
      * <p>
      * If you do not intend to use {@link CursorIterable} then it doesn't matter whether
      * you choose {@link DbiBuilderStage2#withNativeComparator()},
-     * {@link DbiBuilderStage2#withDefaultIteratorComparator()} or
+     * {@link DbiBuilderStage2#withDefaultComparator()} or
      * {@link DbiBuilderStage2#withIteratorComparator(Comparator)} as these comparators will
      * never be used.
      * </p>
      *
      * @return The next builder stage.
      */
-    public DbiBuilderStage3<T> withDefaultIteratorComparator() {
-      this.comparator = dbiBuilder.proxy.getUnsignedComparator();
-      this.useNativeCallback = false;
+    public DbiBuilderStage3<T> withNativeComparator() {
+      this.comparatorType = ComparatorType.NATIVE;
       return new DbiBuilderStage3<>(this);
     }
 
+
     /**
-     * Provide a java-side {@link Comparator} that LMDB will call back to in order to
-     * manage database insertion/iteration order. It will also be used for {@link CursorIterable}
-     * start/stop key comparisons.
+     * Provide a java-side {@link Comparator} that LMDB will call back to for <strong>all</strong>
+     * comparison operations.
+     * Therefore, it will be called by LMDB to manage database insertion/iteration order.
+     * It will also be used for {@link CursorIterable} start/stop key comparisons.
      * <p>
-     * Due to calling back to java, this will be less performant than using LMDB's
-     * default comparator, but allows for total control over the order in which entries
+     * It can be useful if you need to sort your database using some other method,
+     * e.g. signed keys or case-insensitive order.
+     * Note, if you need keys stored in reverse order, see {@link DbiFlags#MDB_REVERSEKEY}
+     * and {@link DbiFlags#MDB_REVERSEDUP}.
+     * </p>
+     * <p>
+     * As this requires LMDB to call back to java, this will be less performant than using LMDB's
+     * default comparators, but allows for total control over the order in which entries
      * are stored in the database.
      * </p>
      *
      * @param comparator for all key comparison operations.
      * @return The next builder stage.
      */
-    public DbiBuilderStage3<T> withCallbackIteratorComparator(final Comparator<T> comparator) {
-      this.comparator = Objects.requireNonNull(comparator);
-      this.useNativeCallback = true;
+    public DbiBuilderStage3<T> withCallbackComparator(final Comparator<T> comparator) {
+      this.customComparator = Objects.requireNonNull(comparator);
+      this.comparatorType = ComparatorType.CALLBACK;
       return new DbiBuilderStage3<>(this);
     }
 
     /**
+     * <hr>
      * <p>
-     * {@link CursorIterable} will make use of the passed comparator for
-     * comparing entries to start/stop keys. It has NO bearing on the insert/iteration
-     * order of the db.
+     * <strong>WARNING</strong>: Only use this if you fully understand the risks and implications.
      * </p>
+     * <hr>
      * <p>
-     * <strong>WARNING:</strong> Only call this method if you fully understand the implications
-     * of using a comparator for the {@link CursorIterable} start/stop keys that behaves
-     * differently to the comparator in LMDB that controls the insert/iteration order.
+     * With this option, {@link CursorIterable} will make use of the passed comparator for
+     * comparing iteration keys to start/stop keys. It has <strong>NO</strong> bearing on the
+     * insert/iteration order of the database (which is controlled by LMDB's own comparators).
      * </p>
      * <p>
-     * The supplied {@link Comparator} should match the behaviour of LMDB's mdb_cmp comparator.
+     * It is <strong>vital</strong> that this comparator is functionally identical to the one
+     * used internally in LMDB for insertion/iteration order, else you will see unexpected behaviour
+     * when using {@link CursorIterable}.
      * </p>
      * <p>
      * If you do not intend to use {@link CursorIterable} then it doesn't matter whether
      * you choose {@link DbiBuilderStage2#withNativeComparator()},
-     * {@link DbiBuilderStage2#withDefaultIteratorComparator()} or
+     * {@link DbiBuilderStage2#withDefaultComparator()} or
      * {@link DbiBuilderStage2#withIteratorComparator(Comparator)} as these comparators will
      * never be used.
      * </p>
@@ -204,8 +219,8 @@ public DbiBuilderStage3<T> withCallbackIteratorComparator(final Comparator<T> co
      * @return The next builder stage.
      */
     public DbiBuilderStage3<T> withIteratorComparator(final Comparator<T> comparator) {
-      this.comparator = Objects.requireNonNull(comparator);
-      this.useNativeCallback = false;
+      this.customComparator = Objects.requireNonNull(comparator);
+      this.comparatorType = ComparatorType.ITERATOR;
       return new DbiBuilderStage3<>(this);
     }
   }
@@ -234,14 +249,18 @@ private DbiBuilderStage3(DbiBuilderStage2<T> dbiBuilderStage2) {
      * Apply all the dbi flags supplied in dbiFlags.
      * </p>
      * <p>
-     * Replaces any flags applies in previous calls to
-     * {@link DbiBuilderStage3#withDbiFlags(Collection)}, {@link DbiBuilderStage3#withDbiFlags(DbiFlags...)}
+     * Clears all flags currently set by previous calls to
+     * {@link DbiBuilderStage3#withDbiFlags(Collection)},
+     * {@link DbiBuilderStage3#withDbiFlags(DbiFlags...)}
      * or {@link DbiBuilderStage3#setDbiFlag(DbiFlags)}.
      * </p>
      *
      * @param dbiFlags to open the database with.
+     *                 A null {@link Collection} will just clear all set flags.
+     *                 Null items are ignored.
      */
     public DbiBuilderStage3<T> withDbiFlags(final Collection<DbiFlags> dbiFlags) {
+      flagSetBuilder.clear();
       if (dbiFlags != null) {
         dbiFlags.stream()
                 .filter(Objects::nonNull)
@@ -255,14 +274,15 @@ public DbiBuilderStage3<T> withDbiFlags(final Collection<DbiFlags> dbiFlags) {
      * Apply all the dbi flags supplied in dbiFlags.
      * </p>
      * <p>
-     * Replaces any flags applies in previous calls to
+     * Clears all flags currently set by previous calls to
      * {@link DbiBuilderStage3#withDbiFlags(Collection)},
      * {@link DbiBuilderStage3#withDbiFlags(DbiFlags...)}
      * or {@link DbiBuilderStage3#setDbiFlag(DbiFlags)}.
      * </p>
      *
      * @param dbiFlags to open the database with.
-     *                 A null array is a no-op. Null items are ignored.
+     *                 A null array will just clear all set flags.
+     *                 Null items are ignored.
      */
     public DbiBuilderStage3<T> withDbiFlags(final DbiFlags... dbiFlags) {
       flagSetBuilder.clear();
@@ -275,7 +295,29 @@ public DbiBuilderStage3<T> withDbiFlags(final DbiFlags... dbiFlags) {
     }
 
     /**
-     * Adds dbiFlag to those flags already added to this builder by
+     * <p>
+     * Apply all the dbi flags supplied in dbiFlags.
+     * </p>
+     * <p>
+     * Clears all flags currently set by previous calls to
+     * {@link DbiBuilderStage3#withDbiFlags(Collection)},
+     * {@link DbiBuilderStage3#withDbiFlags(DbiFlags...)}
+     * or {@link DbiBuilderStage3#setDbiFlag(DbiFlags)}.
+     * </p>
+     *
+     * @param dbiFlagSet to open the database with.
+     *                 A null value will just clear all set flags.
+     */
+    public DbiBuilderStage3<T> withDbiFlags(final DbiFlagSet dbiFlagSet) {
+      flagSetBuilder.clear();
+      if (dbiFlagSet != null) {
+        this.flagSetBuilder.withFlags(dbiFlagSet.getFlags());
+      }
+      return this;
+    }
+
+    /**
+     * Adds a dbiFlag to those flags already added to this builder by
      * {@link DbiBuilderStage3#withDbiFlags(DbiFlags...)},
      * {@link DbiBuilderStage3#withDbiFlags(Collection)}
      * or {@link DbiBuilderStage3#setDbiFlag(DbiFlags)}.
@@ -294,8 +336,15 @@ public DbiBuilderStage3<T> setDbiFlag(final DbiFlags dbiFlag) {
      * The caller MUST commit the transaction after calling {@link DbiBuilderStage3#open()},
      * in order to retain the <code>Dbi</code> in the <code>Env</code>.
      * </p>
+     * <p>
+     * If you don't call this method to supply a {@link Txn}, a {@link Txn} will be opened for the purpose
+     * of creating and opening the {@link Dbi}, then closed. Therefore, if you already have a transaction
+     * open, you should supply that to avoid one blocking the other.
+     * </p>
      *
-     * @param txn transaction to use (required; not closed)
+     * @param txn transaction to use (required; not closed). If the {@link Env} was opened
+     *            with the {@link EnvFlags#MDB_RDONLY_ENV} flag, the {@link Txn} can be read-only,
+     *            else it needs to be a read/write {@link Txn}.
      * @return this builder instance.
      */
     public DbiBuilderStage3<T> withTxn(final Txn<T> txn) {
@@ -329,18 +378,69 @@ private Txn<T> getTxn(final DbiBuilder<T> dbiBuilder) {
           : dbiBuilder.env.txnWrite();
     }
 
+    private Comparator<T> getComparator(final DbiBuilder<T> dbiBuilder,
+                                        final ComparatorType comparatorType,
+                                        final DbiFlagSet dbiFlagSet) {
+      Comparator<T> comparator = null;
+      switch (comparatorType) {
+        case DEFAULT:
+          // Get the appropriate default CursorIterable comparator based on the DbiFlags,
+          // e.g. MDB_INTEGERKEY may benefit from an optimised comparator.
+          comparator = dbiBuilder.proxy.getComparator(dbiFlagSet);
+          break;
+        case CALLBACK:
+        case ITERATOR:
+          comparator = dbiBuilderStage2.customComparator;
+          break;
+        case NATIVE:
+          break;
+        default:
+          throw new IllegalStateException("Unexpected comparatorType " + comparatorType);
+      }
+      return comparator;
+    }
+
     private Dbi<T> open(final Txn<T> txn,
                         final DbiBuilder<T> dbiBuilder) {
       final DbiFlagSet dbiFlagSet = flagSetBuilder.build();
+      final ComparatorType comparatorType = dbiBuilderStage2.comparatorType;
+      final Comparator<T> comparator = getComparator(dbiBuilder, comparatorType, dbiFlagSet);
+      final boolean useNativeCallback = comparatorType == ComparatorType.CALLBACK;
 
       return new Dbi<>(
           dbiBuilder.env,
           txn,
           dbiBuilder.name,
-          dbiBuilderStage2.comparator,
-          dbiBuilderStage2.useNativeCallback,
+          comparator,
+          useNativeCallback,
           dbiBuilder.proxy,
           dbiFlagSet);
     }
   }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  private enum ComparatorType {
+    /**
+     * Default Java comparator for {@link CursorIterable} KeyRange testing,
+     * LMDB comparator for insertion/iteration order.
+     */
+    DEFAULT,
+    /**
+     * Use LMDB native comparator for everything.
+     */
+    NATIVE,
+    /**
+     * Use the supplied custom Java-side comparator for everything.
+     */
+    CALLBACK,
+    /**
+     * Use the supplied custom Java-side comparator for {@link CursorIterable} KeyRange testing,
+     * LMDB comparator for insertion/iteration order.
+     */
+    ITERATOR,
+    ;
+  }
 }
diff --git a/src/main/java/org/lmdbjava/DbiFlags.java b/src/main/java/org/lmdbjava/DbiFlags.java
index 6e4b723d..10952da9 100644
--- a/src/main/java/org/lmdbjava/DbiFlags.java
+++ b/src/main/java/org/lmdbjava/DbiFlags.java
@@ -32,7 +32,7 @@ public enum DbiFlags implements MaskedFlag, DbiFlagSet {
    * Use sorted duplicates.
    *
    * <p>Duplicate keys may be used in the database. Or, from another perspective, keys may have
-   * multiple data items, stored in sorted order. By default keys must be unique and may have only a
+   * multiple data items, stored in sorted order. By default, keys must be unique and may have only a
    * single data item.
    * <p>
    *
@@ -40,8 +40,22 @@ public enum DbiFlags implements MaskedFlag, DbiFlagSet {
    */
   MDB_DUPSORT(0x04),
   /**
-   * Numeric keys in native byte order: either unsigned int or size_t. The keys must all be of the
-   * same size.
+   * Numeric keys in native byte order: either unsigned int or size_t.
+   * The keys must all be of the same size.
+   * <p>
+   * This is an optimisation that is available when your keys are 4 or 8 byte unsigned numeric values.
+   * There are performance benefits for both ordered and un-ordered puts as compared to not using
+   * this flag.
+   * </p>
+   * <p>
+   * When writing the key to the buffer you must write it in native order and subsequently read any
+   * keys retrieved from LMDB (via cursor or get method) also using native order.
+   * </p>
+   * <p>
+   * For more information, see
+   * <a href="https://github.com/lmdbjava/lmdbjava/wiki/Keys#numeric-keys">Numeric Keys</a>
+   * in the LmdbJava wiki.
+   * </p>
    */
   MDB_INTEGERKEY(0x08),
   /**
diff --git a/src/main/java/org/lmdbjava/DirectBufferProxy.java b/src/main/java/org/lmdbjava/DirectBufferProxy.java
index 1aab2573..514c04ab 100644
--- a/src/main/java/org/lmdbjava/DirectBufferProxy.java
+++ b/src/main/java/org/lmdbjava/DirectBufferProxy.java
@@ -111,15 +111,20 @@ protected DirectBuffer allocate() {
   }
 
   @Override
-  public Comparator<DirectBuffer> getSignedComparator() {
-    return signedComparator;
-  }
-
-  @Override
-  public Comparator<DirectBuffer> getUnsignedComparator() {
+  public Comparator<DirectBuffer> getComparator(final DbiFlagSet dbiFlagSet) {
     return unsignedComparator;
   }
 
+  //  @Override
+//  public Comparator<DirectBuffer> getSignedComparator() {
+//    return signedComparator;
+//  }
+//
+//  @Override
+//  public Comparator<DirectBuffer> getUnsignedComparator(final DbiFlagSet dbiFlagSet) {
+//    return unsignedComparator;
+//  }
+
   @Override
   protected void deallocate(final DirectBuffer buff) {
     final ArrayDeque<DirectBuffer> q = BUFFERS.get();
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 2ad929ad..efc4e240 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -270,13 +270,13 @@ public DbiBuilder<T> buildDbi() {
   }
 
   /**
+   * @deprecated Instead use {@link Env#buildDbi()}
    * Convenience method that opens a {@link Dbi} with a UTF-8 database name and default {@link
    * Comparator} that is not invoked from native code.
    *
    * @param name name of the database (or null if no name is required)
    * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#buildDbi()}
    */
   @Deprecated()
   public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
@@ -285,6 +285,7 @@ public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
   }
 
   /**
+   * @deprecated Instead use {@link Env#buildDbi()}
    * Convenience method that opens a {@link Dbi} with a UTF-8 database name and associated {@link
    * Comparator} for use by {@link CursorIterable} when comparing start/stop keys.
    *
@@ -298,7 +299,6 @@ public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
    *     comparator will be used.
    * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#buildDbi()}
    */
   @Deprecated()
   public Dbi<T> openDbi(
@@ -308,6 +308,7 @@ public Dbi<T> openDbi(
   }
 
   /**
+   * @deprecated Instead use {@link Env#buildDbi()}
    * Convenience method that opens a {@link Dbi} with a UTF-8 database name and associated {@link
    * Comparator}. The comparator will be used by {@link CursorIterable} when comparing start/stop
    * keys as a minimum. If nativeCb is {@code true}, this comparator will also be called by LMDB to
@@ -320,7 +321,6 @@ public Dbi<T> openDbi(
    * @param nativeCb whether LMDB native code calls back to the Java comparator
    * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#buildDbi()}
    */
   @Deprecated()
   public Dbi<T> openDbi(
@@ -333,13 +333,13 @@ public Dbi<T> openDbi(
   }
 
   /**
+   * @deprecated Instead use {@link Env#buildDbi()}
    * Convenience method that opens a {@link Dbi} with a default {@link Comparator} that is not
    * invoked from native code.
    *
    * @param name name of the database (or null if no name is required)
    * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#buildDbi()}
    */
   @Deprecated()
   public Dbi<T> openDbi(final byte[] name, final DbiFlags... flags) {
@@ -347,6 +347,7 @@ public Dbi<T> openDbi(final byte[] name, final DbiFlags... flags) {
   }
 
   /**
+   * @deprecated Instead use {@link Env#buildDbi()}
    * Convenience method that opens a {@link Dbi} with an associated {@link Comparator} that is not
    * invoked from native code.
    *
@@ -354,7 +355,6 @@ public Dbi<T> openDbi(final byte[] name, final DbiFlags... flags) {
    * @param comparator custom comparator callback (or null to use LMDB default)
    * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#buildDbi()}
    */
   @Deprecated()
   public Dbi<T> openDbi(
@@ -363,6 +363,7 @@ public Dbi<T> openDbi(
   }
 
   /**
+   * @deprecated Instead use {@link Env#buildDbi()}
    * Convenience method that opens a {@link Dbi} with an associated {@link Comparator} that may be
    * invoked from native code if specified.
    *
@@ -374,7 +375,6 @@ public Dbi<T> openDbi(
    * @param nativeCb whether native code calls back to the Java comparator
    * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#buildDbi()}
    */
   @Deprecated()
   public Dbi<T> openDbi(
@@ -390,6 +390,7 @@ public Dbi<T> openDbi(
   }
 
   /**
+   * @deprecated Instead use {@link Env#buildDbi()}
    * Open the {@link Dbi} using the passed {@link Txn}.
    *
    * <p>The caller must commit the transaction after this method returns in order to retain the
@@ -412,10 +413,9 @@ public Dbi<T> openDbi(
    * @param txn transaction to use (required; not closed)
    * @param name name of the database (or null if no name is required)
    * @param comparator custom comparator callback (or null to use LMDB default)
-   * @param nativeCb whether native code should call back to the comparator
+   * @param nativeCb whether native LMDB code should call back to the Java comparator
    * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#buildDbi()}
    */
   @Deprecated()
   public Dbi<T> openDbi(
@@ -424,6 +424,10 @@ public Dbi<T> openDbi(
       final Comparator<T> comparator,
       final boolean nativeCb,
       final DbiFlags... flags) {
+
+    if (nativeCb && comparator == null) {
+      throw new IllegalArgumentException("Is nativeCb is true, you must supply a comparator");
+    }
     return new Dbi<>(this, txn, name, comparator, nativeCb, proxy, DbiFlagSet.of(flags));
   }
 
diff --git a/src/main/java/org/lmdbjava/Txn.java b/src/main/java/org/lmdbjava/Txn.java
index 5c8440fd..dc57fc66 100644
--- a/src/main/java/org/lmdbjava/Txn.java
+++ b/src/main/java/org/lmdbjava/Txn.java
@@ -164,7 +164,7 @@ public void renew() {
   }
 
   /**
-   * Aborts this read-only transaction and resets the transaction handle so it can be reused upon
+   * Aborts this read-only transaction and resets the transaction handle, so it can be reused upon
    * calling {@link #renew()}.
    */
   public void reset() {
diff --git a/src/main/java/org/lmdbjava/TxnFlags.java b/src/main/java/org/lmdbjava/TxnFlags.java
index 8e4ea757..94112957 100644
--- a/src/main/java/org/lmdbjava/TxnFlags.java
+++ b/src/main/java/org/lmdbjava/TxnFlags.java
@@ -20,6 +20,7 @@
 
 /** Flags for use when creating a {@link Txn}. */
 public enum TxnFlags implements MaskedFlag, TxnFlagSet {
+
   /** Read only. */
   MDB_RDONLY_TXN(0x2_0000);
 
diff --git a/src/test/java/org/lmdbjava/ComparatorTest.java b/src/test/java/org/lmdbjava/ComparatorTest.java
index 446b8545..1b00c71c 100644
--- a/src/test/java/org/lmdbjava/ComparatorTest.java
+++ b/src/test/java/org/lmdbjava/ComparatorTest.java
@@ -136,7 +136,7 @@ private static final class ByteArrayRunner implements ComparatorRunner {
 
     @Override
     public int compare(final byte[] o1, final byte[] o2) {
-      final Comparator<byte[]> c = PROXY_BA.getUnsignedComparator();
+      final Comparator<byte[]> c = PROXY_BA.getComparator();
       return c.compare(o1, o2);
     }
   }
@@ -146,7 +146,7 @@ private static final class UnsignedByteArrayRunner implements ComparatorRunner {
 
     @Override
     public int compare(final byte[] o1, final byte[] o2) {
-      final Comparator<byte[]> c = PROXY_BA.getUnsignedComparator();
+      final Comparator<byte[]> c = PROXY_BA.getComparator();
       return c.compare(o1, o2);
     }
   }
@@ -156,7 +156,7 @@ private static final class ByteBufferRunner implements ComparatorRunner {
 
     @Override
     public int compare(final byte[] o1, final byte[] o2) {
-      final Comparator<ByteBuffer> c = PROXY_OPTIMAL.getUnsignedComparator();
+      final Comparator<ByteBuffer> c = PROXY_OPTIMAL.getComparator();
 
       // Convert arrays to buffers that are larger than the array, with
       // limit set at the array length. One buffer bigger than the other.
@@ -200,7 +200,7 @@ private static final class DirectBufferRunner implements ComparatorRunner {
     public int compare(final byte[] o1, final byte[] o2) {
       final DirectBuffer o1b = new UnsafeBuffer(o1);
       final DirectBuffer o2b = new UnsafeBuffer(o2);
-      final Comparator<DirectBuffer> c = PROXY_DB.getUnsignedComparator();
+      final Comparator<DirectBuffer> c = PROXY_DB.getComparator();
       return c.compare(o1b, o2b);
     }
   }
@@ -234,7 +234,7 @@ public int compare(final byte[] o1, final byte[] o2) {
       final ByteBuf o2b = DEFAULT.directBuffer(o2.length);
       o1b.writeBytes(o1);
       o2b.writeBytes(o2);
-      final Comparator<ByteBuf> c = PROXY_NETTY.getUnsignedComparator();
+      final Comparator<ByteBuf> c = PROXY_NETTY.getComparator();
       return c.compare(o1b, o2b);
     }
   }
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
index 431c6e51..aefe9d43 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
@@ -135,18 +135,27 @@ public void before() throws IOException {
             .open(path, POSIX_MODE, MDB_NOSUBDIR);
 
     // Use a java comparator for start/stop keys only
-    dbJavaComparator = env.openDbi(DB_1,
-        bufferProxy.getUnsignedComparator(),
-        MDB_CREATE,
-        MDB_INTEGERKEY);
+    DbiFlagSet dbiFlagSet = DbiFlagSet.of(MDB_CREATE, MDB_INTEGERKEY);
+
+    dbJavaComparator = env.buildDbi()
+        .withDbName(DB_1)
+        .withIteratorComparator(bufferProxy.getComparator(dbiFlagSet))
+        .withDbiFlags(dbiFlagSet)
+        .open();
+
     // Use LMDB comparator for start/stop keys
-    dbLmdbComparator = env.openDbi(DB_2, MDB_CREATE, MDB_INTEGERKEY);
+    dbLmdbComparator = env.buildDbi()
+        .withDbName(DB_2)
+        .withDefaultComparator()
+        .withDbiFlags(dbiFlagSet)
+        .open();
+
     // Use a java comparator for start/stop keys and as a callback comparaotr
-    dbCallbackComparator = env.openDbi(DB_3,
-        bufferProxy.getUnsignedComparator(),
-        true,
-        MDB_CREATE,
-        MDB_INTEGERKEY);
+    dbCallbackComparator = env.buildDbi()
+        .withDbName(DB_3)
+        .withCallbackComparator(bufferProxy.getComparator(dbiFlagSet))
+        .withDbiFlags(dbiFlagSet)
+        .open();
 
     populateList();
 
@@ -411,52 +420,52 @@ public void forEachRemainingWithClosedEnvTest() {
     }
   }
 
-  @Test
-  public void testSignedVsUnsigned() {
-    final ByteBuffer val1 = bbNative(1);
-    final ByteBuffer val2 = bbNative(2);
-    final ByteBuffer val110 = bbNative(110);
-    final ByteBuffer val111 = bbNative(111);
-    final ByteBuffer val150 = bbNative(150);
-
-    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
-    final Comparator<ByteBuffer> unsignedComparator = bufferProxy.getUnsignedComparator();
-    final Comparator<ByteBuffer> signedComparator = bufferProxy.getSignedComparator();
-
-    // Compare the same
-    assertThat(
-        unsignedComparator.compare(val1, val2), Matchers.is(signedComparator.compare(val1, val2)));
-
-    // Compare differently
-    assertThat(
-        unsignedComparator.compare(val110, val150),
-        Matchers.not(signedComparator.compare(val110, val150)));
-
-    // Compare differently
-    assertThat(
-        unsignedComparator.compare(val111, val150),
-        Matchers.not(signedComparator.compare(val111, val150)));
-
-    // This will fail if the db is using a signed comparator for the start/stop keys
-    for (final Dbi<ByteBuffer> db : dbs) {
-      db.put(val110, val110);
-      db.put(val150, val150);
-
-      final ByteBuffer startKeyBuf = val111;
-      KeyRange<ByteBuffer> keyRange = KeyRange.atLeastBackward(startKeyBuf);
-
-      try (Txn<ByteBuffer> txn = env.txnRead();
-          CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
-        for (final KeyVal<ByteBuffer> kv : c) {
-          final int key = getNativeInt(kv.key());
-          final int val = kv.val().getInt();
-          //          System.out.println("key: " + key + " val: " + val);
-          assertThat(key, is(110));
-          break;
-        }
-      }
-    }
-  }
+//  @Test
+//  public void testSignedVsUnsigned() {
+//    final ByteBuffer val1 = bbNative(1);
+//    final ByteBuffer val2 = bbNative(2);
+//    final ByteBuffer val110 = bbNative(110);
+//    final ByteBuffer val111 = bbNative(111);
+//    final ByteBuffer val150 = bbNative(150);
+//
+//    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
+//    final Comparator<ByteBuffer> unsignedComparator = bufferProxy.getUnsignedComparator();
+//    final Comparator<ByteBuffer> signedComparator = bufferProxy.getSignedComparator();
+//
+//    // Compare the same
+//    assertThat(
+//        unsignedComparator.compare(val1, val2), Matchers.is(signedComparator.compare(val1, val2)));
+//
+//    // Compare differently
+//    assertThat(
+//        unsignedComparator.compare(val110, val150),
+//        Matchers.not(signedComparator.compare(val110, val150)));
+//
+//    // Compare differently
+//    assertThat(
+//        unsignedComparator.compare(val111, val150),
+//        Matchers.not(signedComparator.compare(val111, val150)));
+//
+//    // This will fail if the db is using a signed comparator for the start/stop keys
+//    for (final Dbi<ByteBuffer> db : dbs) {
+//      db.put(val110, val110);
+//      db.put(val150, val150);
+//
+//      final ByteBuffer startKeyBuf = val111;
+//      KeyRange<ByteBuffer> keyRange = KeyRange.atLeastBackward(startKeyBuf);
+//
+//      try (Txn<ByteBuffer> txn = env.txnRead();
+//          CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
+//        for (final KeyVal<ByteBuffer> kv : c) {
+//          final int key = getNativeInt(kv.key());
+//          final int val = kv.val().getInt();
+//          //          System.out.println("key: " + key + " val: " + val);
+//          assertThat(key, is(110));
+//          break;
+//        }
+//      }
+//    }
+//  }
 
   private void verify(final KeyRange<ByteBuffer> range, final int... expected) {
     // Verify using all comparator types
diff --git a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
index f77ac4d6..e2c54346 100644
--- a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
@@ -65,14 +65,26 @@ public void before() throws IOException {
             .setMaxDbs(3)
             .open(path, POSIX_MODE, MDB_NOSUBDIR);
 
+    final DbiFlagSet dbiFlagSet = MDB_CREATE;
     // Use a java comparator for start/stop keys only
-    dbJavaComparator =
-        env.openDbi("JavaComparator", bufferProxy.getUnsignedComparator(), MDB_CREATE);
+    dbJavaComparator = env.buildDbi()
+        .withDbName("JavaComparator")
+        .withDefaultComparator()
+        .withDbiFlags(dbiFlagSet)
+        .open();
     // Use LMDB comparator for start/stop keys
-    dbLmdbComparator = env.openDbi("LmdbComparator", MDB_CREATE);
+    dbLmdbComparator = env.buildDbi()
+        .withDbName("LmdbComparator")
+        .withNativeComparator()
+        .withDbiFlags(dbiFlagSet)
+        .open();
+
     // Use a java comparator for start/stop keys and as a callback comparator
-    dbCallbackComparator =
-        env.openDbi("CallBackComparator", bufferProxy.getUnsignedComparator(), true, MDB_CREATE);
+    dbCallbackComparator = env.buildDbi()
+        .withDbName("CallBackComparator")
+        .withCallbackComparator(bufferProxy.getComparator(dbiFlagSet))
+        .withDbiFlags(dbiFlagSet)
+        .open();
 
     dbs.add(dbJavaComparator);
     dbs.add(dbLmdbComparator);
diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index 22cf7361..79a9a34c 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -129,12 +129,25 @@ public void before() throws IOException {
             .setMaxDbs(3)
             .open(path, POSIX_MODE, MDB_NOSUBDIR);
 
+    final DbiFlagSet dbiFlagSet = MDB_CREATE;
     // Use a java comparator for start/stop keys only
-    dbJavaComparator = env.openDbi(DB_1, bufferProxy.getUnsignedComparator(), MDB_CREATE);
+    dbJavaComparator = env.buildDbi()
+        .withDbName(DB_1)
+        .withDefaultComparator()
+        .withDbiFlags(dbiFlagSet)
+        .open();
     // Use LMDB comparator for start/stop keys
-    dbLmdbComparator = env.openDbi(DB_2, MDB_CREATE);
+    dbLmdbComparator = env.buildDbi()
+        .withDbName(DB_2)
+        .withNativeComparator()
+        .withDbiFlags(dbiFlagSet)
+        .open();
     // Use a java comparator for start/stop keys and as a callback comparaotr
-    dbCallbackComparator = env.openDbi(DB_3, bufferProxy.getUnsignedComparator(), true, MDB_CREATE);
+    dbCallbackComparator = env.buildDbi()
+        .withDbName(DB_3)
+        .withCallbackComparator(bufferProxy.getComparator(dbiFlagSet))
+        .withDbiFlags(dbiFlagSet)
+        .open();
 
     populateList();
 
@@ -407,52 +420,52 @@ public void forEachRemainingWithClosedEnvTest() {
     }
   }
 
-  @Test
-  public void testSignedVsUnsigned() {
-    final ByteBuffer val1 = bb(1);
-    final ByteBuffer val2 = bb(2);
-    final ByteBuffer val110 = bb(110);
-    final ByteBuffer val111 = bb(111);
-    final ByteBuffer val150 = bb(150);
-
-    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
-    final Comparator<ByteBuffer> unsignedComparator = bufferProxy.getUnsignedComparator();
-    final Comparator<ByteBuffer> signedComparator = bufferProxy.getSignedComparator();
-
-    // Compare the same
-    assertThat(
-        unsignedComparator.compare(val1, val2), Matchers.is(signedComparator.compare(val1, val2)));
-
-    // Compare differently
-    assertThat(
-        unsignedComparator.compare(val110, val150),
-        Matchers.not(signedComparator.compare(val110, val150)));
-
-    // Compare differently
-    assertThat(
-        unsignedComparator.compare(val111, val150),
-        Matchers.not(signedComparator.compare(val111, val150)));
-
-    // This will fail if the db is using a signed comparator for the start/stop keys
-    for (final Dbi<ByteBuffer> db : dbs) {
-      db.put(val110, val110);
-      db.put(val150, val150);
-
-      final ByteBuffer startKeyBuf = val111;
-      KeyRange<ByteBuffer> keyRange = KeyRange.atLeastBackward(startKeyBuf);
-
-      try (Txn<ByteBuffer> txn = env.txnRead();
-          CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
-        for (final CursorIterable.KeyVal<ByteBuffer> kv : c) {
-          final int key = kv.key().getInt();
-          final int val = kv.val().getInt();
-          //          System.out.println("key: " + key + " val: " + val);
-          assertThat(key, is(110));
-          break;
-        }
-      }
-    }
-  }
+//  @Test
+//  public void testSignedVsUnsigned() {
+//    final ByteBuffer val1 = bb(1);
+//    final ByteBuffer val2 = bb(2);
+//    final ByteBuffer val110 = bb(110);
+//    final ByteBuffer val111 = bb(111);
+//    final ByteBuffer val150 = bb(150);
+//
+//    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
+//    final Comparator<ByteBuffer> unsignedComparator = bufferProxy.getUnsignedComparator();
+//    final Comparator<ByteBuffer> signedComparator = bufferProxy.getSignedComparator();
+//
+//    // Compare the same
+//    assertThat(
+//        unsignedComparator.compare(val1, val2), Matchers.is(signedComparator.compare(val1, val2)));
+//
+//    // Compare differently
+//    assertThat(
+//        unsignedComparator.compare(val110, val150),
+//        Matchers.not(signedComparator.compare(val110, val150)));
+//
+//    // Compare differently
+//    assertThat(
+//        unsignedComparator.compare(val111, val150),
+//        Matchers.not(signedComparator.compare(val111, val150)));
+//
+//    // This will fail if the db is using a signed comparator for the start/stop keys
+//    for (final Dbi<ByteBuffer> db : dbs) {
+//      db.put(val110, val110);
+//      db.put(val150, val150);
+//
+//      final ByteBuffer startKeyBuf = val111;
+//      KeyRange<ByteBuffer> keyRange = KeyRange.atLeastBackward(startKeyBuf);
+//
+//      try (Txn<ByteBuffer> txn = env.txnRead();
+//          CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
+//        for (final CursorIterable.KeyVal<ByteBuffer> kv : c) {
+//          final int key = kv.key().getInt();
+//          final int val = kv.val().getInt();
+//          //          System.out.println("key: " + key + " val: " + val);
+//          assertThat(key, is(110));
+//          break;
+//        }
+//      }
+//    }
+//  }
 
   private void verify(final KeyRange<ByteBuffer> range, final int... expected) {
     // Verify using all comparator types
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 37f141e9..2209e614 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -118,7 +118,7 @@ public void close() {
   public void customComparator() {
     final Comparator<ByteBuffer> reverseOrder =
         (o1, o2) -> {
-          final int lexical = PROXY_OPTIMAL.getUnsignedComparator().compare(o1, o2);
+          final int lexical = PROXY_OPTIMAL.getComparator().compare(o1, o2);
           if (lexical == 0) {
             return 0;
           }
@@ -131,7 +131,7 @@ public void customComparator() {
   public void customComparatorByteArray() {
     final Comparator<byte[]> reverseOrder =
         (o1, o2) -> {
-          final int lexical = PROXY_BA.getUnsignedComparator().compare(o1, o2);
+          final int lexical = PROXY_BA.getComparator().compare(o1, o2);
           if (lexical == 0) {
             return 0;
           }
@@ -172,13 +172,13 @@ public void dbOpenMaxDatabases() {
   @Test
   public void dbiWithComparatorThreadSafety() {
     doDbiWithComparatorThreadSafety(
-        env, PROXY_OPTIMAL::getUnsignedComparator, TestUtils::bb, ByteBuffer::getInt);
+        env, PROXY_OPTIMAL::getComparator, TestUtils::bb, ByteBuffer::getInt);
   }
 
   @Test
   public void dbiWithComparatorThreadSafetyByteArray() {
     doDbiWithComparatorThreadSafety(
-        envBa, PROXY_BA::getUnsignedComparator, TestUtils::ba, TestUtils::fromBa);
+        envBa, PROXY_BA::getComparator, TestUtils::ba, TestUtils::fromBa);
   }
 
   public <T> void doDbiWithComparatorThreadSafety(
diff --git a/src/test/java/org/lmdbjava/TestDbiBuilder.java b/src/test/java/org/lmdbjava/TestDbiBuilder.java
index 15b70812..7a1e8947 100644
--- a/src/test/java/org/lmdbjava/TestDbiBuilder.java
+++ b/src/test/java/org/lmdbjava/TestDbiBuilder.java
@@ -10,7 +10,6 @@
 import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.nio.charset.StandardCharsets;
-import junit.framework.TestCase;
 import org.hamcrest.Matchers;
 import org.junit.After;
 import org.junit.Before;
@@ -31,6 +30,7 @@ public void after() {
 
     @Before
     public void before() throws IOException {
+        System.out.println("before");
         final File path = tmp.newFile();
         env =
                 create()
@@ -44,7 +44,7 @@ public void before() throws IOException {
     public void unnamed() {
         final Dbi<ByteBuffer> dbi = env.buildDbi()
                 .withoutDbName()
-                .withDefaultIteratorComparator()
+                .withDefaultComparator()
                 .withDbiFlags(DbiFlags.MDB_CREATE)
                 .open();
 
@@ -58,7 +58,7 @@ public void unnamed() {
     public void named() {
         final Dbi<ByteBuffer> dbi = env.buildDbi()
                 .withDbName("foo")
-                .withDefaultIteratorComparator()
+                .withDefaultComparator()
                 .withDbiFlags(DbiFlags.MDB_CREATE)
                 .open();
 

From ef0c852ad9a631ae0f194f4d63dce62e3d1b549f Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Tue, 28 Oct 2025 17:31:32 +0000
Subject: [PATCH 231/322] Add missing txn commit in DbiBuilder

---
 .../java/org/lmdbjava/AbstractFlagSet.java    | 15 +++
 src/main/java/org/lmdbjava/CopyFlagSet.java   | 15 +++
 src/main/java/org/lmdbjava/Dbi.java           | 11 +--
 src/main/java/org/lmdbjava/DbiBuilder.java    | 15 +--
 src/main/java/org/lmdbjava/DbiFlagSet.java    | 15 +++
 src/main/java/org/lmdbjava/EnvFlagSet.java    | 15 +++
 src/main/java/org/lmdbjava/FlagSet.java       | 15 +++
 src/main/java/org/lmdbjava/PutFlagSet.java    | 15 +++
 src/main/java/org/lmdbjava/ReferenceUtil.java |  1 +
 src/main/java/org/lmdbjava/Txn.java           |  7 +-
 src/main/java/org/lmdbjava/TxnFlagSet.java    | 15 +++
 .../java/org/lmdbjava/CopyFlagSetTest.java    | 15 +++
 .../java/org/lmdbjava/DbiBuilderTest.java     | 97 +++++++++++++++++++
 .../java/org/lmdbjava/DbiFlagSetTest.java     | 15 +++
 .../java/org/lmdbjava/EnvFlagSetTest.java     | 15 +++
 .../java/org/lmdbjava/PutFlagSetTest.java     | 15 +++
 .../java/org/lmdbjava/TestDbiBuilder.java     | 83 ----------------
 .../java/org/lmdbjava/TxnFlagSetTest.java     | 15 +++
 18 files changed, 296 insertions(+), 98 deletions(-)
 create mode 100644 src/test/java/org/lmdbjava/DbiBuilderTest.java
 delete mode 100644 src/test/java/org/lmdbjava/TestDbiBuilder.java

diff --git a/src/main/java/org/lmdbjava/AbstractFlagSet.java b/src/main/java/org/lmdbjava/AbstractFlagSet.java
index 7ea413fb..5e62b437 100644
--- a/src/main/java/org/lmdbjava/AbstractFlagSet.java
+++ b/src/main/java/org/lmdbjava/AbstractFlagSet.java
@@ -1,3 +1,18 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package org.lmdbjava;
 
 import java.util.Collection;
diff --git a/src/main/java/org/lmdbjava/CopyFlagSet.java b/src/main/java/org/lmdbjava/CopyFlagSet.java
index 62c73c8d..5f7901de 100644
--- a/src/main/java/org/lmdbjava/CopyFlagSet.java
+++ b/src/main/java/org/lmdbjava/CopyFlagSet.java
@@ -1,3 +1,18 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package org.lmdbjava;
 
 import java.util.Collection;
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index 9cdc03ee..c66dc780 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -49,7 +49,7 @@
  */
 public final class Dbi<T> {
 
-  private final ComparatorCallback ccb;
+  private final ComparatorCallback callbackComparator;
   private boolean cleaned;
   // Used for CursorIterable KeyRange testing and/or native callbacks
   private final Comparator<T> comparator;
@@ -82,7 +82,7 @@ public final class Dbi<T> {
     if (nativeCb) {
       requireNonNull(comparator, "comparator cannot be null if nativeCb is set");
       // LMDB will call back to this comparator for insertion/iteration order
-      this.ccb =
+      this.callbackComparator =
           (keyA, keyB) -> {
             final T compKeyA  = proxy.out(proxy.allocate(), keyA);
             final T compKeyB = proxy.out(proxy.allocate(), keyB);
@@ -91,9 +91,9 @@ public final class Dbi<T> {
             proxy.deallocate(compKeyB);
             return result;
           };
-      LIB.mdb_set_compare(txn.pointer(), ptr, ccb);
+      LIB.mdb_set_compare(txn.pointer(), ptr, callbackComparator);
     } else {
-      ccb = null;
+      callbackComparator = null;
     }
   }
 
@@ -380,8 +380,7 @@ public boolean put(final Txn<T> txn, final T key, final T val, final PutFlags...
     final Pointer transientKey = txn.kv().keyIn(key);
     final Pointer transientVal = txn.kv().valIn(val);
     final int mask = mask(flags);
-    final int rc =
-        LIB.mdb_put(txn.pointer(), ptr, txn.kv().pointerKey(), txn.kv().pointerVal(), mask);
+    final int rc = LIB.mdb_put(txn.pointer(), ptr, txn.kv().pointerKey(), txn.kv().pointerVal(), mask);
     if (rc == MDB_KEYEXIST) {
       if (isSet(mask, MDB_NOOVERWRITE)) {
         txn.kv().valOut(); // marked as in,out in LMDB C docs
diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
index f2f925ce..dcf34d0a 100644
--- a/src/main/java/org/lmdbjava/DbiBuilder.java
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -355,20 +355,23 @@ public DbiBuilderStage3<T> withTxn(final Txn<T> txn) {
     /**
      * Construct and open the {@link Dbi}.
      * <p>
-     * If a {@link Txn} was supplied to the builder, it should be committed upon return from
-     * this method.
+     * If a {@link Txn} was supplied to the builder, it is the callers responsibility to
+     * commit and close the txn upon return from this method, else the created DB won't be retained.
      * </p>
      *
      * @return A newly constructed and opened {@link Dbi}.
      */
     public Dbi<T> open() {
       final DbiBuilder<T> dbiBuilder = dbiBuilderStage2.dbiBuilder;
-      if (txn == null) {
+      if (txn != null) {
+        return open(txn, dbiBuilder);
+      } else {
         try (final Txn<T> txn = getTxn(dbiBuilder)) {
-          return open(txn, dbiBuilder);
+          final Dbi<T> dbi = open(txn, dbiBuilder);
+          // even RO Txns require a commit to retain Dbi in Env
+          txn.commit();
+          return dbi;
         }
-      } else {
-        return open(txn, dbiBuilder);
       }
     }
 
diff --git a/src/main/java/org/lmdbjava/DbiFlagSet.java b/src/main/java/org/lmdbjava/DbiFlagSet.java
index e5c97544..28f5e4f1 100644
--- a/src/main/java/org/lmdbjava/DbiFlagSet.java
+++ b/src/main/java/org/lmdbjava/DbiFlagSet.java
@@ -1,3 +1,18 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package org.lmdbjava;
 
 import java.util.Collection;
diff --git a/src/main/java/org/lmdbjava/EnvFlagSet.java b/src/main/java/org/lmdbjava/EnvFlagSet.java
index 944496e6..f1bab2d0 100644
--- a/src/main/java/org/lmdbjava/EnvFlagSet.java
+++ b/src/main/java/org/lmdbjava/EnvFlagSet.java
@@ -1,3 +1,18 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package org.lmdbjava;
 
 import java.util.Collection;
diff --git a/src/main/java/org/lmdbjava/FlagSet.java b/src/main/java/org/lmdbjava/FlagSet.java
index 80a4c19e..89b955a0 100644
--- a/src/main/java/org/lmdbjava/FlagSet.java
+++ b/src/main/java/org/lmdbjava/FlagSet.java
@@ -1,3 +1,18 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package org.lmdbjava;
 
 import java.util.Comparator;
diff --git a/src/main/java/org/lmdbjava/PutFlagSet.java b/src/main/java/org/lmdbjava/PutFlagSet.java
index 1eedaf10..85de014b 100644
--- a/src/main/java/org/lmdbjava/PutFlagSet.java
+++ b/src/main/java/org/lmdbjava/PutFlagSet.java
@@ -1,3 +1,18 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package org.lmdbjava;
 
 import java.util.Collection;
diff --git a/src/main/java/org/lmdbjava/ReferenceUtil.java b/src/main/java/org/lmdbjava/ReferenceUtil.java
index 2b9f211e..70b3c338 100644
--- a/src/main/java/org/lmdbjava/ReferenceUtil.java
+++ b/src/main/java/org/lmdbjava/ReferenceUtil.java
@@ -41,6 +41,7 @@ private ReferenceUtil() {}
    */
   public static void reachabilityFence0(final Object ref) {
     if (ref != null) {
+      //noinspection EmptySynchronizedStatement
       synchronized (ref) {
         // Empty synchronized is ok: https://stackoverflow.com/a/31933260/1151521
       }
diff --git a/src/main/java/org/lmdbjava/Txn.java b/src/main/java/org/lmdbjava/Txn.java
index dc57fc66..99439bf7 100644
--- a/src/main/java/org/lmdbjava/Txn.java
+++ b/src/main/java/org/lmdbjava/Txn.java
@@ -42,15 +42,16 @@ public final class Txn<T> implements AutoCloseable {
   private final Pointer ptr;
   private final boolean readOnly;
   private final Env<T> env;
+  private final TxnFlagSet flags;
   private State state;
 
   Txn(final Env<T> env, final Txn<T> parent, final BufferProxy<T> proxy, final TxnFlagSet flags) {
-    final TxnFlagSet flagSet = flags != null
+    this.flags = flags != null
         ? flags
         : TxnFlagSet.EMPTY;
     this.proxy = proxy;
     this.keyVal = proxy.keyVal();
-    this.readOnly = flagSet.isSet(MDB_RDONLY_TXN);
+    this.readOnly = this.flags.isSet(MDB_RDONLY_TXN);
     if (env.isReadOnly() && !this.readOnly) {
       throw new EnvIsReadOnly();
     }
@@ -61,7 +62,7 @@ public final class Txn<T> implements AutoCloseable {
     }
     final Pointer txnPtr = allocateDirect(RUNTIME, ADDRESS);
     final Pointer txnParentPtr = parent == null ? null : parent.ptr;
-    checkRc(LIB.mdb_txn_begin(env.pointer(), txnParentPtr, flagSet.getMask(), txnPtr));
+    checkRc(LIB.mdb_txn_begin(env.pointer(), txnParentPtr, this.flags.getMask(), txnPtr));
     ptr = txnPtr.getPointer(0);
 
     state = READY;
diff --git a/src/main/java/org/lmdbjava/TxnFlagSet.java b/src/main/java/org/lmdbjava/TxnFlagSet.java
index 6320eece..8e6310b3 100644
--- a/src/main/java/org/lmdbjava/TxnFlagSet.java
+++ b/src/main/java/org/lmdbjava/TxnFlagSet.java
@@ -1,3 +1,18 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package org.lmdbjava;
 
 import java.util.EnumSet;
diff --git a/src/test/java/org/lmdbjava/CopyFlagSetTest.java b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
index 1ea44b7e..66e89ccb 100644
--- a/src/test/java/org/lmdbjava/CopyFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
@@ -1,3 +1,18 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package org.lmdbjava;
 
 import static org.hamcrest.CoreMatchers.is;
diff --git a/src/test/java/org/lmdbjava/DbiBuilderTest.java b/src/test/java/org/lmdbjava/DbiBuilderTest.java
new file mode 100644
index 00000000..da9341c6
--- /dev/null
+++ b/src/test/java/org/lmdbjava/DbiBuilderTest.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import static com.jakewharton.byteunits.BinaryByteUnit.MEBIBYTES;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.lmdbjava.Env.create;
+import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
+import static org.lmdbjava.TestUtils.bb;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import org.hamcrest.Matchers;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+
+public class DbiBuilderTest {
+
+  @Rule
+  public final TemporaryFolder tmp = new TemporaryFolder();
+  private Env<ByteBuffer> env;
+
+  @After
+  public void after() {
+    env.close();
+  }
+
+  @Before
+  public void before() throws IOException {
+    System.out.println("before");
+    final File path = tmp.newFile();
+    env = create()
+        .setMapSize(MEBIBYTES.toBytes(64))
+        .setMaxReaders(2)
+        .setMaxDbs(2)
+        .open(path, MDB_NOSUBDIR);
+  }
+
+  @Test
+  public void unnamed() {
+    final Dbi<ByteBuffer> dbi = env.buildDbi()
+        .withoutDbName()
+        .withDefaultComparator()
+        .withDbiFlags(DbiFlags.MDB_CREATE)
+        .open();
+
+    assertThat(env.getDbiNames().size(), Matchers.is(0));
+
+    assertPutAndGet(dbi);
+  }
+
+
+  @Test
+  public void named() {
+    final Dbi<ByteBuffer> dbi = env.buildDbi()
+        .withDbName("foo")
+        .withDefaultComparator()
+        .withDbiFlags(DbiFlags.MDB_CREATE)
+        .open();
+
+    assertPutAndGet(dbi);
+
+    assertThat(env.getDbiNames().size(), Matchers.is(1));
+    assertThat(new String(env.getDbiNames().get(0), StandardCharsets.UTF_8), Matchers.is("foo"));
+  }
+
+  private void assertPutAndGet(Dbi<ByteBuffer> dbi) {
+    try (Txn<ByteBuffer> writeTxn = env.txnWrite()) {
+      dbi.put(writeTxn, bb(123), bb(123_000));
+      writeTxn.commit();
+    }
+
+    try (Txn<ByteBuffer> readTxn = env.txnRead()) {
+      final ByteBuffer byteBuffer = dbi.get(readTxn, bb(123));
+      final int val = byteBuffer.getInt();
+      assertThat(val, Matchers.is(123_000));
+    }
+  }
+}
diff --git a/src/test/java/org/lmdbjava/DbiFlagSetTest.java b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
index 323a2ed4..457e4718 100644
--- a/src/test/java/org/lmdbjava/DbiFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
@@ -1,3 +1,18 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package org.lmdbjava;
 
 import static org.hamcrest.CoreMatchers.is;
diff --git a/src/test/java/org/lmdbjava/EnvFlagSetTest.java b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
index ed6a0fea..2ecce3c2 100644
--- a/src/test/java/org/lmdbjava/EnvFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
@@ -1,3 +1,18 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package org.lmdbjava;
 
 import static org.hamcrest.CoreMatchers.is;
diff --git a/src/test/java/org/lmdbjava/PutFlagSetTest.java b/src/test/java/org/lmdbjava/PutFlagSetTest.java
index 8cf1efe0..3e402732 100644
--- a/src/test/java/org/lmdbjava/PutFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/PutFlagSetTest.java
@@ -1,3 +1,18 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package org.lmdbjava;
 
 import static org.hamcrest.CoreMatchers.is;
diff --git a/src/test/java/org/lmdbjava/TestDbiBuilder.java b/src/test/java/org/lmdbjava/TestDbiBuilder.java
deleted file mode 100644
index 7a1e8947..00000000
--- a/src/test/java/org/lmdbjava/TestDbiBuilder.java
+++ /dev/null
@@ -1,83 +0,0 @@
-package org.lmdbjava;
-
-import static com.jakewharton.byteunits.BinaryByteUnit.MEBIBYTES;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.lmdbjava.Env.create;
-import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
-import static org.lmdbjava.TestUtils.bb;
-
-import java.io.File;
-import java.io.IOException;
-import java.nio.ByteBuffer;
-import java.nio.charset.StandardCharsets;
-import org.hamcrest.Matchers;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
-
-public class TestDbiBuilder {
-
-    @Rule
-    public final TemporaryFolder tmp = new TemporaryFolder();
-    private Env<ByteBuffer> env;
-
-    @After
-    public void after() {
-        env.close();
-    }
-
-    @Before
-    public void before() throws IOException {
-        System.out.println("before");
-        final File path = tmp.newFile();
-        env =
-                create()
-                        .setMapSize(MEBIBYTES.toBytes(64))
-                        .setMaxReaders(2)
-                        .setMaxDbs(2)
-                        .open(path, MDB_NOSUBDIR);
-    }
-
-    @Test
-    public void unnamed() {
-        final Dbi<ByteBuffer> dbi = env.buildDbi()
-                .withoutDbName()
-                .withDefaultComparator()
-                .withDbiFlags(DbiFlags.MDB_CREATE)
-                .open();
-
-        assertThat(env.getDbiNames().size(), Matchers.is(0));
-
-        assertPutAndGet(dbi);
-    }
-
-
-    @Test
-    public void named() {
-        final Dbi<ByteBuffer> dbi = env.buildDbi()
-                .withDbName("foo")
-                .withDefaultComparator()
-                .withDbiFlags(DbiFlags.MDB_CREATE)
-                .open();
-
-        assertPutAndGet(dbi);
-
-        assertThat(env.getDbiNames().size(), Matchers.is(1));
-        assertThat(new String(env.getDbiNames().get(0), StandardCharsets.UTF_8), Matchers.is("foo"));
-    }
-
-    private void assertPutAndGet(Dbi<ByteBuffer> dbi) {
-        try (Txn<ByteBuffer> writeTxn = env.txnWrite()) {
-            dbi.put(writeTxn, bb(123), bb(123_000));
-            writeTxn.commit();
-        }
-
-        try (Txn<ByteBuffer> readTxn = env.txnRead()) {
-            final ByteBuffer byteBuffer = dbi.get(readTxn, bb(123));
-            final int val = byteBuffer.getInt();
-            assertThat(val, Matchers.is(123_000));
-        }
-    }
-}
diff --git a/src/test/java/org/lmdbjava/TxnFlagSetTest.java b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
index b526ceeb..2bb3790a 100644
--- a/src/test/java/org/lmdbjava/TxnFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
@@ -1,3 +1,18 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package org.lmdbjava;
 
 import static org.hamcrest.CoreMatchers.is;

From 2fb1c02b1ac5642292839590757b71822e5f55fb Mon Sep 17 00:00:00 2001
From: stroomdev66 <stroomdev66@gmail.com>
Date: Tue, 28 Oct 2025 18:20:30 +0000
Subject: [PATCH 232/322] Upgrade to JUnit 5 and replace Hamcrest with AssertJ

---
 pom.xml                                       |  34 +-
 src/main/java/org/lmdbjava/Dbi.java           |   2 +-
 .../org/lmdbjava/ByteBufferProxyTest.java     |  94 +--
 .../java/org/lmdbjava/ComparatorTest.java     | 120 ++-
 .../java/org/lmdbjava/CursorIterableTest.java | 287 ++++---
 .../java/org/lmdbjava/CursorParamTest.java    | 111 ++-
 src/test/java/org/lmdbjava/CursorTest.java    | 359 ++++----
 src/test/java/org/lmdbjava/DbiTest.java       | 519 ++++++------
 src/test/java/org/lmdbjava/EnvTest.java       | 653 +++++++++------
 src/test/java/org/lmdbjava/FileUtil.java      | 153 ++++
 .../org/lmdbjava/GarbageCollectionTest.java   | 110 ++-
 src/test/java/org/lmdbjava/KeyRangeTest.java  |  85 +-
 src/test/java/org/lmdbjava/LibraryTest.java   |  14 +-
 .../java/org/lmdbjava/MaskedFlagTest.java     |  47 +-
 src/test/java/org/lmdbjava/MetaTest.java      |  20 +-
 .../org/lmdbjava/ResultCodeMapperTest.java    |  56 +-
 .../java/org/lmdbjava/TargetNameTest.java     |  32 +-
 src/test/java/org/lmdbjava/TutorialTest.java  | 774 +++++++++---------
 src/test/java/org/lmdbjava/TxnTest.java       | 405 +++++----
 src/test/java/org/lmdbjava/VerifierTest.java  |  38 +-
 20 files changed, 2188 insertions(+), 1725 deletions(-)
 create mode 100644 src/test/java/org/lmdbjava/FileUtil.java

diff --git a/pom.xml b/pom.xml
index d59d1a1d..3cb7ccc5 100644
--- a/pom.xml
+++ b/pom.xml
@@ -27,17 +27,17 @@
   <properties>
     <!-- Agrona 1.23+ requires Java 17+ -->
     <agrona.version>1.22.0</agrona.version>
+    <assertj.version>3.27.6</assertj.version>
     <buildnumber-maven-plugin.version>3.2.1</buildnumber-maven-plugin.version>
     <byteunits.version>0.9.1</byteunits.version>
     <central-publishing-maven-plugin.version>0.9.0</central-publishing-maven-plugin.version>
     <fmt-maven-plugin.version>2.29</fmt-maven-plugin.version>
     <google-java-format.version>1.28.0</google-java-format.version>
     <guava.version>33.5.0-jre</guava.version>
-    <hamcrest.version>2.2</hamcrest.version>
     <jacoco-maven-plugin.version>0.8.14</jacoco-maven-plugin.version>
     <jnr-constants.version>0.10.4</jnr-constants.version>
     <jnr-ffi.version>2.2.18</jnr-ffi.version>
-    <junit.version>4.13.2</junit.version>
+    <junit.version>5.14.0</junit.version>
     <license-maven-plugin.version>4.6</license-maven-plugin.version>
     <maven-clean-plugin.version>3.5.0</maven-clean-plugin.version>
     <maven-compiler-plugin.version>3.14.1</maven-compiler-plugin.version>
@@ -96,18 +96,6 @@
       <version>${netty-buffer.version}</version>
       <optional>true</optional>
     </dependency>
-    <dependency>
-      <groupId>junit</groupId>
-      <artifactId>junit</artifactId>
-      <version>${junit.version}</version>
-      <scope>test</scope>
-      <exclusions>
-        <exclusion>
-          <groupId>org.hamcrest</groupId>
-          <artifactId>hamcrest-core</artifactId>
-        </exclusion>
-      </exclusions>
-    </dependency>
     <dependency>
       <groupId>org.agrona</groupId>
       <artifactId>agrona</artifactId>
@@ -115,9 +103,21 @@
       <optional>true</optional>
     </dependency>
     <dependency>
-      <groupId>org.hamcrest</groupId>
-      <artifactId>hamcrest</artifactId>
-      <version>${hamcrest.version}</version>
+      <groupId>org.assertj</groupId>
+      <artifactId>assertj-core</artifactId>
+      <version>${assertj.version}</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.junit.jupiter</groupId>
+      <artifactId>junit-jupiter-api</artifactId>
+      <version>${junit.version}</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.junit.jupiter</groupId>
+      <artifactId>junit-jupiter-params</artifactId>
+      <version>${junit.version}</version>
       <scope>test</scope>
     </dependency>
     <dependency>
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index 6b6eb266..5449c172 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -81,7 +81,7 @@ public final class Dbi<T> {
     if (nativeCb) {
       this.ccb =
           (keyA, keyB) -> {
-            final T compKeyA  = proxy.out(proxy.allocate(), keyA);
+            final T compKeyA = proxy.out(proxy.allocate(), keyA);
             final T compKeyB = proxy.out(proxy.allocate(), keyB);
             final int result = this.comparator.compare(compKeyA, compKeyB);
             proxy.deallocate(compKeyA);
diff --git a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
index b68f39ef..82c0abce 100644
--- a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
+++ b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package org.lmdbjava;
 
 import static java.lang.Integer.BYTES;
@@ -20,11 +21,8 @@
 import static java.nio.ByteBuffer.allocateDirect;
 import static java.nio.ByteOrder.BIG_ENDIAN;
 import static java.nio.ByteOrder.LITTLE_ENDIAN;
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.CoreMatchers.not;
-import static org.hamcrest.CoreMatchers.notNullValue;
-import static org.hamcrest.CoreMatchers.startsWith;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.lmdbjava.BufferProxy.MDB_VAL_STRUCT_SIZE;
 import static org.lmdbjava.ByteBufferProxy.AbstractByteBufferProxy.findField;
 import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
@@ -36,15 +34,11 @@
 import static org.lmdbjava.TestUtils.invokePrivateConstructor;
 import static org.lmdbjava.UnsafeAccess.ALLOW_UNSAFE;
 
-import java.io.File;
-import java.io.IOException;
 import java.lang.reflect.Field;
 import java.nio.ByteBuffer;
 import jnr.ffi.Pointer;
 import jnr.ffi.provider.MemoryManager;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
+import org.junit.jupiter.api.Test;
 import org.lmdbjava.ByteBufferProxy.BufferMustBeDirectException;
 import org.lmdbjava.Env.ReadersFullException;
 
@@ -53,23 +47,27 @@ public final class ByteBufferProxyTest {
 
   static final MemoryManager MEM_MGR = RUNTIME.getMemoryManager();
 
-  @Rule public final TemporaryFolder tmp = new TemporaryFolder();
-
-  @Test(expected = BufferMustBeDirectException.class)
-  public void buffersMustBeDirect() throws IOException {
-    final File path = tmp.newFolder();
-    try (Env<ByteBuffer> env = create().setMaxReaders(1).open(path)) {
-      final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
-      final ByteBuffer key = allocate(100);
-      key.putInt(1).flip();
-      final ByteBuffer val = allocate(100);
-      val.putInt(1).flip();
-      db.put(key, val); // error
-    }
+  @Test
+  void buffersMustBeDirect() {
+    assertThatThrownBy(
+            () -> {
+              FileUtil.useTempDir(
+                  dir -> {
+                    try (Env<ByteBuffer> env = create().setMaxReaders(1).open(dir.toFile())) {
+                      final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+                      final ByteBuffer key = allocate(100);
+                      key.putInt(1).flip();
+                      final ByteBuffer val = allocate(100);
+                      val.putInt(1).flip();
+                      db.put(key, val); // error
+                    }
+                  });
+            })
+        .isInstanceOf(BufferMustBeDirectException.class);
   }
 
   @Test
-  public void byteOrderResets() {
+  void byteOrderResets() {
     final int retries = 100;
     for (int i = 0; i < retries; i++) {
       final ByteBuffer bb = PROXY_OPTIMAL.allocate();
@@ -77,56 +75,60 @@ public void byteOrderResets() {
       PROXY_OPTIMAL.deallocate(bb);
     }
     for (int i = 0; i < retries; i++) {
-      assertThat(PROXY_OPTIMAL.allocate().order(), is(BIG_ENDIAN));
+      assertThat(PROXY_OPTIMAL.allocate().order()).isEqualTo(BIG_ENDIAN);
     }
   }
 
   @Test
-  public void coverPrivateConstructor() {
+  void coverPrivateConstructor() {
     invokePrivateConstructor(ByteBufferProxy.class);
   }
 
-  @Test(expected = LmdbException.class)
-  public void fieldNeverFound() {
-    findField(Exception.class, "notARealField");
+  @Test
+  void fieldNeverFound() {
+    assertThatThrownBy(
+            () -> {
+              findField(Exception.class, "notARealField");
+            })
+        .isInstanceOf(LmdbException.class);
   }
 
   @Test
-  public void fieldSuperclassScan() {
+  void fieldSuperclassScan() {
     final Field f = findField(ReadersFullException.class, "rc");
-    assertThat(f, is(notNullValue()));
+    assertThat(f).isNotNull();
   }
 
   @Test
-  public void inOutBuffersProxyOptimal() {
+  void inOutBuffersProxyOptimal() {
     checkInOut(PROXY_OPTIMAL);
   }
 
   @Test
-  public void inOutBuffersProxySafe() {
+  void inOutBuffersProxySafe() {
     checkInOut(PROXY_SAFE);
   }
 
   @Test
-  public void optimalAlwaysAvailable() {
+  void optimalAlwaysAvailable() {
     final BufferProxy<ByteBuffer> v = PROXY_OPTIMAL;
-    assertThat(v, is(notNullValue()));
+    assertThat(v).isNotNull();
   }
 
   @Test
-  public void safeCanBeForced() {
+  void safeCanBeForced() {
     final BufferProxy<ByteBuffer> v = PROXY_SAFE;
-    assertThat(v, is(notNullValue()));
-    assertThat(v.getClass().getSimpleName(), startsWith("Reflect"));
+    assertThat(v).isNotNull();
+    assertThat(v.getClass().getSimpleName()).startsWith("Reflect");
   }
 
   @Test
-  public void unsafeIsDefault() {
-    assertThat(ALLOW_UNSAFE, is(true));
+  void unsafeIsDefault() {
+    assertThat(ALLOW_UNSAFE).isTrue();
     final BufferProxy<ByteBuffer> v = PROXY_OPTIMAL;
-    assertThat(v, is(notNullValue()));
-    assertThat(v, is(not(PROXY_SAFE)));
-    assertThat(v.getClass().getSimpleName(), startsWith("Unsafe"));
+    assertThat(v).isNotNull();
+    assertThat(v).isNotEqualTo(PROXY_SAFE);
+    assertThat(v.getClass().getSimpleName()).startsWith("Unsafe");
   }
 
   private void checkInOut(final BufferProxy<ByteBuffer> v) {
@@ -144,8 +146,8 @@ private void checkInOut(final BufferProxy<ByteBuffer> v) {
     final ByteBuffer bb = allocateDirect(1);
     v.out(bb, p);
 
-    assertThat(bb.getInt(), is(2));
-    assertThat(bb.getInt(), is(3));
-    assertThat(bb.remaining(), is(0));
+    assertThat(bb.getInt()).isEqualTo(2);
+    assertThat(bb.getInt()).isEqualTo(3);
+    assertThat(bb.remaining()).isEqualTo(0);
   }
 }
diff --git a/src/test/java/org/lmdbjava/ComparatorTest.java b/src/test/java/org/lmdbjava/ComparatorTest.java
index 3c7e7a4d..b4946a26 100644
--- a/src/test/java/org/lmdbjava/ComparatorTest.java
+++ b/src/test/java/org/lmdbjava/ComparatorTest.java
@@ -13,19 +13,16 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package org.lmdbjava;
 
 import static io.netty.buffer.PooledByteBufAllocator.DEFAULT;
 import static java.nio.charset.StandardCharsets.US_ASCII;
-import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
 import static org.lmdbjava.ByteBufProxy.PROXY_NETTY;
 import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
-import static org.lmdbjava.ComparatorTest.ComparatorResult.EQUAL_TO;
-import static org.lmdbjava.ComparatorTest.ComparatorResult.GREATER_THAN;
-import static org.lmdbjava.ComparatorTest.ComparatorResult.LESS_THAN;
-import static org.lmdbjava.ComparatorTest.ComparatorResult.get;
+import static org.lmdbjava.ComparatorTest.ComparatorResult.*;
 import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
 
 import com.google.common.primitives.SignedBytes;
@@ -34,16 +31,14 @@
 import java.nio.ByteBuffer;
 import java.util.Arrays;
 import java.util.Comparator;
+import java.util.stream.Stream;
 import org.agrona.DirectBuffer;
 import org.agrona.concurrent.UnsafeBuffer;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameter;
-import org.junit.runners.Parameterized.Parameters;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 
 /** Tests comparator functions are consistent across buffers. */
-@RunWith(Parameterized.class)
 public final class ComparatorTest {
 
   // H = 1 (high), L = 0 (low), X = byte not set in buffer
@@ -59,20 +54,16 @@ public final class ComparatorTest {
   private static final byte[] LX = buffer(0);
   private static final byte[] XX = buffer();
 
-  /** Injected by {@link #data()} with appropriate runner. */
-  @Parameter public ComparatorRunner comparator;
-
-  @Parameters(name = "{index}: comparable: {0}")
-  public static Object[] data() {
-    final ComparatorRunner string = new StringRunner();
-    final ComparatorRunner db = new DirectBufferRunner();
-    final ComparatorRunner ba = new ByteArrayRunner();
-    final ComparatorRunner baUnsigned = new UnsignedByteArrayRunner();
-    final ComparatorRunner bb = new ByteBufferRunner();
-    final ComparatorRunner netty = new NettyRunner();
-    final ComparatorRunner gub = new GuavaUnsignedBytes();
-    final ComparatorRunner gsb = new GuavaSignedBytes();
-    return new Object[] {string, db, ba, baUnsigned, bb, netty, gub, gsb};
+  static Stream<Arguments> comparatorProvider() {
+    return Stream.of(
+        Arguments.arguments("StringRunner", new StringRunner()),
+        Arguments.arguments("DirectBufferRunner", new DirectBufferRunner()),
+        Arguments.arguments("ByteArrayRunner", new ByteArrayRunner()),
+        Arguments.arguments("UnsignedByteArrayRunner", new UnsignedByteArrayRunner()),
+        Arguments.arguments("ByteBufferRunner", new ByteBufferRunner()),
+        Arguments.arguments("NettyRunner", new NettyRunner()),
+        Arguments.arguments("GuavaUnsignedBytes", new GuavaUnsignedBytes()),
+        Arguments.arguments("GuavaSignedBytes", new GuavaSignedBytes()));
   }
 
   private static byte[] buffer(final int... bytes) {
@@ -83,52 +74,55 @@ private static byte[] buffer(final int... bytes) {
     return array;
   }
 
-  @Test
-  public void atLeastOneBufferHasEightBytes() {
-    assertThat(get(comparator.compare(HLLLLLLL, LLLLLLLL)), is(GREATER_THAN));
-    assertThat(get(comparator.compare(LLLLLLLL, HLLLLLLL)), is(LESS_THAN));
+  @ParameterizedTest
+  @MethodSource("comparatorProvider")
+  void atLeastOneBufferHasEightBytes(final String str, final ComparatorRunner comparator) {
+    assertThat(get(comparator.compare(HLLLLLLL, LLLLLLLL))).isEqualTo(GREATER_THAN);
+    assertThat(get(comparator.compare(LLLLLLLL, HLLLLLLL))).isEqualTo(LESS_THAN);
 
-    assertThat(get(comparator.compare(LHLLLLLL, LLLLLLLL)), is(GREATER_THAN));
-    assertThat(get(comparator.compare(LLLLLLLL, LHLLLLLL)), is(LESS_THAN));
+    assertThat(get(comparator.compare(LHLLLLLL, LLLLLLLL))).isEqualTo(GREATER_THAN);
+    assertThat(get(comparator.compare(LLLLLLLL, LHLLLLLL))).isEqualTo(LESS_THAN);
 
-    assertThat(get(comparator.compare(LLLLLLLL, LLLLLLLX)), is(GREATER_THAN));
-    assertThat(get(comparator.compare(LLLLLLLX, LLLLLLLL)), is(LESS_THAN));
+    assertThat(get(comparator.compare(LLLLLLLL, LLLLLLLX))).isEqualTo(GREATER_THAN);
+    assertThat(get(comparator.compare(LLLLLLLX, LLLLLLLL))).isEqualTo(LESS_THAN);
 
-    assertThat(get(comparator.compare(HLLLLLLL, HLLLLLLX)), is(GREATER_THAN));
-    assertThat(get(comparator.compare(HLLLLLLX, HLLLLLLL)), is(LESS_THAN));
+    assertThat(get(comparator.compare(HLLLLLLL, HLLLLLLX))).isEqualTo(GREATER_THAN);
+    assertThat(get(comparator.compare(HLLLLLLX, HLLLLLLL))).isEqualTo(LESS_THAN);
 
-    assertThat(get(comparator.compare(HLLLLLLX, LHLLLLLL)), is(GREATER_THAN));
-    assertThat(get(comparator.compare(LHLLLLLL, HLLLLLLX)), is(LESS_THAN));
+    assertThat(get(comparator.compare(HLLLLLLX, LHLLLLLL))).isEqualTo(GREATER_THAN);
+    assertThat(get(comparator.compare(LHLLLLLL, HLLLLLLX))).isEqualTo(LESS_THAN);
   }
 
-  @Test
-  public void buffersOfTwoBytes() {
-    assertThat(get(comparator.compare(LL, XX)), is(GREATER_THAN));
-    assertThat(get(comparator.compare(XX, LL)), is(LESS_THAN));
+  @ParameterizedTest
+  @MethodSource("comparatorProvider")
+  void buffersOfTwoBytes(final String str, final ComparatorRunner comparator) {
+    assertThat(get(comparator.compare(LL, XX))).isEqualTo(GREATER_THAN);
+    assertThat(get(comparator.compare(XX, LL))).isEqualTo(LESS_THAN);
 
-    assertThat(get(comparator.compare(LL, LX)), is(GREATER_THAN));
-    assertThat(get(comparator.compare(LX, LL)), is(LESS_THAN));
+    assertThat(get(comparator.compare(LL, LX))).isEqualTo(GREATER_THAN);
+    assertThat(get(comparator.compare(LX, LL))).isEqualTo(LESS_THAN);
 
-    assertThat(get(comparator.compare(LH, LX)), is(GREATER_THAN));
-    assertThat(get(comparator.compare(LX, HL)), is(LESS_THAN));
+    assertThat(get(comparator.compare(LH, LX))).isEqualTo(GREATER_THAN);
+    assertThat(get(comparator.compare(LX, HL))).isEqualTo(LESS_THAN);
 
-    assertThat(get(comparator.compare(HX, LL)), is(GREATER_THAN));
-    assertThat(get(comparator.compare(LH, HX)), is(LESS_THAN));
+    assertThat(get(comparator.compare(HX, LL))).isEqualTo(GREATER_THAN);
+    assertThat(get(comparator.compare(LH, HX))).isEqualTo(LESS_THAN);
   }
 
-  @Test
-  public void equalBuffers() {
-    assertThat(get(comparator.compare(LL, LL)), is(EQUAL_TO));
-    assertThat(get(comparator.compare(HX, HX)), is(EQUAL_TO));
-    assertThat(get(comparator.compare(LH, LH)), is(EQUAL_TO));
-    assertThat(get(comparator.compare(LL, LL)), is(EQUAL_TO));
-    assertThat(get(comparator.compare(LX, LX)), is(EQUAL_TO));
-
-    assertThat(get(comparator.compare(HLLLLLLL, HLLLLLLL)), is(EQUAL_TO));
-    assertThat(get(comparator.compare(HLLLLLLX, HLLLLLLX)), is(EQUAL_TO));
-    assertThat(get(comparator.compare(LHLLLLLL, LHLLLLLL)), is(EQUAL_TO));
-    assertThat(get(comparator.compare(LLLLLLLL, LLLLLLLL)), is(EQUAL_TO));
-    assertThat(get(comparator.compare(LLLLLLLX, LLLLLLLX)), is(EQUAL_TO));
+  @ParameterizedTest
+  @MethodSource("comparatorProvider")
+  void equalBuffers(final String str, final ComparatorRunner comparator) {
+    assertThat(get(comparator.compare(LL, LL))).isEqualTo(EQUAL_TO);
+    assertThat(get(comparator.compare(HX, HX))).isEqualTo(EQUAL_TO);
+    assertThat(get(comparator.compare(LH, LH))).isEqualTo(EQUAL_TO);
+    assertThat(get(comparator.compare(LL, LL))).isEqualTo(EQUAL_TO);
+    assertThat(get(comparator.compare(LX, LX))).isEqualTo(EQUAL_TO);
+
+    assertThat(get(comparator.compare(HLLLLLLL, HLLLLLLL))).isEqualTo(EQUAL_TO);
+    assertThat(get(comparator.compare(HLLLLLLX, HLLLLLLX))).isEqualTo(EQUAL_TO);
+    assertThat(get(comparator.compare(LHLLLLLL, LHLLLLLL))).isEqualTo(EQUAL_TO);
+    assertThat(get(comparator.compare(LLLLLLLL, LLLLLLLL))).isEqualTo(EQUAL_TO);
+    assertThat(get(comparator.compare(LLLLLLLX, LLLLLLLX))).isEqualTo(EQUAL_TO);
   }
 
   /** Tests {@link ByteArrayProxy}. */
@@ -169,14 +163,14 @@ public int compare(final byte[] o1, final byte[] o2) {
       o2b = arrayToBuffer(o2, o2.length * 3);
       final int result2 = c.compare(o1b, o2b);
 
-      assertThat(result2, is(result));
+      assertThat(result2).isEqualTo(result);
 
       // Now try with buffers sized to the array.
       o1b = ByteBuffer.wrap(o1);
       o2b = ByteBuffer.wrap(o2);
       final int result3 = c.compare(o1b, o2b);
 
-      assertThat(result3, is(result));
+      assertThat(result3).isEqualTo(result);
 
       return result;
     }
diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index bd23bc55..22f5f7c7 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -13,13 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package org.lmdbjava;
 
 import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
 import static java.util.Arrays.asList;
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.hasSize;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
 import static org.lmdbjava.Env.create;
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
@@ -47,9 +47,8 @@
 import static org.lmdbjava.TestUtils.bb;
 
 import com.google.common.primitives.UnsignedBytes;
-import java.io.File;
-import java.io.IOException;
 import java.nio.ByteBuffer;
+import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.Deque;
@@ -57,200 +56,210 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.NoSuchElementException;
-import org.hamcrest.Matchers;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 import org.lmdbjava.CursorIterable.KeyVal;
 
 /** Test {@link CursorIterable}. */
 public final class CursorIterableTest {
 
-  @Rule public final TemporaryFolder tmp = new TemporaryFolder();
+  private Path file;
   private Dbi<ByteBuffer> db;
   private Env<ByteBuffer> env;
   private Deque<Integer> list;
 
-  @After
-  public void after() {
+  @BeforeEach
+  void beforeEach() {
+    file = FileUtil.createTempFile();
+    env =
+        create()
+            .setMapSize(KIBIBYTES.toBytes(256))
+            .setMaxReaders(1)
+            .setMaxDbs(1)
+            .open(file.toFile(), POSIX_MODE, MDB_NOSUBDIR);
+    db = env.openDbi(DB_1, MDB_CREATE);
+    populateDatabase(db);
+  }
+
+  private void populateDatabase(final Dbi<ByteBuffer> dbi) {
+    list = new LinkedList<>();
+    list.addAll(asList(2, 3, 4, 5, 6, 7, 8, 9));
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      final Cursor<ByteBuffer> c = dbi.openCursor(txn);
+      c.put(bb(2), bb(3), MDB_NOOVERWRITE);
+      c.put(bb(4), bb(5));
+      c.put(bb(6), bb(7));
+      c.put(bb(8), bb(9));
+      txn.commit();
+    }
+  }
+
+  @AfterEach
+  void afterEach() {
     env.close();
+    FileUtil.delete(file);
   }
 
   @Test
-  public void allBackwardTest() {
+  void allBackwardTest() {
     verify(allBackward(), 8, 6, 4, 2);
   }
 
   @Test
-  public void allTest() {
+  void allTest() {
     verify(all(), 2, 4, 6, 8);
   }
 
   @Test
-  public void atLeastBackwardTest() {
+  void atLeastBackwardTest() {
     verify(atLeastBackward(bb(5)), 4, 2);
     verify(atLeastBackward(bb(6)), 6, 4, 2);
     verify(atLeastBackward(bb(9)), 8, 6, 4, 2);
   }
 
   @Test
-  public void atLeastTest() {
+  void atLeastTest() {
     verify(atLeast(bb(5)), 6, 8);
     verify(atLeast(bb(6)), 6, 8);
   }
 
   @Test
-  public void atMostBackwardTest() {
+  void atMostBackwardTest() {
     verify(atMostBackward(bb(5)), 8, 6);
     verify(atMostBackward(bb(6)), 8, 6);
   }
 
   @Test
-  public void atMostTest() {
+  void atMostTest() {
     verify(atMost(bb(5)), 2, 4);
     verify(atMost(bb(6)), 2, 4, 6);
   }
 
-  @Before
-  public void before() throws IOException {
-    final File path = tmp.newFile();
-    env =
-        create()
-            .setMapSize(KIBIBYTES.toBytes(256))
-            .setMaxReaders(1)
-            .setMaxDbs(1)
-            .open(path, POSIX_MODE, MDB_NOSUBDIR);
-    db = env.openDbi(DB_1, MDB_CREATE);
-    populateDatabase(db);
-  }
-
-  private void populateDatabase(final Dbi<ByteBuffer> dbi) {
-    list = new LinkedList<>();
-    list.addAll(asList(2, 3, 4, 5, 6, 7, 8, 9));
-    try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      final Cursor<ByteBuffer> c = dbi.openCursor(txn);
-      c.put(bb(2), bb(3), MDB_NOOVERWRITE);
-      c.put(bb(4), bb(5));
-      c.put(bb(6), bb(7));
-      c.put(bb(8), bb(9));
-      txn.commit();
-    }
-  }
-
   @Test
-  public void closedBackwardTest() {
+  void closedBackwardTest() {
     verify(closedBackward(bb(7), bb(3)), 6, 4);
     verify(closedBackward(bb(6), bb(2)), 6, 4, 2);
     verify(closedBackward(bb(9), bb(3)), 8, 6, 4);
   }
 
   @Test
-  public void closedOpenBackwardTest() {
+  void closedOpenBackwardTest() {
     verify(closedOpenBackward(bb(8), bb(3)), 8, 6, 4);
     verify(closedOpenBackward(bb(7), bb(2)), 6, 4);
     verify(closedOpenBackward(bb(9), bb(3)), 8, 6, 4);
   }
 
   @Test
-  public void closedOpenTest() {
+  void closedOpenTest() {
     verify(closedOpen(bb(3), bb(8)), 4, 6);
     verify(closedOpen(bb(2), bb(6)), 2, 4);
   }
 
   @Test
-  public void closedTest() {
+  void closedTest() {
     verify(closed(bb(3), bb(7)), 4, 6);
     verify(closed(bb(2), bb(6)), 2, 4, 6);
     verify(closed(bb(1), bb(7)), 2, 4, 6);
   }
 
   @Test
-  public void greaterThanBackwardTest() {
+  void greaterThanBackwardTest() {
     verify(greaterThanBackward(bb(6)), 4, 2);
     verify(greaterThanBackward(bb(7)), 6, 4, 2);
     verify(greaterThanBackward(bb(9)), 8, 6, 4, 2);
   }
 
   @Test
-  public void greaterThanTest() {
+  void greaterThanTest() {
     verify(greaterThan(bb(4)), 6, 8);
     verify(greaterThan(bb(3)), 4, 6, 8);
   }
 
-  @Test(expected = IllegalStateException.class)
-  public void iterableOnlyReturnedOnce() {
-    try (Txn<ByteBuffer> txn = env.txnRead();
-        CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-      c.iterator(); // ok
-      c.iterator(); // fails
-    }
+  @Test
+  void iterableOnlyReturnedOnce() {
+    assertThatThrownBy(
+            () -> {
+              try (Txn<ByteBuffer> txn = env.txnRead();
+                  CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+                c.iterator(); // ok
+                c.iterator(); // fails
+              }
+            })
+        .isInstanceOf(IllegalStateException.class);
   }
 
   @Test
-  public void iterate() {
+  void iterate() {
     try (Txn<ByteBuffer> txn = env.txnRead();
         CursorIterable<ByteBuffer> c = db.iterate(txn)) {
       for (final KeyVal<ByteBuffer> kv : c) {
-        assertThat(kv.key().getInt(), is(list.pollFirst()));
-        assertThat(kv.val().getInt(), is(list.pollFirst()));
+        assertThat(kv.key().getInt()).isEqualTo(list.pollFirst());
+        assertThat(kv.val().getInt()).isEqualTo(list.pollFirst());
       }
     }
   }
 
-  @Test(expected = IllegalStateException.class)
-  public void iteratorOnlyReturnedOnce() {
-    try (Txn<ByteBuffer> txn = env.txnRead();
-        CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-      c.iterator(); // ok
-      c.iterator(); // fails
-    }
+  @Test
+  void iteratorOnlyReturnedOnce() {
+    assertThatThrownBy(
+            () -> {
+              try (Txn<ByteBuffer> txn = env.txnRead();
+                  CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+                c.iterator(); // ok
+                c.iterator(); // fails
+              }
+            })
+        .isInstanceOf(IllegalStateException.class);
   }
 
   @Test
-  public void lessThanBackwardTest() {
+  void lessThanBackwardTest() {
     verify(lessThanBackward(bb(5)), 8, 6);
     verify(lessThanBackward(bb(2)), 8, 6, 4);
   }
 
   @Test
-  public void lessThanTest() {
+  void lessThanTest() {
     verify(lessThan(bb(5)), 2, 4);
     verify(lessThan(bb(8)), 2, 4, 6);
   }
 
-  @Test(expected = NoSuchElementException.class)
-  public void nextThrowsNoSuchElementExceptionIfNoMoreElements() {
-    try (Txn<ByteBuffer> txn = env.txnRead();
-        CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-      final Iterator<KeyVal<ByteBuffer>> i = c.iterator();
-      while (i.hasNext()) {
-        final KeyVal<ByteBuffer> kv = i.next();
-        assertThat(kv.key().getInt(), is(list.pollFirst()));
-        assertThat(kv.val().getInt(), is(list.pollFirst()));
-      }
-      assertThat(i.hasNext(), is(false));
-      i.next();
-    }
+  @Test
+  void nextThrowsNoSuchElementExceptionIfNoMoreElements() {
+    assertThatThrownBy(
+            () -> {
+              try (Txn<ByteBuffer> txn = env.txnRead();
+                  CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+                final Iterator<KeyVal<ByteBuffer>> i = c.iterator();
+                while (i.hasNext()) {
+                  final KeyVal<ByteBuffer> kv = i.next();
+                  assertThat(kv.key().getInt()).isEqualTo(list.pollFirst());
+                  assertThat(kv.val().getInt()).isEqualTo(list.pollFirst());
+                }
+                assertThat(i.hasNext()).isFalse();
+                i.next();
+              }
+            })
+        .isInstanceOf(NoSuchElementException.class);
   }
 
   @Test
-  public void openBackwardTest() {
+  void openBackwardTest() {
     verify(openBackward(bb(7), bb(2)), 6, 4);
     verify(openBackward(bb(8), bb(1)), 6, 4, 2);
     verify(openBackward(bb(9), bb(4)), 8, 6);
   }
 
   @Test
-  public void openClosedBackwardTest() {
+  void openClosedBackwardTest() {
     verify(openClosedBackward(bb(7), bb(2)), 6, 4, 2);
     verify(openClosedBackward(bb(8), bb(4)), 6, 4);
     verify(openClosedBackward(bb(9), bb(4)), 8, 6, 4);
   }
 
   @Test
-  public void openClosedBackwardTestWithGuava() {
+  void openClosedBackwardTestWithGuava() {
     final Comparator<byte[]> guava = UnsignedBytes.lexicographicalComparator();
     final Comparator<ByteBuffer> comparator =
         (bb1, bb2) -> {
@@ -271,19 +280,19 @@ public void openClosedBackwardTestWithGuava() {
   }
 
   @Test
-  public void openClosedTest() {
+  void openClosedTest() {
     verify(openClosed(bb(3), bb(8)), 4, 6, 8);
     verify(openClosed(bb(2), bb(6)), 4, 6);
   }
 
   @Test
-  public void openTest() {
+  void openTest() {
     verify(open(bb(3), bb(7)), 4, 6);
     verify(open(bb(2), bb(8)), 4, 6);
   }
 
   @Test
-  public void removeOddElements() {
+  void removeOddElements() {
     verify(all(), 2, 4, 6, 8);
     int idx = -1;
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
@@ -302,55 +311,71 @@ public void removeOddElements() {
     verify(all(), 4, 8);
   }
 
-  @Test(expected = Env.AlreadyClosedException.class)
-  public void nextWithClosedEnvTest() {
-    try (Txn<ByteBuffer> txn = env.txnRead()) {
-      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+  @Test
+  void nextWithClosedEnvTest() {
+    assertThatThrownBy(
+            () -> {
+              try (Txn<ByteBuffer> txn = env.txnRead()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
 
-        env.close();
-        c.next();
-      }
-    }
+                  env.close();
+                  c.next();
+                }
+              }
+            })
+        .isInstanceOf(Env.AlreadyClosedException.class);
   }
 
-  @Test(expected = Env.AlreadyClosedException.class)
-  public void removeWithClosedEnvTest() {
-    try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+  @Test
+  void removeWithClosedEnvTest() {
+    assertThatThrownBy(
+            () -> {
+              try (Txn<ByteBuffer> txn = env.txnWrite()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
 
-        final KeyVal<ByteBuffer> keyVal = c.next();
-        assertThat(keyVal, Matchers.notNullValue());
+                  final KeyVal<ByteBuffer> keyVal = c.next();
+                  assertThat(keyVal).isNotNull();
 
-        env.close();
-        c.remove();
-      }
-    }
+                  env.close();
+                  c.remove();
+                }
+              }
+            })
+        .isInstanceOf(Env.AlreadyClosedException.class);
   }
 
-  @Test(expected = Env.AlreadyClosedException.class)
-  public void hasNextWithClosedEnvTest() {
-    try (Txn<ByteBuffer> txn = env.txnRead()) {
-      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+  @Test
+  void hasNextWithClosedEnvTest() {
+    assertThatThrownBy(
+            () -> {
+              try (Txn<ByteBuffer> txn = env.txnRead()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
 
-        env.close();
-        c.hasNext();
-      }
-    }
+                  env.close();
+                  c.hasNext();
+                }
+              }
+            })
+        .isInstanceOf(Env.AlreadyClosedException.class);
   }
 
-  @Test(expected = Env.AlreadyClosedException.class)
-  public void forEachRemainingWithClosedEnvTest() {
-    try (Txn<ByteBuffer> txn = env.txnRead()) {
-      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+  @Test
+  void forEachRemainingWithClosedEnvTest() {
+    assertThatThrownBy(
+            () -> {
+              try (Txn<ByteBuffer> txn = env.txnRead()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
 
-        env.close();
-        c.forEachRemaining(keyVal -> {});
-      }
-    }
+                  env.close();
+                  c.forEachRemaining(keyVal -> {});
+                }
+              }
+            })
+        .isInstanceOf(Env.AlreadyClosedException.class);
   }
 
   private void verify(final KeyRange<ByteBuffer> range, final int... expected) {
@@ -367,13 +392,13 @@ private void verify(
         final int key = kv.key().getInt();
         final int val = kv.val().getInt();
         results.add(key);
-        assertThat(val, is(key + 1));
+        assertThat(val).isEqualTo(key + 1);
       }
     }
 
-    assertThat(results, hasSize(expected.length));
+    assertThat(results.size()).isEqualTo(expected.length);
     for (int idx = 0; idx < results.size(); idx++) {
-      assertThat(results.get(idx), is(expected[idx]));
+      assertThat(results.get(idx)).isEqualTo(expected[idx]);
     }
   }
 }
diff --git a/src/test/java/org/lmdbjava/CursorParamTest.java b/src/test/java/org/lmdbjava/CursorParamTest.java
index bd99e709..0b2df19e 100644
--- a/src/test/java/org/lmdbjava/CursorParamTest.java
+++ b/src/test/java/org/lmdbjava/CursorParamTest.java
@@ -13,14 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package org.lmdbjava;
 
-import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
+import static com.jakewharton.byteunits.BinaryByteUnit.MEBIBYTES;
 import static java.lang.Long.BYTES;
 import static java.nio.charset.StandardCharsets.UTF_8;
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.collection.IsEmptyCollection.empty;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
 import static org.lmdbjava.ByteBufProxy.PROXY_NETTY;
 import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
@@ -44,40 +43,31 @@
 import static org.lmdbjava.TestUtils.nb;
 
 import io.netty.buffer.ByteBuf;
-import java.io.File;
-import java.io.IOException;
 import java.nio.ByteBuffer;
+import java.nio.file.Path;
+import java.util.stream.Stream;
 import org.agrona.DirectBuffer;
 import org.agrona.MutableDirectBuffer;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameter;
-import org.junit.runners.Parameterized.Parameters;
+import org.junit.jupiter.api.io.TempDir;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 
 /** Test {@link Cursor} with different buffer implementations. */
-@RunWith(Parameterized.class)
 public final class CursorParamTest {
 
-  /** Injected by {@link #data()} with appropriate runner. */
-  @Parameter public BufferRunner<?> runner;
-
-  @Rule public final TemporaryFolder tmp = new TemporaryFolder();
-
-  @Parameters(name = "{index}: buffer adapter: {0}")
-  public static Object[] data() {
-    final BufferRunner<ByteBuffer> bb1 = new ByteBufferRunner(PROXY_OPTIMAL);
-    final BufferRunner<ByteBuffer> bb2 = new ByteBufferRunner(PROXY_SAFE);
-    final BufferRunner<byte[]> ba = new ByteArrayRunner(PROXY_BA);
-    final BufferRunner<DirectBuffer> db = new DirectBufferRunner();
-    final BufferRunner<ByteBuf> netty = new NettyBufferRunner();
-    return new Object[] {bb1, bb2, ba, db, netty};
+  static Stream<Arguments> data() {
+    return Stream.of(
+        Arguments.arguments("ByteBufferRunner(PROXY_OPTIMAL)", new ByteBufferRunner(PROXY_OPTIMAL)),
+        Arguments.arguments("ByteBufferRunner(PROXY_SAFE)", new ByteBufferRunner(PROXY_SAFE)),
+        Arguments.arguments("ByteArrayRunner(PROXY_BA)", new ByteArrayRunner(PROXY_BA)),
+        Arguments.arguments("DirectBufferRunner", new DirectBufferRunner()),
+        Arguments.arguments("NettyBufferRunner", new NettyBufferRunner()));
   }
 
-  @Test
-  public void execute() {
+  @ParameterizedTest
+  @MethodSource("data")
+  void execute(final String name, final BufferRunner<?> runner, @TempDir final Path tmp) {
     runner.execute(tmp);
   }
 
@@ -95,11 +85,11 @@ protected AbstractBufferRunner(final BufferProxy<T> proxy) {
     }
 
     @Override
-    public final void execute(final TemporaryFolder tmp) {
+    public final void execute(final Path tmp) {
       try (Env<T> env = env(tmp)) {
-        assertThat(env.getDbiNames(), empty());
+        assertThat(env.getDbiNames()).isEmpty();
         final Dbi<T> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
-        assertThat(env.getDbiNames().get(0), is(DB_1.getBytes(UTF_8)));
+        assertThat(env.getDbiNames().get(0)).isEqualTo(DB_1.getBytes(UTF_8));
         try (Txn<T> txn = env.txnWrite();
             Cursor<T> c = db.openCursor(txn)) {
           // populate data
@@ -113,71 +103,66 @@ public final void execute(final TemporaryFolder tmp) {
 
           // check MDB_SET operations
           final T key3 = set(3);
-          assertThat(c.get(key3, MDB_SET_KEY), is(true));
-          assertThat(get(c.key()), is(3));
-          assertThat(get(c.val()), is(4));
+          assertThat(c.get(key3, MDB_SET_KEY)).isTrue();
+          assertThat(get(c.key())).isEqualTo(3);
+          assertThat(get(c.val())).isEqualTo(4);
           final T key6 = set(6);
-          assertThat(c.get(key6, MDB_SET_RANGE), is(true));
-          assertThat(get(c.key()), is(7));
+          assertThat(c.get(key6, MDB_SET_RANGE)).isTrue();
+          assertThat(get(c.key())).isEqualTo(7);
           if (!(this instanceof ByteArrayRunner)) {
-            assertThat(get(c.val()), is(8));
+            assertThat(get(c.val())).isEqualTo(8);
           }
           final T key999 = set(999);
-          assertThat(c.get(key999, MDB_SET_KEY), is(false));
+          assertThat(c.get(key999, MDB_SET_KEY)).isFalse();
 
           // check MDB navigation operations
-          assertThat(c.seek(MDB_LAST), is(true));
+          assertThat(c.seek(MDB_LAST)).isTrue();
           final int mdb1 = get(c.key());
           final int mdb2 = get(c.val());
 
-          assertThat(c.seek(MDB_PREV), is(true));
+          assertThat(c.seek(MDB_PREV)).isTrue();
           final int mdb3 = get(c.key());
           final int mdb4 = get(c.val());
 
-          assertThat(c.seek(MDB_NEXT), is(true));
+          assertThat(c.seek(MDB_NEXT)).isTrue();
           final int mdb5 = get(c.key());
           final int mdb6 = get(c.val());
 
-          assertThat(c.seek(MDB_FIRST), is(true));
+          assertThat(c.seek(MDB_FIRST)).isTrue();
           final int mdb7 = get(c.key());
           final int mdb8 = get(c.val());
 
           // assert afterwards to ensure memory address from LMDB
           // are valid within same txn and across cursor movement
           // MDB_LAST
-          assertThat(mdb1, is(7));
+          assertThat(mdb1).isEqualTo(7);
           if (!(this instanceof ByteArrayRunner)) {
-            assertThat(mdb2, is(8));
+            assertThat(mdb2).isEqualTo(8);
           }
 
           // MDB_PREV
-          assertThat(mdb3, is(5));
-          assertThat(mdb4, is(6));
+          assertThat(mdb3).isEqualTo(5);
+          assertThat(mdb4).isEqualTo(6);
 
           // MDB_NEXT
-          assertThat(mdb5, is(7));
+          assertThat(mdb5).isEqualTo(7);
           if (!(this instanceof ByteArrayRunner)) {
-            assertThat(mdb6, is(8));
+            assertThat(mdb6).isEqualTo(8);
           }
 
           // MDB_FIRST
-          assertThat(mdb7, is(1));
-          assertThat(mdb8, is(2));
+          assertThat(mdb7).isEqualTo(1);
+          assertThat(mdb8).isEqualTo(2);
         }
       }
     }
 
-    private Env<T> env(final TemporaryFolder tmp) {
-      try {
-        final File path = tmp.newFile();
-        return create(proxy)
-            .setMapSize(KIBIBYTES.toBytes(1_024))
-            .setMaxReaders(1)
-            .setMaxDbs(1)
-            .open(path, POSIX_MODE, MDB_NOSUBDIR);
-      } catch (final IOException e) {
-        throw new LmdbException("IO failure", e);
-      }
+    private Env<T> env(final Path tmp) {
+      return create(proxy)
+          .setMapSize(MEBIBYTES.toBytes(1))
+          .setMaxReaders(1)
+          .setMaxDbs(1)
+          .open(tmp.resolve("db").toFile(), POSIX_MODE, MDB_NOSUBDIR);
     }
   }
 
@@ -291,7 +276,7 @@ public void set(final ByteBuf buff, final int val) {
    */
   private interface BufferRunner<T> {
 
-    void execute(TemporaryFolder tmp);
+    void execute(Path tmp);
 
     T set(int val);
 
diff --git a/src/test/java/org/lmdbjava/CursorTest.java b/src/test/java/org/lmdbjava/CursorTest.java
index cf6e4dea..a0c78855 100644
--- a/src/test/java/org/lmdbjava/CursorTest.java
+++ b/src/test/java/org/lmdbjava/CursorTest.java
@@ -13,16 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package org.lmdbjava;
 
-import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
+import static com.jakewharton.byteunits.BinaryByteUnit.MEBIBYTES;
 import static java.lang.Long.BYTES;
 import static java.lang.Long.MIN_VALUE;
 import static java.nio.ByteBuffer.allocateDirect;
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
 import static org.lmdbjava.DbiFlags.MDB_DUPFIXED;
@@ -41,141 +40,175 @@
 import static org.lmdbjava.TestUtils.POSIX_MODE;
 import static org.lmdbjava.TestUtils.bb;
 
-import java.io.File;
-import java.io.IOException;
 import java.nio.ByteBuffer;
+import java.nio.file.Path;
 import java.util.function.Consumer;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 import org.lmdbjava.Cursor.ClosedException;
+import org.lmdbjava.Env.AlreadyClosedException;
 import org.lmdbjava.Txn.NotReadyException;
 import org.lmdbjava.Txn.ReadOnlyRequiredException;
 
 /** Test {@link Cursor}. */
 public final class CursorTest {
 
-  @Rule public final TemporaryFolder tmp = new TemporaryFolder();
-
+  private Path file;
   private Env<ByteBuffer> env;
 
-  @After
-  public void after() {
-    env.close();
+  @BeforeEach
+  void beforeEach() {
+    file = FileUtil.createTempFile();
+    env =
+        create(PROXY_OPTIMAL)
+            .setMapSize(MEBIBYTES.toBytes(1))
+            .setMaxReaders(1)
+            .setMaxDbs(1)
+            .open(file.toFile(), POSIX_MODE, MDB_NOSUBDIR);
   }
 
-  @Before
-  public void before() throws IOException {
-    try {
-      final File path = tmp.newFile();
-      env =
-          create(PROXY_OPTIMAL)
-              .setMapSize(KIBIBYTES.toBytes(1_024))
-              .setMaxReaders(1)
-              .setMaxDbs(1)
-              .open(path, POSIX_MODE, MDB_NOSUBDIR);
-    } catch (final IOException e) {
-      throw new LmdbException("IO failure", e);
-    }
+  @AfterEach
+  void afterEach() {
+    env.close();
+    FileUtil.delete(file);
   }
 
-  @Test(expected = ClosedException.class)
-  public void closedCursorRejectsSubsequentGets() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
-    try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      final Cursor<ByteBuffer> c = db.openCursor(txn);
-      c.close();
-      c.seek(MDB_FIRST);
-    }
+  @Test
+  void closedCursorRejectsSubsequentGets() {
+    assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+              try (Txn<ByteBuffer> txn = env.txnWrite()) {
+                final Cursor<ByteBuffer> c = db.openCursor(txn);
+                c.close();
+                c.seek(MDB_FIRST);
+              }
+            })
+        .isInstanceOf(ClosedException.class);
   }
 
-  @Test(expected = Env.AlreadyClosedException.class)
-  public void closedEnvRejectsSeekFirstCall() {
-    doEnvClosedTest(null, c -> c.seek(MDB_FIRST));
+  @Test
+  void closedEnvRejectsSeekFirstCall() {
+    assertThatThrownBy(
+            () -> {
+              doEnvClosedTest(null, c -> c.seek(MDB_FIRST));
+            })
+        .isInstanceOf(AlreadyClosedException.class);
   }
 
-  @Test(expected = Env.AlreadyClosedException.class)
-  public void closedEnvRejectsSeekLastCall() {
-    doEnvClosedTest(null, c -> c.seek(MDB_LAST));
+  @Test
+  void closedEnvRejectsSeekLastCall() {
+    assertThatThrownBy(
+            () -> {
+              doEnvClosedTest(null, c -> c.seek(MDB_LAST));
+            })
+        .isInstanceOf(AlreadyClosedException.class);
   }
 
-  @Test(expected = Env.AlreadyClosedException.class)
-  public void closedEnvRejectsSeekNextCall() {
-    doEnvClosedTest(null, c -> c.seek(MDB_NEXT));
+  @Test
+  void closedEnvRejectsSeekNextCall() {
+    assertThatThrownBy(
+            () -> {
+              doEnvClosedTest(null, c -> c.seek(MDB_NEXT));
+            })
+        .isInstanceOf(AlreadyClosedException.class);
   }
 
-  @Test(expected = Env.AlreadyClosedException.class)
-  public void closedEnvRejectsCloseCall() {
-    doEnvClosedTest(null, Cursor::close);
+  @Test
+  void closedEnvRejectsCloseCall() {
+    assertThatThrownBy(
+            () -> {
+              doEnvClosedTest(null, Cursor::close);
+            })
+        .isInstanceOf(AlreadyClosedException.class);
   }
 
-  @Test(expected = Env.AlreadyClosedException.class)
-  public void closedEnvRejectsFirstCall() {
-    doEnvClosedTest(null, Cursor::first);
+  @Test
+  void closedEnvRejectsFirstCall() {
+    assertThatThrownBy(
+            () -> {
+              doEnvClosedTest(null, Cursor::first);
+            })
+        .isInstanceOf(AlreadyClosedException.class);
   }
 
-  @Test(expected = Env.AlreadyClosedException.class)
-  public void closedEnvRejectsLastCall() {
-    doEnvClosedTest(null, Cursor::last);
+  @Test
+  void closedEnvRejectsLastCall() {
+    assertThatThrownBy(
+            () -> {
+              doEnvClosedTest(null, Cursor::last);
+            })
+        .isInstanceOf(AlreadyClosedException.class);
   }
 
-  @Test(expected = Env.AlreadyClosedException.class)
-  public void closedEnvRejectsPrevCall() {
-    doEnvClosedTest(
-        c -> {
-          c.first();
-          assertThat(c.key().getInt(), is(1));
-          assertThat(c.val().getInt(), is(10));
-          c.next();
-        },
-        Cursor::prev);
+  @Test
+  void closedEnvRejectsPrevCall() {
+    assertThatThrownBy(
+            () -> {
+              doEnvClosedTest(
+                  c -> {
+                    c.first();
+                    assertThat(c.key().getInt()).isEqualTo(1);
+                    assertThat(c.val().getInt()).isEqualTo(10);
+                    c.next();
+                  },
+                  Cursor::prev);
+            })
+        .isInstanceOf(AlreadyClosedException.class);
   }
 
-  @Test(expected = Env.AlreadyClosedException.class)
-  public void closedEnvRejectsDeleteCall() {
-    doEnvClosedTest(
-        c -> {
-          c.first();
-          assertThat(c.key().getInt(), is(1));
-          assertThat(c.val().getInt(), is(10));
-        },
-        Cursor::delete);
+  @Test
+  void closedEnvRejectsDeleteCall() {
+    assertThatThrownBy(
+            () -> {
+              doEnvClosedTest(
+                  c -> {
+                    c.first();
+                    assertThat(c.key().getInt()).isEqualTo(1);
+                    assertThat(c.val().getInt()).isEqualTo(10);
+                  },
+                  Cursor::delete);
+            })
+        .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
-  public void count() {
+  void count() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
     try (Txn<ByteBuffer> txn = env.txnWrite();
         Cursor<ByteBuffer> c = db.openCursor(txn)) {
       c.put(bb(1), bb(2), MDB_APPENDDUP);
-      assertThat(c.count(), is(1L));
+      assertThat(c.count()).isEqualTo(1L);
       c.put(bb(1), bb(4), MDB_APPENDDUP);
       c.put(bb(1), bb(6), MDB_APPENDDUP);
-      assertThat(c.count(), is(3L));
+      assertThat(c.count()).isEqualTo(3L);
       c.put(bb(2), bb(1), MDB_APPENDDUP);
       c.put(bb(2), bb(2), MDB_APPENDDUP);
-      assertThat(c.count(), is(2L));
+      assertThat(c.count()).isEqualTo(2L);
     }
   }
 
-  @Test(expected = NotReadyException.class)
-  public void cursorCannotCloseIfTransactionCommitted() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
-    try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      try (Cursor<ByteBuffer> c = db.openCursor(txn); ) {
-        c.put(bb(1), bb(2), MDB_APPENDDUP);
-        assertThat(c.count(), is(1L));
-        c.put(bb(1), bb(4), MDB_APPENDDUP);
-        assertThat(c.count(), is(2L));
-        txn.commit();
-      }
-    }
+  @Test
+  void cursorCannotCloseIfTransactionCommitted() {
+    assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+              try (Txn<ByteBuffer> txn = env.txnWrite()) {
+                try (Cursor<ByteBuffer> c = db.openCursor(txn); ) {
+                  c.put(bb(1), bb(2), MDB_APPENDDUP);
+                  assertThat(c.count()).isEqualTo(1L);
+                  c.put(bb(1), bb(4), MDB_APPENDDUP);
+                  assertThat(c.count()).isEqualTo(2L);
+                  txn.commit();
+                }
+              }
+            })
+        .isInstanceOf(NotReadyException.class);
   }
 
   @Test
-  public void cursorFirstLastNextPrev() {
+  void cursorFirstLastNextPrev() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
     try (Txn<ByteBuffer> txn = env.txnWrite();
         Cursor<ByteBuffer> c = db.openCursor(txn)) {
@@ -184,46 +217,46 @@ public void cursorFirstLastNextPrev() {
       c.put(bb(5), bb(6));
       c.put(bb(7), bb(8));
 
-      assertThat(c.first(), is(true));
-      assertThat(c.key().getInt(0), is(1));
-      assertThat(c.val().getInt(0), is(2));
+      assertThat(c.first()).isTrue();
+      assertThat(c.key().getInt(0)).isEqualTo(1);
+      assertThat(c.val().getInt(0)).isEqualTo(2);
 
-      assertThat(c.last(), is(true));
-      assertThat(c.key().getInt(0), is(7));
-      assertThat(c.val().getInt(0), is(8));
+      assertThat(c.last()).isTrue();
+      assertThat(c.key().getInt(0)).isEqualTo(7);
+      assertThat(c.val().getInt(0)).isEqualTo(8);
 
-      assertThat(c.prev(), is(true));
-      assertThat(c.key().getInt(0), is(5));
-      assertThat(c.val().getInt(0), is(6));
+      assertThat(c.prev()).isTrue();
+      assertThat(c.key().getInt(0)).isEqualTo(5);
+      assertThat(c.val().getInt(0)).isEqualTo(6);
 
-      assertThat(c.first(), is(true));
-      assertThat(c.next(), is(true));
-      assertThat(c.key().getInt(0), is(3));
-      assertThat(c.val().getInt(0), is(4));
+      assertThat(c.first()).isTrue();
+      assertThat(c.next()).isTrue();
+      assertThat(c.key().getInt(0)).isEqualTo(3);
+      assertThat(c.val().getInt(0)).isEqualTo(4);
     }
   }
 
   @Test
-  public void delete() {
+  void delete() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
     try (Txn<ByteBuffer> txn = env.txnWrite();
         Cursor<ByteBuffer> c = db.openCursor(txn)) {
       c.put(bb(1), bb(2), MDB_NOOVERWRITE);
       c.put(bb(3), bb(4));
-      assertThat(c.seek(MDB_FIRST), is(true));
-      assertThat(c.key().getInt(), is(1));
-      assertThat(c.val().getInt(), is(2));
+      assertThat(c.seek(MDB_FIRST)).isTrue();
+      assertThat(c.key().getInt()).isEqualTo(1);
+      assertThat(c.val().getInt()).isEqualTo(2);
       c.delete();
-      assertThat(c.seek(MDB_FIRST), is(true));
-      assertThat(c.key().getInt(), is(3));
-      assertThat(c.val().getInt(), is(4));
+      assertThat(c.seek(MDB_FIRST)).isTrue();
+      assertThat(c.key().getInt()).isEqualTo(3);
+      assertThat(c.val().getInt()).isEqualTo(4);
       c.delete();
-      assertThat(c.seek(MDB_FIRST), is(false));
+      assertThat(c.seek(MDB_FIRST)).isFalse();
     }
   }
 
   @Test
-  public void getKeyVal() {
+  void getKeyVal() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
     try (Txn<ByteBuffer> txn = env.txnWrite();
         Cursor<ByteBuffer> c = db.openCursor(txn)) {
@@ -234,17 +267,17 @@ public void getKeyVal() {
       c.put(bb(2), bb(2), MDB_APPENDDUP);
       c.put(bb(2), bb(3), MDB_APPENDDUP);
       c.put(bb(2), bb(4), MDB_APPENDDUP);
-      assertThat(c.get(bb(1), bb(2), MDB_GET_BOTH), is(true));
-      assertThat(c.count(), is(3L));
-      assertThat(c.get(bb(1), bb(3), MDB_GET_BOTH), is(false));
-      assertThat(c.get(bb(2), bb(1), MDB_GET_BOTH), is(true));
-      assertThat(c.count(), is(4L));
-      assertThat(c.get(bb(2), bb(0), MDB_GET_BOTH), is(false));
+      assertThat(c.get(bb(1), bb(2), MDB_GET_BOTH)).isTrue();
+      assertThat(c.count()).isEqualTo(3L);
+      assertThat(c.get(bb(1), bb(3), MDB_GET_BOTH)).isFalse();
+      assertThat(c.get(bb(2), bb(1), MDB_GET_BOTH)).isTrue();
+      assertThat(c.count()).isEqualTo(4L);
+      assertThat(c.get(bb(2), bb(0), MDB_GET_BOTH)).isFalse();
     }
   }
 
   @Test
-  public void putMultiple() {
+  void putMultiple() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT, MDB_DUPFIXED);
     final int elemCount = 20;
 
@@ -259,21 +292,25 @@ public void putMultiple() {
     try (Txn<ByteBuffer> txn = env.txnWrite();
         Cursor<ByteBuffer> c = db.openCursor(txn)) {
       c.putMultiple(k, values, elemCount, MDB_MULTIPLE);
-      assertThat(c.count(), is((long) elemCount));
+      assertThat(c.count()).isEqualTo((long) elemCount);
     }
   }
 
-  @Test(expected = IllegalArgumentException.class)
-  public void putMultipleWithoutMdbMultipleFlag() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
-    try (Txn<ByteBuffer> txn = env.txnWrite();
-        Cursor<ByteBuffer> c = db.openCursor(txn)) {
-      c.putMultiple(bb(100), bb(1), 1);
-    }
+  @Test
+  void putMultipleWithoutMdbMultipleFlag() {
+    assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+              try (Txn<ByteBuffer> txn = env.txnWrite();
+                  Cursor<ByteBuffer> c = db.openCursor(txn)) {
+                c.putMultiple(bb(100), bb(1), 1);
+              }
+            })
+        .isInstanceOf(IllegalArgumentException.class);
   }
 
   @Test
-  public void renewTxRo() {
+  void renewTxRo() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
 
     final Cursor<ByteBuffer> c;
@@ -290,20 +327,24 @@ public void renewTxRo() {
     c.close();
   }
 
-  @Test(expected = ReadOnlyRequiredException.class)
-  public void renewTxRw() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
-    try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      assertThat(txn.isReadOnly(), is(false));
-
-      try (Cursor<ByteBuffer> c = db.openCursor(txn)) {
-        c.renew(txn);
-      }
-    }
+  @Test
+  void renewTxRw() {
+    assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+              try (Txn<ByteBuffer> txn = env.txnWrite()) {
+                assertThat(txn.isReadOnly()).isFalse();
+
+                try (Cursor<ByteBuffer> c = db.openCursor(txn)) {
+                  c.renew(txn);
+                }
+              }
+            })
+        .isInstanceOf(ReadOnlyRequiredException.class);
   }
 
   @Test
-  public void repeatedCloseCausesNotError() {
+  void repeatedCloseCausesNotError() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       final Cursor<ByteBuffer> c = db.openCursor(txn);
@@ -313,52 +354,52 @@ public void repeatedCloseCausesNotError() {
   }
 
   @Test
-  public void reserve() {
+  void reserve() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
     final ByteBuffer key = bb(5);
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      assertNull(db.get(txn, key));
+      assertThat(db.get(txn, key)).isNull();
       try (Cursor<ByteBuffer> c = db.openCursor(txn)) {
         final ByteBuffer val = c.reserve(key, BYTES * 2);
-        assertNotNull(db.get(txn, key));
+        assertThat(db.get(txn, key)).isNotNull();
         val.putLong(MIN_VALUE).flip();
       }
       txn.commit();
     }
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       final ByteBuffer val = db.get(txn, key);
-      assertThat(val.capacity(), is(BYTES * 2));
-      assertThat(val.getLong(), is(MIN_VALUE));
+      assertThat(val.capacity()).isEqualTo(BYTES * 2);
+      assertThat(val.getLong()).isEqualTo(MIN_VALUE);
     }
   }
 
   @Test
-  public void returnValueForNoDupData() {
+  void returnValueForNoDupData() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
     try (Txn<ByteBuffer> txn = env.txnWrite();
         Cursor<ByteBuffer> c = db.openCursor(txn)) {
       // ok
-      assertThat(c.put(bb(5), bb(6), MDB_NODUPDATA), is(true));
-      assertThat(c.put(bb(5), bb(7), MDB_NODUPDATA), is(true));
-      assertThat(c.put(bb(5), bb(6), MDB_NODUPDATA), is(false));
+      assertThat(c.put(bb(5), bb(6), MDB_NODUPDATA)).isTrue();
+      assertThat(c.put(bb(5), bb(7), MDB_NODUPDATA)).isTrue();
+      assertThat(c.put(bb(5), bb(6), MDB_NODUPDATA)).isFalse();
     }
   }
 
   @Test
-  public void returnValueForNoOverwrite() {
+  void returnValueForNoOverwrite() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
     try (Txn<ByteBuffer> txn = env.txnWrite();
         Cursor<ByteBuffer> c = db.openCursor(txn)) {
       // ok
-      assertThat(c.put(bb(5), bb(6), MDB_NOOVERWRITE), is(true));
+      assertThat(c.put(bb(5), bb(6), MDB_NOOVERWRITE)).isTrue();
       // fails, but gets exist val
-      assertThat(c.put(bb(5), bb(8), MDB_NOOVERWRITE), is(false));
-      assertThat(c.val().getInt(0), is(6));
+      assertThat(c.put(bb(5), bb(8), MDB_NOOVERWRITE)).isFalse();
+      assertThat(c.val().getInt(0)).isEqualTo(6);
     }
   }
 
   @Test
-  public void testCursorByteBufferDuplicate() {
+  void testCursorByteBufferDuplicate() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       try (Cursor<ByteBuffer> c = db.openCursor(txn)) {
@@ -377,11 +418,11 @@ public void testCursorByteBufferDuplicate() {
         final ByteBuffer key2 = c.key().duplicate();
         final ByteBuffer val2 = c.val().duplicate();
 
-        assertThat(key1.getInt(0), is(1));
-        assertThat(val1.getInt(0), is(2));
+        assertThat(key1.getInt(0)).isEqualTo(1);
+        assertThat(val1.getInt(0)).isEqualTo(2);
 
-        assertThat(key2.getInt(0), is(3));
-        assertThat(val2.getInt(0), is(4));
+        assertThat(key2.getInt(0)).isEqualTo(3);
+        assertThat(val2.getInt(0)).isEqualTo(4);
       }
     }
   }
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 75c23931..844a819e 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package org.lmdbjava;
 
 import static com.jakewharton.byteunits.BinaryByteUnit.MEBIBYTES;
@@ -24,16 +25,8 @@
 import static java.util.concurrent.TimeUnit.SECONDS;
 import static java.util.stream.Collectors.toList;
 import static java.util.stream.IntStream.range;
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.CoreMatchers.not;
-import static org.hamcrest.CoreMatchers.notNullValue;
-import static org.hamcrest.CoreMatchers.nullValue;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.containsInAnyOrder;
-import static org.hamcrest.Matchers.hasSize;
-import static org.hamcrest.collection.IsEmptyCollection.empty;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
 import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
@@ -46,11 +39,13 @@
 import static org.lmdbjava.KeyRange.atMost;
 import static org.lmdbjava.PutFlags.MDB_NODUPDATA;
 import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
-import static org.lmdbjava.TestUtils.*;
+import static org.lmdbjava.TestUtils.DB_1;
+import static org.lmdbjava.TestUtils.ba;
+import static org.lmdbjava.TestUtils.bb;
+import static org.lmdbjava.TestUtils.fromBa;
 
-import java.io.File;
-import java.io.IOException;
 import java.nio.ByteBuffer;
+import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.Iterator;
@@ -61,13 +56,13 @@
 import java.util.concurrent.Future;
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.function.*;
-import org.hamcrest.Matchers;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
+import java.util.function.BiConsumer;
+import java.util.function.Function;
+import java.util.function.IntFunction;
+import java.util.function.ToIntFunction;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 import org.lmdbjava.CursorIterable.KeyVal;
 import org.lmdbjava.Dbi.DbFullException;
 import org.lmdbjava.Env.AlreadyClosedException;
@@ -77,43 +72,51 @@
 /** Test {@link Dbi}. */
 public final class DbiTest {
 
-  @Rule public final TemporaryFolder tmp = new TemporaryFolder();
+  private Path file;
   private Env<ByteBuffer> env;
+  private Path fileBa;
   private Env<byte[]> envBa;
 
-  @After
-  public void after() {
-    env.close();
-  }
-
-  @Before
-  public void before() throws IOException {
-    final File path = tmp.newFile();
+  @BeforeEach
+  void beforeEach() {
+    file = FileUtil.createTempFile();
     env =
         create()
             .setMapSize(MEBIBYTES.toBytes(64))
             .setMaxReaders(2)
             .setMaxDbs(2)
-            .open(path, MDB_NOSUBDIR);
-    final File pathBa = tmp.newFile();
+            .open(file.toFile(), MDB_NOSUBDIR);
+    fileBa = FileUtil.createTempFile();
     envBa =
         create(PROXY_BA)
             .setMapSize(MEBIBYTES.toBytes(64))
             .setMaxReaders(2)
             .setMaxDbs(2)
-            .open(pathBa, MDB_NOSUBDIR);
+            .open(fileBa.toFile(), MDB_NOSUBDIR);
   }
 
-  @Test(expected = ConstantDerivedException.class)
-  public void close() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
-    db.put(bb(1), bb(42));
-    db.close();
-    db.put(bb(2), bb(42)); // error
+  @AfterEach
+  void afterEach() {
+    env.close();
+    envBa.close();
+    FileUtil.delete(file);
+    FileUtil.delete(fileBa);
   }
 
   @Test
-  public void customComparator() {
+  void close() {
+    assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+              db.put(bb(1), bb(42));
+              db.close();
+              db.put(bb(2), bb(42)); // error
+            })
+        .isInstanceOf(ConstantDerivedException.class);
+  }
+
+  @Test
+  void customComparator() {
     final Comparator<ByteBuffer> reverseOrder =
         (o1, o2) -> {
           final int lexical = PROXY_OPTIMAL.getComparator().compare(o1, o2);
@@ -126,7 +129,7 @@ public void customComparator() {
   }
 
   @Test
-  public void customComparatorByteArray() {
+  void customComparatorByteArray() {
     final Comparator<byte[]> reverseOrder =
         (o1, o2) -> {
           final int lexical = PROXY_BA.getComparator().compare(o1, o2);
@@ -145,41 +148,45 @@ private <T> void doCustomComparator(
       ToIntFunction<T> deserializer) {
     final Dbi<T> db = env.openDbi(DB_1, comparator, true, MDB_CREATE);
     try (Txn<T> txn = env.txnWrite()) {
-      assertThat(db.put(txn, serializer.apply(2), serializer.apply(3)), is(true));
-      assertThat(db.put(txn, serializer.apply(4), serializer.apply(6)), is(true));
-      assertThat(db.put(txn, serializer.apply(6), serializer.apply(7)), is(true));
-      assertThat(db.put(txn, serializer.apply(8), serializer.apply(7)), is(true));
+      assertThat(db.put(txn, serializer.apply(2), serializer.apply(3))).isTrue();
+      assertThat(db.put(txn, serializer.apply(4), serializer.apply(6))).isTrue();
+      assertThat(db.put(txn, serializer.apply(6), serializer.apply(7))).isTrue();
+      assertThat(db.put(txn, serializer.apply(8), serializer.apply(7))).isTrue();
       txn.commit();
     }
     try (Txn<T> txn = env.txnRead();
         CursorIterable<T> ci = db.iterate(txn, atMost(serializer.apply(4)))) {
       final Iterator<KeyVal<T>> iter = ci.iterator();
-      assertThat(deserializer.applyAsInt(iter.next().key()), is(8));
-      assertThat(deserializer.applyAsInt(iter.next().key()), is(6));
-      assertThat(deserializer.applyAsInt(iter.next().key()), is(4));
+      assertThat(deserializer.applyAsInt(iter.next().key())).isEqualTo(8);
+      assertThat(deserializer.applyAsInt(iter.next().key())).isEqualTo(6);
+      assertThat(deserializer.applyAsInt(iter.next().key())).isEqualTo(4);
     }
   }
 
-  @Test(expected = DbFullException.class)
-  public void dbOpenMaxDatabases() {
-    env.openDbi("db1 is OK", MDB_CREATE);
-    env.openDbi("db2 is OK", MDB_CREATE);
-    env.openDbi("db3 fails", MDB_CREATE);
+  @Test
+  void dbOpenMaxDatabases() {
+    assertThatThrownBy(
+            () -> {
+              env.openDbi("db1 is OK", MDB_CREATE);
+              env.openDbi("db2 is OK", MDB_CREATE);
+              env.openDbi("db3 fails", MDB_CREATE);
+            })
+        .isInstanceOf(DbFullException.class);
   }
 
   @Test
-  public void dbiWithComparatorThreadSafety() {
+  void dbiWithComparatorThreadSafety() {
     doDbiWithComparatorThreadSafety(
         env, PROXY_OPTIMAL::getComparator, TestUtils::bb, ByteBuffer::getInt);
   }
 
   @Test
-  public void dbiWithComparatorThreadSafetyByteArray() {
+  void dbiWithComparatorThreadSafetyByteArray() {
     doDbiWithComparatorThreadSafety(
         envBa, PROXY_BA::getComparator, TestUtils::ba, TestUtils::fromBa);
   }
 
-  public <T> void doDbiWithComparatorThreadSafety(
+  private <T> void doDbiWithComparatorThreadSafety(
       Env<T> env,
       Function<DbiFlags[], Comparator<T>> comparator,
       IntFunction<T> serializer,
@@ -190,66 +197,67 @@ public <T> void doDbiWithComparatorThreadSafety(
 
     final List<Integer> keys = range(0, 1_000).boxed().collect(toList());
 
-    final ExecutorService pool = Executors.newCachedThreadPool();
-    final AtomicBoolean proceed = new AtomicBoolean(true);
-    final Future<?> reader =
-        pool.submit(
-            () -> {
-              while (proceed.get()) {
-                try (Txn<T> txn = env.txnRead()) {
-                  db.get(txn, serializer.apply(50));
+    try (final ExecutorService pool = Executors.newCachedThreadPool()) {
+      final AtomicBoolean proceed = new AtomicBoolean(true);
+      final Future<?> reader =
+          pool.submit(
+              () -> {
+                while (proceed.get()) {
+                  try (Txn<T> txn = env.txnRead()) {
+                    db.get(txn, serializer.apply(50));
+                  }
                 }
-              }
-            });
+              });
 
-    for (final Integer key : keys) {
-      try (Txn<T> txn = env.txnWrite()) {
-        db.put(txn, serializer.apply(key), serializer.apply(3));
-        txn.commit();
+      for (final Integer key : keys) {
+        try (Txn<T> txn = env.txnWrite()) {
+          db.put(txn, serializer.apply(key), serializer.apply(3));
+          txn.commit();
+        }
       }
-    }
 
-    try (Txn<T> txn = env.txnRead();
-        CursorIterable<T> ci = db.iterate(txn)) {
-      final Iterator<KeyVal<T>> iter = ci.iterator();
-      final List<Integer> result = new ArrayList<>();
-      while (iter.hasNext()) {
-        result.add(deserializer.applyAsInt(iter.next().key()));
-      }
+      try (Txn<T> txn = env.txnRead();
+          CursorIterable<T> ci = db.iterate(txn)) {
+        final Iterator<KeyVal<T>> iter = ci.iterator();
+        final List<Integer> result = new ArrayList<>();
+        while (iter.hasNext()) {
+          result.add(deserializer.applyAsInt(iter.next().key()));
+        }
 
-      assertThat(result, Matchers.contains(keys.toArray(new Integer[0])));
-    }
+        assertThat(result).contains(keys.toArray(new Integer[0]));
+      }
 
-    proceed.set(false);
-    try {
-      reader.get(1, SECONDS);
-      pool.shutdown();
-      pool.awaitTermination(1, SECONDS);
-    } catch (ExecutionException | InterruptedException | TimeoutException e) {
-      throw new IllegalStateException(e);
+      proceed.set(false);
+      try {
+        reader.get(1, SECONDS);
+        pool.shutdown();
+        pool.awaitTermination(1, SECONDS);
+      } catch (ExecutionException | InterruptedException | TimeoutException e) {
+        throw new IllegalStateException(e);
+      }
     }
   }
 
   @Test
-  public void drop() {
+  void drop() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       db.put(txn, bb(1), bb(42));
       db.put(txn, bb(2), bb(42));
-      assertThat(db.get(txn, bb(1)), not(nullValue()));
-      assertThat(db.get(txn, bb(2)), not(nullValue()));
+      assertThat(db.get(txn, bb(1))).isNotNull();
+      assertThat(db.get(txn, bb(2))).isNotNull();
       db.drop(txn);
-      assertThat(db.get(txn, bb(1)), is(nullValue())); // data gone
-      assertThat(db.get(txn, bb(2)), is(nullValue()));
+      assertThat(db.get(txn, bb(1))).isNull(); // data gone
+      assertThat(db.get(txn, bb(2))).isNull();
       db.put(txn, bb(1), bb(42)); // ensure DB still works
       db.put(txn, bb(2), bb(42));
-      assertThat(db.get(txn, bb(1)), not(nullValue()));
-      assertThat(db.get(txn, bb(2)), not(nullValue()));
+      assertThat(db.get(txn, bb(1))).isNotNull();
+      assertThat(db.get(txn, bb(2))).isNotNull();
     }
   }
 
   @Test
-  public void dropAndDelete() {
+  void dropAndDelete() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
     final Dbi<ByteBuffer> nameDb = env.openDbi((byte[]) null);
     final byte[] dbNameBytes = DB_1.getBytes(UTF_8);
@@ -257,15 +265,15 @@ public void dropAndDelete() {
     dbNameBuffer.put(dbNameBytes).flip();
 
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      assertThat(nameDb.get(txn, dbNameBuffer), not(nullValue()));
+      assertThat(nameDb.get(txn, dbNameBuffer)).isNotNull();
       db.drop(txn, true);
-      assertThat(nameDb.get(txn, dbNameBuffer), is(nullValue()));
+      assertThat(nameDb.get(txn, dbNameBuffer)).isNull();
       txn.commit();
     }
   }
 
   @Test
-  public void dropAndDeleteAnonymousDb() {
+  void dropAndDeleteAnonymousDb() {
     env.openDbi(DB_1, MDB_CREATE);
     final Dbi<ByteBuffer> nameDb = env.openDbi((byte[]) null);
     final byte[] dbNameBytes = DB_1.getBytes(UTF_8);
@@ -273,9 +281,9 @@ public void dropAndDeleteAnonymousDb() {
     dbNameBuffer.put(dbNameBytes).flip();
 
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      assertThat(nameDb.get(txn, dbNameBuffer), not(nullValue()));
+      assertThat(nameDb.get(txn, dbNameBuffer)).isNotNull();
       nameDb.drop(txn, true);
-      assertThat(nameDb.get(txn, dbNameBuffer), is(nullValue()));
+      assertThat(nameDb.get(txn, dbNameBuffer)).isNull();
       txn.commit();
     }
 
@@ -283,41 +291,41 @@ public void dropAndDeleteAnonymousDb() {
   }
 
   @Test
-  public void getName() {
+  void getName() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
-    assertThat(db.getName(), is(DB_1.getBytes(UTF_8)));
+    assertThat(db.getName()).isEqualTo(DB_1.getBytes(UTF_8));
   }
 
   @Test
-  public void getNamesWhenDbisPresent() {
+  void getNamesWhenDbisPresent() {
     final byte[] dbHello = new byte[] {'h', 'e', 'l', 'l', 'o'};
     final byte[] dbWorld = new byte[] {'w', 'o', 'r', 'l', 'd'};
     env.openDbi(dbHello, MDB_CREATE);
     env.openDbi(dbWorld, MDB_CREATE);
     final List<byte[]> dbiNames = env.getDbiNames();
-    assertThat(dbiNames, hasSize(2));
-    assertThat(dbiNames.get(0), is(dbHello));
-    assertThat(dbiNames.get(1), is(dbWorld));
+    assertThat(dbiNames).hasSize(2);
+    assertThat(dbiNames.get(0)).isEqualTo(dbHello);
+    assertThat(dbiNames.get(1)).isEqualTo(dbWorld);
   }
 
   @Test
-  public void getNamesWhenEmpty() {
+  void getNamesWhenEmpty() {
     final List<byte[]> dbiNames = env.getDbiNames();
-    assertThat(dbiNames, empty());
+    assertThat(dbiNames).isEmpty();
   }
 
   @Test
-  public void listsFlags() {
+  void listsFlags() {
     final Dbi<ByteBuffer> dbi = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT, MDB_REVERSEKEY);
 
     try (Txn<ByteBuffer> txn = env.txnRead()) {
       final List<DbiFlags> flags = dbi.listFlags(txn);
-      assertThat(flags, containsInAnyOrder(MDB_DUPSORT, MDB_REVERSEKEY));
+      assertThat(flags).containsExactlyInAnyOrder(MDB_DUPSORT, MDB_REVERSEKEY);
     }
   }
 
   @Test
-  public void putAbortGet() {
+  void putAbortGet() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
 
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
@@ -326,30 +334,30 @@ public void putAbortGet() {
     }
 
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      assertNull(db.get(txn, bb(5)));
+      assertThat(db.get(txn, bb(5))).isNull();
     }
   }
 
   @Test
-  public void putAndGetAndDeleteWithInternalTx() {
+  void putAndGetAndDeleteWithInternalTx() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
 
     db.put(bb(5), bb(5));
     try (Txn<ByteBuffer> txn = env.txnRead()) {
       final ByteBuffer found = db.get(txn, bb(5));
-      assertNotNull(found);
-      assertThat(txn.val().getInt(), is(5));
+      assertThat(found).isNotNull();
+      assertThat(txn.val().getInt()).isEqualTo(5);
     }
-    assertThat(db.delete(bb(5)), is(true));
-    assertThat(db.delete(bb(5)), is(false));
+    assertThat(db.delete(bb(5))).isTrue();
+    assertThat(db.delete(bb(5))).isFalse();
 
     try (Txn<ByteBuffer> txn = env.txnRead()) {
-      assertNull(db.get(txn, bb(5)));
+      assertThat(db.get(txn, bb(5))).isNull();
     }
   }
 
   @Test
-  public void putCommitGet() {
+  void putCommitGet() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       db.put(txn, bb(5), bb(5));
@@ -358,90 +366,93 @@ public void putCommitGet() {
 
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       final ByteBuffer found = db.get(txn, bb(5));
-      assertNotNull(found);
-      assertThat(txn.val().getInt(), is(5));
+      assertThat(found).isNotNull();
+      assertThat(txn.val().getInt()).isEqualTo(5);
     }
   }
 
   @Test
-  public void putCommitGetByteArray() throws IOException {
-    final File path = tmp.newFile();
-    try (Env<byte[]> envBa =
-        create(PROXY_BA)
-            .setMapSize(MEBIBYTES.toBytes(64))
-            .setMaxReaders(1)
-            .setMaxDbs(2)
-            .open(path, MDB_NOSUBDIR)) {
-      final Dbi<byte[]> db = envBa.openDbi(DB_1, MDB_CREATE);
-      try (Txn<byte[]> txn = envBa.txnWrite()) {
-        db.put(txn, ba(5), ba(5));
-        txn.commit();
-      }
-      try (Txn<byte[]> txn = envBa.txnWrite()) {
-        final byte[] found = db.get(txn, ba(5));
-        assertNotNull(found);
-        assertThat(fromBa(txn.val()), is(5));
-      }
-    }
+  void putCommitGetByteArray() {
+    FileUtil.useTempFile(
+        file -> {
+          try (Env<byte[]> envBa =
+              create(PROXY_BA)
+                  .setMapSize(MEBIBYTES.toBytes(64))
+                  .setMaxReaders(1)
+                  .setMaxDbs(2)
+                  .open(file.toFile(), MDB_NOSUBDIR)) {
+            final Dbi<byte[]> db = envBa.openDbi(DB_1, MDB_CREATE);
+            try (Txn<byte[]> txn = envBa.txnWrite()) {
+              db.put(txn, ba(5), ba(5));
+              txn.commit();
+            }
+            try (Txn<byte[]> txn = envBa.txnWrite()) {
+              final byte[] found = db.get(txn, ba(5));
+              assertThat(found).isNotNull();
+              assertThat(fromBa(txn.val())).isEqualTo(5);
+            }
+          }
+        });
   }
 
   @Test
-  public void putDelete() {
+  void putDelete() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
 
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       db.put(txn, bb(5), bb(5));
-      assertThat(db.delete(txn, bb(5)), is(true));
+      assertThat(db.delete(txn, bb(5))).isTrue();
 
-      assertNull(db.get(txn, bb(5)));
+      assertThat(db.get(txn, bb(5))).isNull();
       txn.abort();
     }
   }
 
   @Test
-  public void putDuplicateDelete() {
+  void putDuplicateDelete() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
 
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       db.put(txn, bb(5), bb(5));
       db.put(txn, bb(5), bb(6));
       db.put(txn, bb(5), bb(7));
-      assertThat(db.delete(txn, bb(5), bb(6)), is(true));
-      assertThat(db.delete(txn, bb(5), bb(6)), is(false));
-      assertThat(db.delete(txn, bb(5), bb(5)), is(true));
-      assertThat(db.delete(txn, bb(5), bb(5)), is(false));
+      assertThat(db.delete(txn, bb(5), bb(6))).isTrue();
+      assertThat(db.delete(txn, bb(5), bb(6))).isFalse();
+      assertThat(db.delete(txn, bb(5), bb(5))).isTrue();
+      assertThat(db.delete(txn, bb(5), bb(5))).isFalse();
 
       try (Cursor<ByteBuffer> cursor = db.openCursor(txn)) {
         final ByteBuffer key = bb(5);
         cursor.get(key, MDB_SET_KEY);
-        assertThat(cursor.count(), is(1L));
+        assertThat(cursor.count()).isEqualTo(1L);
       }
       txn.abort();
     }
   }
 
   @Test
-  public void putReserve() {
+  void putReserve() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
 
     final ByteBuffer key = bb(5);
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      assertNull(db.get(txn, key));
+      assertThat(db.get(txn, key)).isNull();
       final ByteBuffer val = db.reserve(txn, key, 32, MDB_NOOVERWRITE);
       val.putLong(MAX_VALUE);
-      assertNotNull(db.get(txn, key));
+      assertThat(db.get(txn, key)).isNotNull();
       txn.commit();
     }
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       final ByteBuffer val = db.get(txn, key);
-      assertThat(val.capacity(), is(32));
-      assertThat(val.getLong(), is(MAX_VALUE));
-      assertThat(val.getLong(8), is(0L));
+      assertThat(val).isNotNull();
+      assertThat(val.capacity()).isEqualTo(32);
+      assertThat(val.getLong()).isEqualTo(MAX_VALUE);
+      assertThat(val.getLong(8)).isEqualTo(0L);
     }
   }
 
   @Test
-  public void putZeroByteValueForNonMdbDupSortDatabase() {
+  void putZeroByteValueForNonMdbDupSortDatabase() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       final ByteBuffer val = allocateDirect(0);
@@ -451,36 +462,36 @@ public void putZeroByteValueForNonMdbDupSortDatabase() {
 
     try (Txn<ByteBuffer> txn = env.txnRead()) {
       final ByteBuffer found = db.get(txn, bb(5));
-      assertNotNull(found);
-      assertThat(txn.val().capacity(), is(0));
+      assertThat(found).isNotNull();
+      assertThat(txn.val().capacity()).isEqualTo(0);
     }
   }
 
   @Test
-  public void returnValueForNoDupData() {
+  void returnValueForNoDupData() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       // ok
-      assertThat(db.put(txn, bb(5), bb(6), MDB_NODUPDATA), is(true));
-      assertThat(db.put(txn, bb(5), bb(7), MDB_NODUPDATA), is(true));
-      assertThat(db.put(txn, bb(5), bb(6), MDB_NODUPDATA), is(false));
+      assertThat(db.put(txn, bb(5), bb(6), MDB_NODUPDATA)).isTrue();
+      assertThat(db.put(txn, bb(5), bb(7), MDB_NODUPDATA)).isTrue();
+      assertThat(db.put(txn, bb(5), bb(6), MDB_NODUPDATA)).isFalse();
     }
   }
 
   @Test
-  public void returnValueForNoOverwrite() {
+  void returnValueForNoOverwrite() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       // ok
-      assertThat(db.put(txn, bb(5), bb(6), MDB_NOOVERWRITE), is(true));
+      assertThat(db.put(txn, bb(5), bb(6), MDB_NOOVERWRITE)).isTrue();
       // fails, but gets exist val
-      assertThat(db.put(txn, bb(5), bb(8), MDB_NOOVERWRITE), is(false));
-      assertThat(txn.val().getInt(0), is(6));
+      assertThat(db.put(txn, bb(5), bb(8), MDB_NOOVERWRITE)).isFalse();
+      assertThat(txn.val().getInt(0)).isEqualTo(6);
     }
   }
 
   @Test
-  public void stats() {
+  void stats() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
     db.put(bb(1), bb(42));
     db.put(bb(2), bb(42));
@@ -489,32 +500,36 @@ public void stats() {
     try (Txn<ByteBuffer> txn = env.txnRead()) {
       stat = db.stat(txn);
     }
-    assertThat(stat, is(notNullValue()));
-    assertThat(stat.branchPages, is(0L));
-    assertThat(stat.depth, is(1));
-    assertThat(stat.entries, is(3L));
-    assertThat(stat.leafPages, is(1L));
-    assertThat(stat.overflowPages, is(0L));
-    assertThat(stat.pageSize % 4_096, is(0));
+    assertThat(stat).isNotNull();
+    assertThat(stat.branchPages).isEqualTo(0L);
+    assertThat(stat.depth).isEqualTo(1);
+    assertThat(stat.entries).isEqualTo(3L);
+    assertThat(stat.leafPages).isEqualTo(1L);
+    assertThat(stat.overflowPages).isEqualTo(0L);
+    assertThat(stat.pageSize % 4_096).isEqualTo(0);
   }
 
-  @Test(expected = MapFullException.class)
-  public void testMapFullException() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
-    try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      final ByteBuffer v;
-      try {
-        v = allocateDirect(1_024 * 1_024 * 1_024);
-      } catch (final OutOfMemoryError e) {
-        // Travis CI OS X build cannot allocate this much memory, so assume OK
-        throw new MapFullException();
-      }
-      db.put(txn, bb(1), v);
-    }
+  @Test
+  void testMapFullException() {
+    assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+              try (Txn<ByteBuffer> txn = env.txnWrite()) {
+                final ByteBuffer v;
+                try {
+                  v = allocateDirect(1_024 * 1_024 * 1_024);
+                } catch (final OutOfMemoryError e) {
+                  // Travis CI OS X build cannot allocate this much memory, so assume OK
+                  throw new MapFullException();
+                }
+                db.put(txn, bb(1), v);
+              }
+            })
+        .isInstanceOf(MapFullException.class);
   }
 
   @Test
-  public void testParallelWritesStress() {
+  void testParallelWritesStress() {
     if (getProperty("os.name").startsWith("Windows")) {
       return; // Windows VMs run this test too slowly
     }
@@ -531,69 +546,113 @@ public void testParallelWritesStress() {
             });
   }
 
-  @Test(expected = AlreadyClosedException.class)
-  public void closedEnvRejectsOpenCall() {
-    env.close();
-    env.openDbi(DB_1, MDB_CREATE);
+  @Test
+  void closedEnvRejectsOpenCall() {
+    assertThatThrownBy(
+            () -> {
+              env.close();
+              env.openDbi(DB_1, MDB_CREATE);
+            })
+        .isInstanceOf(AlreadyClosedException.class);
   }
 
-  @Test(expected = AlreadyClosedException.class)
-  public void closedEnvRejectsCloseCall() {
-    doEnvClosedTest(null, (db, txn) -> db.close());
+  @Test
+  void closedEnvRejectsCloseCall() {
+    assertThatThrownBy(
+            () -> {
+              doEnvClosedTest(null, (db, txn) -> db.close());
+            })
+        .isInstanceOf(AlreadyClosedException.class);
   }
 
-  @Test(expected = AlreadyClosedException.class)
-  public void closedEnvRejectsGetCall() {
-    doEnvClosedTest(
-        (db, txn) -> {
-          final ByteBuffer valBuf = db.get(txn, bb(1));
-          assertThat(valBuf.getInt(), is(10));
-        },
-        (db, txn) -> db.get(txn, bb(2)));
+  @Test
+  void closedEnvRejectsGetCall() {
+    assertThatThrownBy(
+            () -> {
+              doEnvClosedTest(
+                  (db, txn) -> {
+                    final ByteBuffer valBuf = db.get(txn, bb(1));
+                    assertThat(valBuf.getInt()).isEqualTo(10);
+                  },
+                  (db, txn) -> db.get(txn, bb(2)));
+            })
+        .isInstanceOf(AlreadyClosedException.class);
   }
 
-  @Test(expected = AlreadyClosedException.class)
-  public void closedEnvRejectsPutCall() {
-    doEnvClosedTest(null, (db, txn) -> db.put(bb(5), bb(50)));
+  @Test
+  void closedEnvRejectsPutCall() {
+    assertThatThrownBy(
+            () -> {
+              doEnvClosedTest(null, (db, txn) -> db.put(bb(5), bb(50)));
+            })
+        .isInstanceOf(AlreadyClosedException.class);
   }
 
-  @Test(expected = AlreadyClosedException.class)
-  public void closedEnvRejectsPutWithTxnCall() {
-    doEnvClosedTest(
-        null,
-        (db, txn) -> {
-          db.put(txn, bb(5), bb(50));
-        });
+  @Test
+  void closedEnvRejectsPutWithTxnCall() {
+    assertThatThrownBy(
+            () -> {
+              doEnvClosedTest(
+                  null,
+                  (db, txn) -> {
+                    db.put(txn, bb(5), bb(50));
+                  });
+            })
+        .isInstanceOf(AlreadyClosedException.class);
   }
 
-  @Test(expected = AlreadyClosedException.class)
-  public void closedEnvRejectsIterateCall() {
-    doEnvClosedTest(null, Dbi::iterate);
+  @Test
+  void closedEnvRejectsIterateCall() {
+    assertThatThrownBy(
+            () -> {
+              doEnvClosedTest(null, Dbi::iterate);
+            })
+        .isInstanceOf(AlreadyClosedException.class);
   }
 
-  @Test(expected = AlreadyClosedException.class)
-  public void closedEnvRejectsDropCall() {
-    doEnvClosedTest(null, Dbi::drop);
+  @Test
+  void closedEnvRejectsDropCall() {
+    assertThatThrownBy(
+            () -> {
+              doEnvClosedTest(null, Dbi::drop);
+            })
+        .isInstanceOf(AlreadyClosedException.class);
   }
 
-  @Test(expected = AlreadyClosedException.class)
-  public void closedEnvRejectsDropAndDeleteCall() {
-    doEnvClosedTest(null, (db, txn) -> db.drop(txn, true));
+  @Test
+  void closedEnvRejectsDropAndDeleteCall() {
+    assertThatThrownBy(
+            () -> {
+              doEnvClosedTest(null, (db, txn) -> db.drop(txn, true));
+            })
+        .isInstanceOf(AlreadyClosedException.class);
   }
 
-  @Test(expected = AlreadyClosedException.class)
-  public void closedEnvRejectsOpenCursorCall() {
-    doEnvClosedTest(null, Dbi::openCursor);
+  @Test
+  void closedEnvRejectsOpenCursorCall() {
+    assertThatThrownBy(
+            () -> {
+              doEnvClosedTest(null, Dbi::openCursor);
+            })
+        .isInstanceOf(AlreadyClosedException.class);
   }
 
-  @Test(expected = AlreadyClosedException.class)
-  public void closedEnvRejectsReserveCall() {
-    doEnvClosedTest(null, (db, txn) -> db.reserve(txn, bb(1), 32, MDB_NOOVERWRITE));
+  @Test
+  void closedEnvRejectsReserveCall() {
+    assertThatThrownBy(
+            () -> {
+              doEnvClosedTest(null, (db, txn) -> db.reserve(txn, bb(1), 32, MDB_NOOVERWRITE));
+            })
+        .isInstanceOf(AlreadyClosedException.class);
   }
 
-  @Test(expected = AlreadyClosedException.class)
-  public void closedEnvRejectsStatCall() {
-    doEnvClosedTest(null, Dbi::stat);
+  @Test
+  void closedEnvRejectsStatCall() {
+    assertThatThrownBy(
+            () -> {
+              doEnvClosedTest(null, Dbi::stat);
+            })
+        .isInstanceOf(AlreadyClosedException.class);
   }
 
   private void doEnvClosedTest(
diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index e71c6ae9..87edd049 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -13,16 +13,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package org.lmdbjava;
 
 import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
 import static com.jakewharton.byteunits.BinaryByteUnit.MEBIBYTES;
 import static java.nio.ByteBuffer.allocateDirect;
-import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.CoreMatchers.notNullValue;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.greaterThan;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.lmdbjava.CopyFlags.MDB_CP_COMPACT;
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
 import static org.lmdbjava.Env.Builder.MAX_READERS_DEFAULT;
@@ -33,13 +31,13 @@
 import static org.lmdbjava.TestUtils.DB_1;
 import static org.lmdbjava.TestUtils.bb;
 
-import java.io.File;
 import java.io.IOException;
+import java.io.UncheckedIOException;
 import java.nio.ByteBuffer;
+import java.nio.file.Files;
+import java.nio.file.Path;
 import java.util.Random;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
+import org.junit.jupiter.api.Test;
 import org.lmdbjava.Env.AlreadyClosedException;
 import org.lmdbjava.Env.AlreadyOpenException;
 import org.lmdbjava.Env.Builder;
@@ -50,306 +48,453 @@
 /** Test {@link Env}. */
 public final class EnvTest {
 
-  @Rule public final TemporaryFolder tmp = new TemporaryFolder();
-
   @Test
-  public void byteUnit() throws IOException {
-    final File path = tmp.newFile();
-    try (Env<ByteBuffer> env =
-        create().setMaxReaders(1).setMapSize(MEBIBYTES.toBytes(1)).open(path, MDB_NOSUBDIR)) {
-      final EnvInfo info = env.info();
-      assertThat(info.mapSize, is(MEBIBYTES.toBytes(1)));
-    }
+  void byteUnit() {
+    FileUtil.useTempFile(
+        file -> {
+          try (Env<ByteBuffer> env =
+              create()
+                  .setMaxReaders(1)
+                  .setMapSize(MEBIBYTES.toBytes(1))
+                  .open(file.toFile(), MDB_NOSUBDIR)) {
+            final EnvInfo info = env.info();
+            assertThat(info.mapSize).isEqualTo(MEBIBYTES.toBytes(1));
+          }
+        });
   }
 
-  @Test(expected = AlreadyOpenException.class)
-  public void cannotChangeMapSizeAfterOpen() throws IOException {
-    final File path = tmp.newFile();
-    final Builder<ByteBuffer> builder = create().setMaxReaders(1);
-    try (Env<ByteBuffer> env = builder.open(path, MDB_NOSUBDIR)) {
-      builder.setMapSize(1);
-    }
+  @Test
+  void cannotChangeMapSizeAfterOpen() {
+    assertThatThrownBy(
+            () -> {
+              FileUtil.useTempFile(
+                  file -> {
+                    final Builder<ByteBuffer> builder = create().setMaxReaders(1);
+                    try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
+                      builder.setMapSize(1);
+                    }
+                  });
+            })
+        .isInstanceOf(AlreadyOpenException.class);
   }
 
-  @Test(expected = AlreadyOpenException.class)
-  public void cannotChangeMaxDbsAfterOpen() throws IOException {
-    final File path = tmp.newFile();
-    final Builder<ByteBuffer> builder = create().setMaxReaders(1);
-    try (Env<ByteBuffer> env = builder.open(path, MDB_NOSUBDIR)) {
-      builder.setMaxDbs(1);
-    }
+  @Test
+  void cannotChangeMaxDbsAfterOpen() {
+    assertThatThrownBy(
+            () -> {
+              FileUtil.useTempFile(
+                  file -> {
+                    final Builder<ByteBuffer> builder = create().setMaxReaders(1);
+                    try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
+                      builder.setMaxDbs(1);
+                    }
+                  });
+            })
+        .isInstanceOf(AlreadyOpenException.class);
   }
 
-  @Test(expected = AlreadyOpenException.class)
-  public void cannotChangeMaxReadersAfterOpen() throws IOException {
-    final File path = tmp.newFile();
-    final Builder<ByteBuffer> builder = create().setMaxReaders(1);
-    try (Env<ByteBuffer> env = builder.open(path, MDB_NOSUBDIR)) {
-      builder.setMaxReaders(1);
-    }
+  @Test
+  void cannotChangeMaxReadersAfterOpen() {
+    assertThatThrownBy(
+            () -> {
+              FileUtil.useTempFile(
+                  file -> {
+                    final Builder<ByteBuffer> builder = create().setMaxReaders(1);
+                    try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
+                      builder.setMaxReaders(1);
+                    }
+                  });
+            })
+        .isInstanceOf(AlreadyOpenException.class);
   }
 
-  @Test(expected = AlreadyClosedException.class)
-  public void cannotInfoOnceClosed() throws IOException {
-    final File path = tmp.newFile();
-    final Env<ByteBuffer> env = create().setMaxReaders(1).open(path, MDB_NOSUBDIR);
-    env.close();
-    env.info();
+  @Test
+  void cannotInfoOnceClosed() {
+    assertThatThrownBy(
+            () -> {
+              FileUtil.useTempFile(
+                  file -> {
+                    final Env<ByteBuffer> env =
+                        create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
+                    env.close();
+                    env.info();
+                  });
+            })
+        .isInstanceOf(AlreadyClosedException.class);
   }
 
-  @Test(expected = AlreadyOpenException.class)
-  public void cannotOpenTwice() throws IOException {
-    final File path = tmp.newFile();
-    final Builder<ByteBuffer> builder = create().setMaxReaders(1);
-
-    builder.open(path, MDB_NOSUBDIR).close();
-    builder.open(path, MDB_NOSUBDIR);
+  @Test
+  void cannotOpenTwice() {
+    assertThatThrownBy(
+            () -> {
+              FileUtil.useTempFile(
+                  file -> {
+                    final Builder<ByteBuffer> builder = create().setMaxReaders(1);
+                    builder.open(file.toFile(), MDB_NOSUBDIR).close();
+                    builder.open(file.toFile(), MDB_NOSUBDIR);
+                  });
+            })
+        .isInstanceOf(AlreadyOpenException.class);
   }
 
-  @Test(expected = IllegalArgumentException.class)
-  public void cannotOverflowMapSize() {
-    final Builder<ByteBuffer> builder = create().setMaxReaders(1);
-    final int mb = 1_024 * 1_024;
-    final int size = mb * 2_048; // as per issue 18
-    builder.setMapSize(size);
+  @Test
+  void cannotOverflowMapSize() {
+    assertThatThrownBy(
+            () -> {
+              final Builder<ByteBuffer> builder = create().setMaxReaders(1);
+              final int mb = 1_024 * 1_024;
+              final int size = mb * 2_048; // as per issue 18
+              builder.setMapSize(size);
+            })
+        .isInstanceOf(IllegalArgumentException.class);
   }
 
-  @Test(expected = AlreadyClosedException.class)
-  public void cannotStatOnceClosed() throws IOException {
-    final File path = tmp.newFile();
-    final Env<ByteBuffer> env = create().setMaxReaders(1).open(path, MDB_NOSUBDIR);
-    env.close();
-    env.stat();
+  @Test
+  void cannotStatOnceClosed() {
+    assertThatThrownBy(
+            () -> {
+              FileUtil.useTempFile(
+                  file -> {
+                    final Env<ByteBuffer> env =
+                        create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
+                    env.close();
+                    env.stat();
+                  });
+            })
+        .isInstanceOf(AlreadyClosedException.class);
   }
 
-  @Test(expected = AlreadyClosedException.class)
-  public void cannotSyncOnceClosed() throws IOException {
-    final File path = tmp.newFile();
-    final Env<ByteBuffer> env = create().setMaxReaders(1).open(path, MDB_NOSUBDIR);
-    env.close();
-    env.sync(false);
+  @Test
+  void cannotSyncOnceClosed() {
+    assertThatThrownBy(
+            () -> {
+              FileUtil.useTempFile(
+                  file -> {
+                    final Env<ByteBuffer> env =
+                        create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
+                    env.close();
+                    env.sync(false);
+                  });
+            })
+        .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
-  public void copyDirectoryBased() throws IOException {
-    final File dest = tmp.newFolder();
-    assertThat(dest.exists(), is(true));
-    assertThat(dest.isDirectory(), is(true));
-    assertThat(dest.list().length, is(0));
-    final File src = tmp.newFolder();
-    try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src)) {
-      env.copy(dest, MDB_CP_COMPACT);
-      assertThat(dest.list().length, is(1));
-    }
+  void copyDirectoryBased() {
+    FileUtil.useTempDir(
+        dest -> {
+          assertThat(Files.exists(dest)).isTrue();
+          assertThat(Files.isDirectory(dest)).isTrue();
+          assertThat(FileUtil.count(dest)).isEqualTo(0);
+          FileUtil.useTempDir(
+              src -> {
+                try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src.toFile())) {
+                  env.copy(dest.toFile(), MDB_CP_COMPACT);
+                  assertThat(FileUtil.count(dest)).isEqualTo(1);
+                }
+              });
+        });
   }
 
-  @Test(expected = InvalidCopyDestination.class)
-  public void copyDirectoryRejectsFileDestination() throws IOException {
-    final File dest = tmp.newFile();
-    final File src = tmp.newFolder();
-    try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src)) {
-      env.copy(dest, MDB_CP_COMPACT);
-    }
+  @Test
+  void copyDirectoryRejectsFileDestination() {
+    assertThatThrownBy(
+            () -> {
+              FileUtil.useTempDir(
+                  dest -> {
+                    FileUtil.deleteDir(dest);
+                    FileUtil.useTempDir(
+                        src -> {
+                          try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src.toFile())) {
+                            env.copy(dest.toFile(), MDB_CP_COMPACT);
+                          }
+                        });
+                  });
+            })
+        .isInstanceOf(InvalidCopyDestination.class);
   }
 
-  @Test(expected = InvalidCopyDestination.class)
-  public void copyDirectoryRejectsMissingDestination() throws IOException {
-    final File dest = tmp.newFolder();
-    assertThat(dest.delete(), is(true));
-    final File src = tmp.newFolder();
-    try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src)) {
-      env.copy(dest, MDB_CP_COMPACT);
-    }
+  @Test
+  void copyDirectoryRejectsMissingDestination() {
+    assertThatThrownBy(
+            () -> {
+              FileUtil.useTempDir(
+                  dest -> {
+                    try {
+                      Files.delete(dest);
+                      FileUtil.useTempDir(
+                          src -> {
+                            try (Env<ByteBuffer> env =
+                                create().setMaxReaders(1).open(src.toFile())) {
+                              env.copy(dest.toFile(), MDB_CP_COMPACT);
+                            }
+                          });
+                    } catch (final IOException e) {
+                      throw new UncheckedIOException(e);
+                    }
+                  });
+            })
+        .isInstanceOf(InvalidCopyDestination.class);
   }
 
-  @Test(expected = InvalidCopyDestination.class)
-  public void copyDirectoryRejectsNonEmptyDestination() throws IOException {
-    final File dest = tmp.newFolder();
-    final File subDir = new File(dest, "hello");
-    assertThat(subDir.mkdir(), is(true));
-    final File src = tmp.newFolder();
-    try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src)) {
-      env.copy(dest, MDB_CP_COMPACT);
-    }
+  @Test
+  void copyDirectoryRejectsNonEmptyDestination() {
+    assertThatThrownBy(
+            () -> {
+              FileUtil.useTempDir(
+                  dest -> {
+                    try {
+                      final Path subDir = dest.resolve("hello");
+                      Files.createDirectory(subDir);
+                      assertThat(Files.isDirectory(subDir)).isTrue();
+                      FileUtil.useTempDir(
+                          src -> {
+                            try (Env<ByteBuffer> env =
+                                create().setMaxReaders(1).open(src.toFile())) {
+                              env.copy(dest.toFile(), MDB_CP_COMPACT);
+                            }
+                          });
+                    } catch (final IOException e) {
+                      throw new UncheckedIOException(e);
+                    }
+                  });
+            })
+        .isInstanceOf(InvalidCopyDestination.class);
   }
 
   @Test
-  public void copyFileBased() throws IOException {
-    final File dest = tmp.newFile();
-    assertThat(dest.delete(), is(true));
-    assertThat(dest.exists(), is(false));
-    final File src = tmp.newFile();
-    try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src, MDB_NOSUBDIR)) {
-      env.copy(dest, MDB_CP_COMPACT);
-    }
-    assertThat(dest.length(), greaterThan(0L));
+  void copyFileBased() {
+    FileUtil.useTempFile(
+        dest -> {
+          FileUtil.delete(dest);
+          assertThat(Files.exists(dest)).isFalse();
+          FileUtil.useTempFile(
+              src -> {
+                try (Env<ByteBuffer> env =
+                    create().setMaxReaders(1).open(src.toFile(), MDB_NOSUBDIR)) {
+                  env.copy(dest.toFile(), MDB_CP_COMPACT);
+                }
+                assertThat(FileUtil.size(dest)).isGreaterThan(0L);
+              });
+        });
   }
 
-  @Test(expected = InvalidCopyDestination.class)
-  public void copyFileRejectsExistingDestination() throws IOException {
-    final File dest = tmp.newFile();
-    assertThat(dest.exists(), is(true));
-    final File src = tmp.newFile();
-    try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src, MDB_NOSUBDIR)) {
-      env.copy(dest, MDB_CP_COMPACT);
-    }
+  @Test
+  void copyFileRejectsExistingDestination() {
+    assertThatThrownBy(
+            () -> {
+              FileUtil.useTempFile(
+                  dest -> {
+                    assertThat(Files.exists(dest)).isTrue();
+                    FileUtil.useTempFile(
+                        src -> {
+                          try (Env<ByteBuffer> env =
+                              create().setMaxReaders(1).open(src.toFile(), MDB_NOSUBDIR)) {
+                            env.copy(dest.toFile(), MDB_CP_COMPACT);
+                          }
+                        });
+                  });
+            })
+        .isInstanceOf(InvalidCopyDestination.class);
   }
 
   @Test
-  public void createAsDirectory() throws IOException {
-    final File path = tmp.newFolder();
-    final Env<ByteBuffer> env = create().setMaxReaders(1).open(path);
-    assertThat(path.isDirectory(), is(true));
-    env.sync(false);
-    env.close();
-    assertThat(env.isClosed(), is(true));
-    env.close(); // safe to repeat
+  void createAsDirectory() {
+    FileUtil.useTempDir(
+        dest -> {
+          final Env<ByteBuffer> env = create().setMaxReaders(1).open(dest.toFile());
+          assertThat(Files.isDirectory(dest)).isTrue();
+          env.sync(false);
+          env.close();
+          assertThat(env.isClosed()).isTrue();
+          env.close(); // safe to repeat
+        });
   }
 
   @Test
-  public void createAsFile() throws IOException {
-    final File path = tmp.newFile();
-    try (Env<ByteBuffer> env =
-        create().setMapSize(1_024 * 1_024).setMaxDbs(1).setMaxReaders(1).open(path, MDB_NOSUBDIR)) {
-      env.sync(true);
-      assertThat(path.isFile(), is(true));
-    }
+  void createAsFile() {
+    FileUtil.useTempFile(
+        file -> {
+          try (Env<ByteBuffer> env =
+              create()
+                  .setMapSize(MEBIBYTES.toBytes(1))
+                  .setMaxDbs(1)
+                  .setMaxReaders(1)
+                  .open(file.toFile(), MDB_NOSUBDIR)) {
+            env.sync(true);
+            assertThat(Files.isRegularFile(file)).isTrue();
+          }
+        });
   }
 
-  @Test(expected = BadReaderLockException.class)
-  public void detectTransactionThreadViolation() throws IOException {
-    final File path = tmp.newFile();
-    try (Env<ByteBuffer> env = create().setMaxReaders(1).open(path, MDB_NOSUBDIR)) {
-      env.txnRead();
-      env.txnRead();
-    }
+  @Test
+  void detectTransactionThreadViolation() {
+    assertThatThrownBy(
+            () -> {
+              FileUtil.useTempFile(
+                  file -> {
+                    try (Env<ByteBuffer> env =
+                        create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR)) {
+                      env.txnRead();
+                      env.txnRead();
+                    }
+                  });
+            })
+        .isInstanceOf(BadReaderLockException.class);
   }
 
   @Test
-  public void info() throws IOException {
-    final File path = tmp.newFile();
-    try (Env<ByteBuffer> env =
-        create().setMaxReaders(4).setMapSize(123_456).open(path, MDB_NOSUBDIR)) {
-      final EnvInfo info = env.info();
-      assertThat(info, is(notNullValue()));
-      assertThat(info.lastPageNumber, is(1L));
-      assertThat(info.lastTransactionId, is(0L));
-      assertThat(info.mapAddress, is(0L));
-      assertThat(info.mapSize, is(123_456L));
-      assertThat(info.maxReaders, is(4));
-      assertThat(info.numReaders, is(0));
-      assertThat(info.toString(), containsString("maxReaders="));
-      assertThat(env.getMaxKeySize(), is(511));
-    }
+  void info() {
+    FileUtil.useTempFile(
+        file -> {
+          try (Env<ByteBuffer> env =
+              create().setMaxReaders(4).setMapSize(123_456).open(file.toFile(), MDB_NOSUBDIR)) {
+            final EnvInfo info = env.info();
+            assertThat(info).isNotNull();
+            assertThat(info.lastPageNumber).isEqualTo(1L);
+            assertThat(info.lastTransactionId).isEqualTo(0L);
+            assertThat(info.mapAddress).isEqualTo(0L);
+            assertThat(info.mapSize).isEqualTo(123_456L);
+            assertThat(info.maxReaders).isEqualTo(4);
+            assertThat(info.numReaders).isEqualTo(0);
+            assertThat(info.toString()).contains("maxReaders=");
+            assertThat(env.getMaxKeySize()).isEqualTo(511);
+          }
+        });
   }
 
-  @Test(expected = MapFullException.class)
-  public void mapFull() throws IOException {
-    final File path = tmp.newFolder();
-    final byte[] k = new byte[500];
-    final ByteBuffer key = allocateDirect(500);
-    final ByteBuffer val = allocateDirect(1_024);
-    final Random rnd = new Random();
-    try (Env<ByteBuffer> env =
-        create().setMaxReaders(1).setMapSize(MEBIBYTES.toBytes(8)).setMaxDbs(1).open(path)) {
-      final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
-      for (; ; ) {
-        rnd.nextBytes(k);
-        key.clear();
-        key.put(k).flip();
-        val.clear();
-        db.put(key, val);
-      }
-    }
+  @Test
+  void mapFull() {
+    assertThatThrownBy(
+            () -> {
+              FileUtil.useTempDir(
+                  dir -> {
+                    final byte[] k = new byte[500];
+                    final ByteBuffer key = allocateDirect(500);
+                    final ByteBuffer val = allocateDirect(1_024);
+                    final Random rnd = new Random();
+                    try (Env<ByteBuffer> env =
+                        create()
+                            .setMaxReaders(1)
+                            .setMapSize(MEBIBYTES.toBytes(8))
+                            .setMaxDbs(1)
+                            .open(dir.toFile())) {
+                      final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+                      for (; ; ) {
+                        rnd.nextBytes(k);
+                        key.clear();
+                        key.put(k).flip();
+                        val.clear();
+                        db.put(key, val);
+                      }
+                    }
+                  });
+            })
+        .isInstanceOf(MapFullException.class);
   }
 
   @Test
-  public void readOnlySupported() throws IOException {
-    final File path = tmp.newFolder();
-    try (Env<ByteBuffer> rwEnv = create().setMaxReaders(1).open(path)) {
-      final Dbi<ByteBuffer> rwDb = rwEnv.openDbi(DB_1, MDB_CREATE);
-      rwDb.put(bb(1), bb(42));
-    }
-    try (Env<ByteBuffer> roEnv = create().setMaxReaders(1).open(path, MDB_RDONLY_ENV)) {
-      final Dbi<ByteBuffer> roDb = roEnv.openDbi(DB_1);
-      try (Txn<ByteBuffer> roTxn = roEnv.txnRead()) {
-        assertThat(roDb.get(roTxn, bb(1)), notNullValue());
-      }
-    }
+  void readOnlySupported() {
+    FileUtil.useTempDir(
+        dir -> {
+          try (Env<ByteBuffer> rwEnv = create().setMaxReaders(1).open(dir.toFile())) {
+            final Dbi<ByteBuffer> rwDb = rwEnv.openDbi(DB_1, MDB_CREATE);
+            rwDb.put(bb(1), bb(42));
+          }
+          try (Env<ByteBuffer> roEnv =
+              create().setMaxReaders(1).open(dir.toFile(), MDB_RDONLY_ENV)) {
+            final Dbi<ByteBuffer> roDb = roEnv.openDbi(DB_1);
+            try (Txn<ByteBuffer> roTxn = roEnv.txnRead()) {
+              assertThat(roDb.get(roTxn, bb(1))).isNotNull();
+            }
+          }
+        });
   }
 
   @Test
-  public void setMapSize() throws IOException {
-    final File path = tmp.newFolder();
-    final byte[] k = new byte[500];
-    final ByteBuffer key = allocateDirect(500);
-    final ByteBuffer val = allocateDirect(1_024);
-    final Random rnd = new Random();
-    try (Env<ByteBuffer> env =
-        create().setMaxReaders(1).setMapSize(KIBIBYTES.toBytes(256)).setMaxDbs(1).open(path)) {
-      final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
-
-      db.put(bb(1), bb(42));
-      boolean mapFullExThrown = false;
-      try {
-        for (int i = 0; i < 70; i++) {
-          rnd.nextBytes(k);
-          key.clear();
-          key.put(k).flip();
-          val.clear();
-          db.put(key, val);
-        }
-      } catch (final MapFullException mfE) {
-        mapFullExThrown = true;
-      }
-      assertThat(mapFullExThrown, is(true));
-
-      env.setMapSize(KIBIBYTES.toBytes(1024));
-
-      try (Txn<ByteBuffer> roTxn = env.txnRead()) {
-        assertThat(db.get(roTxn, bb(1)).getInt(), is(42));
-      }
-
-      mapFullExThrown = false;
-      try {
-        for (int i = 0; i < 70; i++) {
-          rnd.nextBytes(k);
-          key.clear();
-          key.put(k).flip();
-          val.clear();
-          db.put(key, val);
-        }
-      } catch (final MapFullException mfE) {
-        mapFullExThrown = true;
-      }
-      assertThat(mapFullExThrown, is(false));
-    }
+  void setMapSize() {
+    FileUtil.useTempDir(
+        dir -> {
+          final byte[] k = new byte[500];
+          final ByteBuffer key = allocateDirect(500);
+          final ByteBuffer val = allocateDirect(1_024);
+          final Random rnd = new Random();
+          try (Env<ByteBuffer> env =
+              create()
+                  .setMaxReaders(1)
+                  .setMapSize(KIBIBYTES.toBytes(256))
+                  .setMaxDbs(1)
+                  .open(dir.toFile())) {
+            final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+
+            db.put(bb(1), bb(42));
+            boolean mapFullExThrown = false;
+            try {
+              for (int i = 0; i < 70; i++) {
+                rnd.nextBytes(k);
+                key.clear();
+                key.put(k).flip();
+                val.clear();
+                db.put(key, val);
+              }
+            } catch (final MapFullException mfE) {
+              mapFullExThrown = true;
+            }
+            assertThat(mapFullExThrown).isTrue();
+
+            env.setMapSize(KIBIBYTES.toBytes(1024));
+
+            try (Txn<ByteBuffer> roTxn = env.txnRead()) {
+              final ByteBuffer byteBuffer = db.get(roTxn, bb(1));
+              assertThat(byteBuffer).isNotNull();
+              assertThat(byteBuffer.getInt()).isEqualTo(42);
+            }
+
+            mapFullExThrown = false;
+            try {
+              for (int i = 0; i < 70; i++) {
+                rnd.nextBytes(k);
+                key.clear();
+                key.put(k).flip();
+                val.clear();
+                db.put(key, val);
+              }
+            } catch (final MapFullException mfE) {
+              mapFullExThrown = true;
+            }
+            assertThat(mapFullExThrown).isFalse();
+          }
+        });
   }
 
   @Test
-  public void stats() throws IOException {
-    final File path = tmp.newFile();
-    try (Env<ByteBuffer> env = create().setMaxReaders(1).open(path, MDB_NOSUBDIR)) {
-      final Stat stat = env.stat();
-      assertThat(stat, is(notNullValue()));
-      assertThat(stat.branchPages, is(0L));
-      assertThat(stat.depth, is(0));
-      assertThat(stat.entries, is(0L));
-      assertThat(stat.leafPages, is(0L));
-      assertThat(stat.overflowPages, is(0L));
-      assertThat(stat.pageSize % 4_096, is(0));
-      assertThat(stat.toString(), containsString("pageSize="));
-    }
+  void stats() {
+    FileUtil.useTempFile(
+        file -> {
+          try (Env<ByteBuffer> env = create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR)) {
+            final Stat stat = env.stat();
+            assertThat(stat).isNotNull();
+            assertThat(stat.branchPages).isEqualTo(0L);
+            assertThat(stat.depth).isEqualTo(0);
+            assertThat(stat.entries).isEqualTo(0L);
+            assertThat(stat.leafPages).isEqualTo(0L);
+            assertThat(stat.overflowPages).isEqualTo(0L);
+            assertThat(stat.pageSize % 4_096).isEqualTo(0);
+            assertThat(stat.toString()).contains("pageSize=");
+          }
+        });
   }
 
   @Test
-  public void testDefaultOpen() throws IOException {
-    final File path = tmp.newFolder();
-    try (Env<ByteBuffer> env = open(path, 10)) {
-      final EnvInfo info = env.info();
-      assertThat(info.maxReaders, is(MAX_READERS_DEFAULT));
-      final Dbi<ByteBuffer> db = env.openDbi("test", MDB_CREATE);
-      db.put(allocateDirect(1), allocateDirect(1));
-    }
+  void testDefaultOpen() {
+    FileUtil.useTempDir(
+        dir -> {
+          try (Env<ByteBuffer> env = open(dir.toFile(), 10)) {
+            final EnvInfo info = env.info();
+            assertThat(info.maxReaders).isEqualTo(MAX_READERS_DEFAULT);
+            final Dbi<ByteBuffer> db = env.openDbi("test", MDB_CREATE);
+            db.put(allocateDirect(1), allocateDirect(1));
+          }
+        });
   }
 }
diff --git a/src/test/java/org/lmdbjava/FileUtil.java b/src/test/java/org/lmdbjava/FileUtil.java
new file mode 100644
index 00000000..3e459f14
--- /dev/null
+++ b/src/test/java/org/lmdbjava/FileUtil.java
@@ -0,0 +1,153 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.nio.file.FileVisitOption;
+import java.nio.file.FileVisitResult;
+import java.nio.file.FileVisitor;
+import java.nio.file.Files;
+import java.nio.file.NotDirectoryException;
+import java.nio.file.Path;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.util.EnumSet;
+import java.util.function.Consumer;
+import java.util.stream.Stream;
+
+final class FileUtil {
+
+  private FileUtil() {}
+
+  static Path createTempDir() {
+    try {
+      return Files.createTempDirectory("lmdbjava");
+    } catch (final IOException e) {
+      throw new UncheckedIOException(e);
+    }
+  }
+
+  static Path createTempFile() {
+    try {
+      return Files.createTempFile("lmdbjava", "db");
+    } catch (final IOException e) {
+      throw new UncheckedIOException(e);
+    }
+  }
+
+  static void useTempDir(final Consumer<Path> consumer) {
+    Path path = null;
+    try {
+      path = createTempDir();
+      consumer.accept(path);
+    } finally {
+      if (path != null) {
+        deleteDir(path);
+      }
+    }
+  }
+
+  static void useTempFile(final Consumer<Path> consumer) {
+    Path path = null;
+    try {
+      path = createTempFile();
+      consumer.accept(path);
+    } finally {
+      if (path != null) {
+        deleteIfExists(path);
+      }
+    }
+  }
+
+  public static long size(final Path path) {
+    try {
+      return Files.size(path);
+    } catch (final IOException e) {
+      throw new UncheckedIOException(e);
+    }
+  }
+
+  public static void delete(final Path path) {
+    try {
+      Files.delete(path);
+    } catch (final IOException e) {
+      throw new UncheckedIOException(e);
+    }
+  }
+
+  public static void deleteDir(final Path path) {
+    if (path != null && Files.isDirectory(path)) {
+      recursiveDelete(path);
+      deleteIfExists(path);
+    }
+  }
+
+  private static void recursiveDelete(final Path path) {
+    try {
+      Files.walkFileTree(
+          path,
+          EnumSet.of(FileVisitOption.FOLLOW_LINKS),
+          Integer.MAX_VALUE,
+          new FileVisitor<Path>() {
+            @Override
+            public FileVisitResult preVisitDirectory(
+                final Path dir, final BasicFileAttributes attrs) throws IOException {
+              return FileVisitResult.CONTINUE;
+            }
+
+            @Override
+            public FileVisitResult visitFileFailed(final Path file, final IOException exc)
+                throws IOException {
+              return FileVisitResult.CONTINUE;
+            }
+
+            @Override
+            public FileVisitResult visitFile(final Path file, final BasicFileAttributes attrs) {
+              deleteIfExists(file);
+              return FileVisitResult.CONTINUE;
+            }
+
+            @Override
+            public FileVisitResult postVisitDirectory(final Path dir, final IOException exc) {
+              if (!dir.equals(path)) {
+                deleteIfExists(dir);
+              }
+              return FileVisitResult.CONTINUE;
+            }
+          });
+    } catch (final NotDirectoryException e) {
+      // Ignore.
+    } catch (final IOException e) {
+      throw new UncheckedIOException(e);
+    }
+  }
+
+  private static void deleteIfExists(final Path path) {
+    try {
+      Files.deleteIfExists(path);
+    } catch (final IOException e) {
+      throw new UncheckedIOException(e);
+    }
+  }
+
+  public static long count(final Path path) {
+    try (final Stream<Path> stream = Files.list(path)) {
+      return stream.count();
+    } catch (final IOException e) {
+      throw new UncheckedIOException(e);
+    }
+  }
+}
diff --git a/src/test/java/org/lmdbjava/GarbageCollectionTest.java b/src/test/java/org/lmdbjava/GarbageCollectionTest.java
index 7615f7f0..f0aa64e4 100644
--- a/src/test/java/org/lmdbjava/GarbageCollectionTest.java
+++ b/src/test/java/org/lmdbjava/GarbageCollectionTest.java
@@ -13,20 +13,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package org.lmdbjava;
 
 import static java.nio.ByteBuffer.allocateDirect;
 import static java.nio.charset.StandardCharsets.UTF_8;
-import static org.junit.Assert.fail;
+import static org.assertj.core.api.Assertions.fail;
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
 import static org.lmdbjava.Env.create;
 
-import java.io.File;
-import java.io.IOException;
 import java.nio.ByteBuffer;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
+import org.junit.jupiter.api.Test;
 import org.mockito.MockedStatic;
 import org.mockito.Mockito;
 
@@ -36,62 +33,63 @@ public class GarbageCollectionTest {
   private static final String KEY_PREFIX = "Uncorruptedkey";
   private static final String VAL_PREFIX = "Uncorruptedval";
 
-  @Rule public final TemporaryFolder tmp = new TemporaryFolder();
-
   @Test
-  public void buffersNotGarbageCollectedTest() throws IOException {
-    final File path = tmp.newFolder();
-    try (Env<ByteBuffer> env = create().setMapSize(2_085_760_999).setMaxDbs(1).open(path)) {
-      final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
-
-      try (Txn<ByteBuffer> txn = env.txnWrite()) {
-        for (int i = 0; i < 5_000; i++) {
-          putBuffer(db, txn, i);
-        }
-        txn.commit();
-      }
+  void buffersNotGarbageCollectedTest() {
+    FileUtil.useTempDir(
+        dir -> {
+          try (Env<ByteBuffer> env =
+              create().setMapSize(2_085_760_999).setMaxDbs(1).open(dir.toFile())) {
+            final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
 
-      // Call GC before writing to LMDB and after last reference to buffer by
-      // changing the behavior of mask
-      try (MockedStatic<MaskedFlag> mockedStatic = Mockito.mockStatic(MaskedFlag.class)) {
-        mockedStatic
-            .when(MaskedFlag::mask)
-            .thenAnswer(
-                invocationOnMock -> {
-                  System.gc();
-                  return 0;
-                });
-        final int gcRecordWrites = Integer.getInteger("gcRecordWrites", 50);
-        try (Txn<ByteBuffer> txn = env.txnWrite()) {
-          for (int i = 0; i < gcRecordWrites; i++) {
-            putBuffer(db, txn, i);
-          }
-          txn.commit();
-        }
-      }
+            try (Txn<ByteBuffer> txn = env.txnWrite()) {
+              for (int i = 0; i < 5_000; i++) {
+                putBuffer(db, txn, i);
+              }
+              txn.commit();
+            }
 
-      // Find corrupt keys
-      try (Txn<ByteBuffer> txn = env.txnRead()) {
-        try (Cursor<ByteBuffer> c = db.openCursor(txn)) {
-          if (c.first()) {
-            do {
-              final byte[] rkey = new byte[c.key().remaining()];
-              c.key().get(rkey);
-              final byte[] rval = new byte[c.val().remaining()];
-              c.val().get(rval);
-              final String skey = new String(rkey, UTF_8);
-              final String sval = new String(rval, UTF_8);
-              if (!skey.startsWith("Uncorruptedkey")) {
-                fail("Found corrupt key " + skey);
+            // Call GC before writing to LMDB and after last reference to buffer by
+            // changing the behavior of mask
+            try (MockedStatic<MaskedFlag> mockedStatic = Mockito.mockStatic(MaskedFlag.class)) {
+              mockedStatic
+                  .when(MaskedFlag::mask)
+                  .thenAnswer(
+                      invocationOnMock -> {
+                        System.gc();
+                        return 0;
+                      });
+              final int gcRecordWrites = Integer.getInteger("gcRecordWrites", 50);
+              try (Txn<ByteBuffer> txn = env.txnWrite()) {
+                for (int i = 0; i < gcRecordWrites; i++) {
+                  putBuffer(db, txn, i);
+                }
+                txn.commit();
               }
-              if (!sval.startsWith("Uncorruptedval")) {
-                fail("Found corrupt val " + sval);
+            }
+
+            // Find corrupt keys
+            try (Txn<ByteBuffer> txn = env.txnRead()) {
+              try (Cursor<ByteBuffer> c = db.openCursor(txn)) {
+                if (c.first()) {
+                  do {
+                    final byte[] rkey = new byte[c.key().remaining()];
+                    c.key().get(rkey);
+                    final byte[] rval = new byte[c.val().remaining()];
+                    c.val().get(rval);
+                    final String skey = new String(rkey, UTF_8);
+                    final String sval = new String(rval, UTF_8);
+                    if (!skey.startsWith("Uncorruptedkey")) {
+                      fail("Found corrupt key " + skey);
+                    }
+                    if (!sval.startsWith("Uncorruptedval")) {
+                      fail("Found corrupt val " + sval);
+                    }
+                  } while (c.next());
+                }
               }
-            } while (c.next());
+            }
           }
-        }
-      }
-    }
+        });
   }
 
   private void putBuffer(final Dbi<ByteBuffer> db, final Txn<ByteBuffer> txn, final int i) {
diff --git a/src/test/java/org/lmdbjava/KeyRangeTest.java b/src/test/java/org/lmdbjava/KeyRangeTest.java
index 6e104bbf..0f77b92f 100644
--- a/src/test/java/org/lmdbjava/KeyRangeTest.java
+++ b/src/test/java/org/lmdbjava/KeyRangeTest.java
@@ -13,11 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package org.lmdbjava;
 
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.CoreMatchers.nullValue;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.lmdbjava.KeyRange.all;
 import static org.lmdbjava.KeyRange.allBackward;
 import static org.lmdbjava.KeyRange.atLeast;
@@ -40,8 +39,8 @@
 
 import java.util.ArrayList;
 import java.util.List;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 import org.lmdbjava.KeyRangeType.CursorOp;
 import org.lmdbjava.KeyRangeType.IteratorOp;
 
@@ -55,135 +54,135 @@ public final class KeyRangeTest {
 
   private final FakeCursor cursor = new FakeCursor();
 
+  @BeforeEach
+  void beforeEach() {
+    cursor.reset();
+  }
+
   @Test
-  public void allBackwardTest() {
+  void allBackwardTest() {
     verify(allBackward(), 8, 6, 4, 2);
   }
 
   @Test
-  public void allTest() {
+  void allTest() {
     verify(all(), 2, 4, 6, 8);
   }
 
   @Test
-  public void atLeastBackwardTest() {
+  void atLeastBackwardTest() {
     verify(atLeastBackward(5), 4, 2);
     verify(atLeastBackward(6), 6, 4, 2);
     verify(atLeastBackward(9), 8, 6, 4, 2);
   }
 
   @Test
-  public void atLeastTest() {
+  void atLeastTest() {
     verify(atLeast(5), 6, 8);
     verify(atLeast(6), 6, 8);
   }
 
   @Test
-  public void atMostBackwardTest() {
+  void atMostBackwardTest() {
     verify(atMostBackward(5), 8, 6);
     verify(atMostBackward(6), 8, 6);
   }
 
   @Test
-  public void atMostTest() {
+  void atMostTest() {
     verify(atMost(5), 2, 4);
     verify(atMost(6), 2, 4, 6);
   }
 
-  @Before
-  public void before() {
-    cursor.reset();
-  }
-
   @Test
-  public void closedBackwardTest() {
+  void closedBackwardTest() {
     verify(closedBackward(7, 3), 6, 4);
     verify(closedBackward(6, 2), 6, 4, 2);
     verify(closedBackward(9, 3), 8, 6, 4);
   }
 
   @Test
-  public void closedOpenBackwardTest() {
+  void closedOpenBackwardTest() {
     verify(closedOpenBackward(8, 3), 8, 6, 4);
     verify(closedOpenBackward(7, 2), 6, 4);
     verify(closedOpenBackward(9, 3), 8, 6, 4);
   }
 
   @Test
-  public void closedOpenTest() {
+  void closedOpenTest() {
     verify(closedOpen(3, 8), 4, 6);
     verify(closedOpen(2, 6), 2, 4);
   }
 
   @Test
-  public void closedTest() {
+  void closedTest() {
     verify(closed(3, 7), 4, 6);
     verify(closed(2, 6), 2, 4, 6);
   }
 
   @Test
-  public void fakeCursor() {
-    assertThat(cursor.first(), is(2));
-    assertThat(cursor.next(), is(4));
-    assertThat(cursor.next(), is(6));
-    assertThat(cursor.next(), is(8));
-    assertThat(cursor.next(), nullValue());
-    assertThat(cursor.first(), is(2));
-    assertThat(cursor.prev(), nullValue());
-    assertThat(cursor.getWithSetRange(3), is(4));
-    assertThat(cursor.next(), is(6));
-    assertThat(cursor.getWithSetRange(1), is(2));
-    assertThat(cursor.last(), is(8));
-    assertThat(cursor.getWithSetRange(100), nullValue());
+  void fakeCursor() {
+    assertThat(cursor.first()).isEqualTo(2);
+    assertThat(cursor.next()).isEqualTo(4);
+    assertThat(cursor.next()).isEqualTo(6);
+    assertThat(cursor.next()).isEqualTo(8);
+    assertThat(cursor.next()).isNull();
+    assertThat(cursor.first()).isEqualTo(2);
+    assertThat(cursor.prev()).isNull();
+    assertThat(cursor.getWithSetRange(3)).isEqualTo(4);
+    assertThat(cursor.next()).isEqualTo(6);
+    assertThat(cursor.getWithSetRange(1)).isEqualTo(2);
+    assertThat(cursor.last()).isEqualTo(8);
+    assertThat(cursor.getWithSetRange(100)).isNull();
   }
 
   @Test
-  public void greaterThanBackwardTest() {
+  void greaterThanBackwardTest() {
     verify(greaterThanBackward(6), 4, 2);
     verify(greaterThanBackward(7), 6, 4, 2);
     verify(greaterThanBackward(9), 8, 6, 4, 2);
   }
 
   @Test
-  public void greaterThanTest() {
+  void greaterThanTest() {
     verify(greaterThan(4), 6, 8);
     verify(greaterThan(3), 4, 6, 8);
   }
 
   @Test
-  public void lessThanBackwardTest() {
+  void lessThanBackwardTest() {
     verify(lessThanBackward(5), 8, 6);
     verify(lessThanBackward(2), 8, 6, 4);
   }
 
   @Test
-  public void lessThanTest() {
+  void lessThanTest() {
     verify(lessThan(5), 2, 4);
     verify(lessThan(8), 2, 4, 6);
   }
 
   @Test
-  public void openBackwardTest() {
+  void openBackwardTest() {
     verify(openBackward(7, 2), 6, 4);
     verify(openBackward(8, 1), 6, 4, 2);
     verify(openBackward(9, 4), 8, 6);
   }
 
   @Test
-  public void openClosedBackwardTest() {
+  void openClosedBackwardTest() {
     verify(openClosedBackward(7, 2), 6, 4, 2);
     verify(openClosedBackward(8, 4), 6, 4);
     verify(openClosedBackward(9, 4), 8, 6, 4);
   }
 
   @Test
-  public void openClosedTest() {
+  void openClosedTest() {
     verify(openClosed(3, 8), 4, 6, 8);
     verify(openClosed(2, 6), 4, 6);
   }
 
   @Test
-  public void openTest() {
+  void openTest() {
     verify(open(3, 7), 4, 6);
     verify(open(2, 8), 4, 6);
   }
@@ -212,9 +211,9 @@ private void verify(final KeyRange<Integer> range, final int... expected) {
     } while (op != TERMINATE);
 
     for (int idx = 0; idx < results.size(); idx++) {
-      assertThat("idx " + idx, results.get(idx), is(expected[idx]));
+      assertThat(results.get(idx)).withFailMessage("idx " + idx).isEqualTo(expected[idx]);
     }
-    assertThat(results.size(), is(expected.length));
+    assertThat(results.size()).isEqualTo(expected.length);
   }
 
   /**
diff --git a/src/test/java/org/lmdbjava/LibraryTest.java b/src/test/java/org/lmdbjava/LibraryTest.java
index 6dcfcee9..3b492d75 100644
--- a/src/test/java/org/lmdbjava/LibraryTest.java
+++ b/src/test/java/org/lmdbjava/LibraryTest.java
@@ -13,30 +13,30 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package org.lmdbjava;
 
 import static java.lang.Long.BYTES;
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.lmdbjava.Library.RUNTIME;
 import static org.lmdbjava.TestUtils.invokePrivateConstructor;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.lmdbjava.Library.MDB_envinfo;
 
 /** Test {@link Library}. */
 public final class LibraryTest {
 
   @Test
-  public void coverPrivateConstructors() {
+  void coverPrivateConstructors() {
     invokePrivateConstructor(Library.class);
     invokePrivateConstructor(UnsafeAccess.class);
   }
 
   @Test
-  public void structureFieldOrder() {
+  void structureFieldOrder() {
     final MDB_envinfo v = new MDB_envinfo(RUNTIME);
-    assertThat(v.f0_me_mapaddr.offset(), is(0L));
-    assertThat(v.f1_me_mapsize.offset(), is((long) BYTES));
+    assertThat(v.f0_me_mapaddr.offset()).isEqualTo(0L);
+    assertThat(v.f1_me_mapsize.offset()).isEqualTo(BYTES);
   }
 }
diff --git a/src/test/java/org/lmdbjava/MaskedFlagTest.java b/src/test/java/org/lmdbjava/MaskedFlagTest.java
index 918bf922..25c23797 100644
--- a/src/test/java/org/lmdbjava/MaskedFlagTest.java
+++ b/src/test/java/org/lmdbjava/MaskedFlagTest.java
@@ -13,57 +13,56 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package org.lmdbjava;
 
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.arrayWithSize;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.lmdbjava.EnvFlags.MDB_FIXEDMAP;
 import static org.lmdbjava.EnvFlags.MDB_NOSYNC;
 import static org.lmdbjava.EnvFlags.MDB_RDONLY_ENV;
 import static org.lmdbjava.MaskedFlag.isSet;
 import static org.lmdbjava.MaskedFlag.mask;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 /** Test {@link MaskedFlag}. */
 public final class MaskedFlagTest {
 
   @Test
-  public void isSetOperates() {
-    assertThat(isSet(0, MDB_NOSYNC), is(false));
-    assertThat(isSet(0, MDB_FIXEDMAP), is(false));
-    assertThat(isSet(0, MDB_RDONLY_ENV), is(false));
+  void isSetOperates() {
+    assertThat(isSet(0, MDB_NOSYNC)).isFalse();
+    assertThat(isSet(0, MDB_FIXEDMAP)).isFalse();
+    assertThat(isSet(0, MDB_RDONLY_ENV)).isFalse();
 
-    assertThat(isSet(MDB_FIXEDMAP.getMask(), MDB_NOSYNC), is(false));
-    assertThat(isSet(MDB_FIXEDMAP.getMask(), MDB_FIXEDMAP), is(true));
-    assertThat(isSet(MDB_FIXEDMAP.getMask(), MDB_RDONLY_ENV), is(false));
+    assertThat(isSet(MDB_FIXEDMAP.getMask(), MDB_NOSYNC)).isFalse();
+    assertThat(isSet(MDB_FIXEDMAP.getMask(), MDB_FIXEDMAP)).isTrue();
+    assertThat(isSet(MDB_FIXEDMAP.getMask(), MDB_RDONLY_ENV)).isFalse();
 
-    assertThat(isSet(MDB_NOSYNC.getMask(), MDB_NOSYNC), is(true));
-    assertThat(isSet(MDB_NOSYNC.getMask(), MDB_FIXEDMAP), is(false));
-    assertThat(isSet(MDB_NOSYNC.getMask(), MDB_RDONLY_ENV), is(false));
+    assertThat(isSet(MDB_NOSYNC.getMask(), MDB_NOSYNC)).isTrue();
+    assertThat(isSet(MDB_NOSYNC.getMask(), MDB_FIXEDMAP)).isFalse();
+    assertThat(isSet(MDB_NOSYNC.getMask(), MDB_RDONLY_ENV)).isFalse();
 
     final int syncFixed = mask(MDB_NOSYNC, MDB_FIXEDMAP);
-    assertThat(isSet(syncFixed, MDB_NOSYNC), is(true));
-    assertThat(isSet(syncFixed, MDB_FIXEDMAP), is(true));
-    assertThat(isSet(syncFixed, MDB_RDONLY_ENV), is(false));
+    assertThat(isSet(syncFixed, MDB_NOSYNC)).isTrue();
+    assertThat(isSet(syncFixed, MDB_FIXEDMAP)).isTrue();
+    assertThat(isSet(syncFixed, MDB_RDONLY_ENV)).isFalse();
   }
 
   @Test
-  public void masking() {
+  void masking() {
     final EnvFlags[] nullFlags = null;
-    assertThat(mask(nullFlags), is(0));
+    assertThat(mask(nullFlags)).isEqualTo(0);
 
     final EnvFlags[] emptyFlags = new EnvFlags[] {};
-    assertThat(mask(emptyFlags), is(0));
+    assertThat(mask(emptyFlags)).isEqualTo(0);
 
     final EnvFlags[] nullElementZero = new EnvFlags[] {null};
-    assertThat(nullElementZero, is(arrayWithSize(1)));
-    assertThat(mask(nullElementZero), is(0));
+    assertThat(nullElementZero.length).isEqualTo(1);
+    assertThat(mask(nullElementZero)).isEqualTo(0);
 
-    assertThat(mask(MDB_NOSYNC), is(MDB_NOSYNC.getMask()));
+    assertThat(mask(MDB_NOSYNC)).isEqualTo(MDB_NOSYNC.getMask());
 
     final int expected = MDB_NOSYNC.getMask() + MDB_FIXEDMAP.getMask();
-    assertThat(mask(MDB_NOSYNC, MDB_FIXEDMAP), is(expected));
+    assertThat(mask(MDB_NOSYNC, MDB_FIXEDMAP)).isEqualTo(expected);
   }
 }
diff --git a/src/test/java/org/lmdbjava/MetaTest.java b/src/test/java/org/lmdbjava/MetaTest.java
index be0faa87..3e893561 100644
--- a/src/test/java/org/lmdbjava/MetaTest.java
+++ b/src/test/java/org/lmdbjava/MetaTest.java
@@ -13,17 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package org.lmdbjava;
 
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.CoreMatchers.not;
-import static org.hamcrest.CoreMatchers.nullValue;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.lmdbjava.LmdbNativeException.PageCorruptedException.MDB_CORRUPTED;
 import static org.lmdbjava.Meta.error;
 import static org.lmdbjava.TestUtils.invokePrivateConstructor;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.lmdbjava.Meta.Version;
 
 /** Test {@link Meta}. */
@@ -35,15 +33,15 @@ public void coverPrivateConstructors() {
   }
 
   @Test
-  public void errCode() {
-    assertThat(error(MDB_CORRUPTED), is("MDB_CORRUPTED: Located page was wrong type"));
+  void errCode() {
+    assertThat(error(MDB_CORRUPTED)).isEqualTo("MDB_CORRUPTED: Located page was wrong type");
   }
 
   @Test
-  public void version() {
+  void version() {
     final Version v = Meta.version();
-    assertThat(v, not(nullValue()));
-    assertThat(v.major, is(0));
-    assertThat(v.minor, is(9));
+    assertThat(v).isNotNull();
+    assertThat(v.major).isEqualTo(0);
+    assertThat(v.minor).isEqualTo(9);
   }
 }
diff --git a/src/test/java/org/lmdbjava/ResultCodeMapperTest.java b/src/test/java/org/lmdbjava/ResultCodeMapperTest.java
index 7a3764ed..c363d60a 100644
--- a/src/test/java/org/lmdbjava/ResultCodeMapperTest.java
+++ b/src/test/java/org/lmdbjava/ResultCodeMapperTest.java
@@ -13,22 +13,20 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package org.lmdbjava;
 
 import static java.lang.Integer.MAX_VALUE;
-import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.CoreMatchers.notNullValue;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.hasSize;
-import static org.junit.Assert.fail;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.assertj.core.api.Assertions.fail;
 import static org.lmdbjava.Cursor.FullException.MDB_CURSOR_FULL;
 import static org.lmdbjava.ResultCodeMapper.checkRc;
 import static org.lmdbjava.TestUtils.invokePrivateConstructor;
 
 import java.util.HashSet;
 import java.util.Set;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 import org.lmdbjava.Cursor.FullException;
 import org.lmdbjava.Dbi.BadDbiException;
 import org.lmdbjava.Dbi.BadValueSizeException;
@@ -86,71 +84,71 @@ public final class ResultCodeMapperTest {
   }
 
   @Test
-  public void checkErrAll() {
+  void checkErrAll() {
     for (final Integer rc : RESULT_CODES) {
       try {
         checkRc(rc);
         fail("Exception expected for RC " + rc);
       } catch (final LmdbNativeException e) {
-        assertThat(e.getResultCode(), is(rc));
+        assertThat(e.getResultCode()).isEqualTo(rc);
       }
     }
   }
 
-  @Test(expected = ConstantDerivedException.class)
-  public void checkErrConstantDerived() {
-    checkRc(20);
+  @Test
+  void checkErrConstantDerived() {
+    assertThatThrownBy(() -> checkRc(20)).isInstanceOf(ConstantDerivedException.class);
   }
 
   @Test
-  public void checkErrConstantDerivedMessage() {
+  void checkErrConstantDerivedMessage() {
     try {
       checkRc(2);
       fail("Should have raised exception");
     } catch (final ConstantDerivedException ex) {
-      assertThat(ex.getMessage(), containsString("No such file or directory"));
+      assertThat(ex.getMessage()).contains("No such file or directory");
     }
   }
 
-  @Test(expected = FullException.class)
-  public void checkErrCursorFull() {
-    checkRc(MDB_CURSOR_FULL);
+  @Test
+  void checkErrCursorFull() {
+    assertThatThrownBy(() -> checkRc(MDB_CURSOR_FULL)).isInstanceOf(FullException.class);
   }
 
-  @Test(expected = IllegalArgumentException.class)
-  public void checkErrUnknownResultCode() {
-    checkRc(MAX_VALUE);
+  @Test
+  void checkErrUnknownResultCode() {
+    assertThatThrownBy(() -> checkRc(MAX_VALUE)).isInstanceOf(IllegalArgumentException.class);
   }
 
   @Test
-  public void coverPrivateConstructors() {
+  void coverPrivateConstructors() {
     invokePrivateConstructor(ResultCodeMapper.class);
   }
 
   @Test
-  public void lmdbExceptionPreservesRootCause() {
+  void lmdbExceptionPreservesRootCause() {
     final Exception cause = new IllegalStateException("root cause");
     final LmdbException e = new LmdbException("test", cause);
-    assertThat(e.getCause(), is(cause));
-    assertThat(e.getMessage(), is("test"));
+    assertThat(e.getCause()).isEqualTo(cause);
+    assertThat(e.getMessage()).isEqualTo("test");
   }
 
   @Test
-  public void mapperReturnsUnique() {
+  void mapperReturnsUnique() {
     final Set<LmdbNativeException> seen = new HashSet<>();
     for (final Integer rc : RESULT_CODES) {
       try {
         checkRc(rc);
       } catch (final LmdbNativeException ex) {
-        assertThat(ex, is(notNullValue()));
+        assertThat(ex).isNotNull();
         seen.add(ex);
       }
     }
-    assertThat(seen, hasSize(RESULT_CODES.size()));
+    assertThat(seen).hasSize(RESULT_CODES.size());
   }
 
   @Test
-  public void noDuplicateResultCodes() {
-    assertThat(RESULT_CODES.size(), is(EXCEPTIONS.size()));
+  void noDuplicateResultCodes() {
+    assertThat(RESULT_CODES.size()).isEqualTo(EXCEPTIONS.size());
   }
 }
diff --git a/src/test/java/org/lmdbjava/TargetNameTest.java b/src/test/java/org/lmdbjava/TargetNameTest.java
index b598be55..e766aaa6 100644
--- a/src/test/java/org/lmdbjava/TargetNameTest.java
+++ b/src/test/java/org/lmdbjava/TargetNameTest.java
@@ -13,15 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package org.lmdbjava;
 
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.lmdbjava.TargetName.isExternal;
 import static org.lmdbjava.TargetName.resolveFilename;
 import static org.lmdbjava.TestUtils.invokePrivateConstructor;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 /** Test {@link TargetName}. */
 public final class TargetNameTest {
@@ -29,18 +29,18 @@ public final class TargetNameTest {
   private static final String NONE = "";
 
   @Test
-  public void coverPrivateConstructors() {
+  void coverPrivateConstructors() {
     invokePrivateConstructor(TargetName.class);
   }
 
   @Test
-  public void customEmbedded() {
-    assertThat(resolveFilename(NONE, "x/y.so", NONE, NONE), is("x/y.so"));
-    assertThat(isExternal(NONE), is(false));
+  void customEmbedded() {
+    assertThat(resolveFilename(NONE, "x/y.so", NONE, NONE)).isEqualTo("x/y.so");
+    assertThat(isExternal(NONE)).isFalse();
   }
 
   @Test
-  public void embeddedNameResolution() {
+  void embeddedNameResolution() {
     embed("aarch64-linux-gnu.so", "aarch64", "Linux");
     embed("aarch64-macos-none.so", "aarch64", "Mac OS");
     embed("x86_64-linux-gnu.so", "x86_64", "Linux");
@@ -49,19 +49,19 @@ public void embeddedNameResolution() {
   }
 
   @Test
-  public void externalLibrary() {
-    assertThat(resolveFilename("/l.so", NONE, NONE, NONE), is("/l.so"));
-    assertThat(TargetName.isExternal("/l.so"), is(true));
+  void externalLibrary() {
+    assertThat(resolveFilename("/l.so", NONE, NONE, NONE)).isEqualTo("/l.so");
+    assertThat(TargetName.isExternal("/l.so")).isTrue();
   }
 
   @Test
-  public void externalTakesPriority() {
-    assertThat(resolveFilename("/lm.so", "x/y.so", NONE, NONE), is("/lm.so"));
-    assertThat(isExternal("/lm.so"), is(true));
+  void externalTakesPriority() {
+    assertThat(resolveFilename("/lm.so", "x/y.so", NONE, NONE)).isEqualTo("/lm.so");
+    assertThat(isExternal("/lm.so")).isTrue();
   }
 
   private void embed(final String lib, final String arch, final String os) {
-    assertThat(resolveFilename(NONE, NONE, arch, os), is("org/lmdbjava/" + lib));
-    assertThat(isExternal(NONE), is(false));
+    assertThat(resolveFilename(NONE, NONE, arch, os)).isEqualTo("org/lmdbjava/" + lib);
+    assertThat(isExternal(NONE)).isFalse();
   }
 }
diff --git a/src/test/java/org/lmdbjava/TutorialTest.java b/src/test/java/org/lmdbjava/TutorialTest.java
index b86c1d2a..1b42b327 100644
--- a/src/test/java/org/lmdbjava/TutorialTest.java
+++ b/src/test/java/org/lmdbjava/TutorialTest.java
@@ -13,18 +13,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package org.lmdbjava;
 
 import static java.nio.ByteBuffer.allocateDirect;
 import static java.nio.charset.StandardCharsets.UTF_8;
 import static java.util.concurrent.Executors.newCachedThreadPool;
 import static java.util.concurrent.TimeUnit.SECONDS;
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.CoreMatchers.notNullValue;
-import static org.hamcrest.CoreMatchers.startsWith;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
 import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
@@ -35,16 +31,13 @@
 import static org.lmdbjava.SeekOp.MDB_LAST;
 import static org.lmdbjava.SeekOp.MDB_PREV;
 
-import java.io.File;
-import java.io.IOException;
 import java.nio.ByteBuffer;
+import java.nio.file.Path;
 import java.util.concurrent.ExecutorService;
 import org.agrona.DirectBuffer;
 import org.agrona.MutableDirectBuffer;
 import org.agrona.concurrent.UnsafeBuffer;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
+import org.junit.jupiter.api.Test;
 import org.lmdbjava.CursorIterable.KeyVal;
 
 /**
@@ -63,426 +56,429 @@
 public final class TutorialTest {
 
   private static final String DB_NAME = "my DB";
-  @Rule public final TemporaryFolder tmp = new TemporaryFolder();
 
-  /**
-   * In this first tutorial we will use LmdbJava with some basic defaults.
-   *
-   * @throws IOException if a path was unavailable for memory mapping
-   */
+  /** In this first tutorial we will use LmdbJava with some basic defaults. */
   @Test
-  public void tutorial1() throws IOException {
+  void tutorial1() {
     // We need a storage directory first.
     // The path cannot be on a remote file system.
-    final File path = tmp.newFolder();
-
-    // We always need an Env. An Env owns a physical on-disk storage file. One
-    // Env can store many different databases (ie sorted maps).
-    final Env<ByteBuffer> env =
-        create()
-            // LMDB also needs to know how large our DB might be. Over-estimating is OK.
-            .setMapSize(10_485_760)
-            // LMDB also needs to know how many DBs (Dbi) we want to store in this Env.
-            .setMaxDbs(1)
-            // Now let's open the Env. The same path can be concurrently opened and
-            // used in different processes, but do not open the same path twice in
-            // the same process at the same time.
-            .open(path);
-
-    // We need a Dbi for each DB. A Dbi roughly equates to a sorted map. The
-    // MDB_CREATE flag causes the DB to be created if it doesn't already exist.
-    final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
-
-    // We want to store some data, so we will need a direct ByteBuffer.
-    // Note that LMDB keys cannot exceed maxKeySize bytes (511 bytes by default).
-    // Values can be larger.
-    final ByteBuffer key = allocateDirect(env.getMaxKeySize());
-    final ByteBuffer val = allocateDirect(700);
-    key.put("greeting".getBytes(UTF_8)).flip();
-    val.put("Hello world".getBytes(UTF_8)).flip();
-    final int valSize = val.remaining();
-
-    // Now store it. Dbi.put() internally begins and commits a transaction (Txn).
-    db.put(key, val);
-
-    // To fetch any data from LMDB we need a Txn. A Txn is very important in
-    // LmdbJava because it offers ACID characteristics and internally holds a
-    // read-only key buffer and read-only value buffer. These read-only buffers
-    // are always the same two Java objects, but point to different LMDB-managed
-    // memory as we use Dbi (and Cursor) methods. These read-only buffers remain
-    // valid only until the Txn is released or the next Dbi or Cursor call. If
-    // you need data afterwards, you should copy the bytes to your own buffer.
-    try (Txn<ByteBuffer> txn = env.txnRead()) {
-      final ByteBuffer found = db.get(txn, key);
-      assertNotNull(found);
-
-      // The fetchedVal is read-only and points to LMDB memory
-      final ByteBuffer fetchedVal = txn.val();
-      assertThat(fetchedVal.remaining(), is(valSize));
-
-      // Let's double-check the fetched value is correct
-      assertThat(UTF_8.decode(fetchedVal).toString(), is("Hello world"));
-    }
-
-    // We can also delete. The simplest way is to let Dbi allocate a new Txn...
-    db.delete(key);
-
-    // Now if we try to fetch the deleted row, it won't be present
-    try (Txn<ByteBuffer> txn = env.txnRead()) {
-      assertNull(db.get(txn, key));
-    }
-
-    env.close();
+    FileUtil.useTempDir(
+        dir -> {
+
+          // We always need an Env. An Env owns a physical on-disk storage file. One
+          // Env can store many different databases (ie sorted maps).
+          final Env<ByteBuffer> env =
+              create()
+                  // LMDB also needs to know how large our DB might be. Over-estimating is OK.
+                  .setMapSize(10_485_760)
+                  // LMDB also needs to know how many DBs (Dbi) we want to store in this Env.
+                  .setMaxDbs(1)
+                  // Now let's open the Env. The same path can be concurrently opened and
+                  // used in different processes, but do not open the same path twice in
+                  // the same process at the same time.
+                  .open(dir.toFile());
+
+          // We need a Dbi for each DB. A Dbi roughly equates to a sorted map. The
+          // MDB_CREATE flag causes the DB to be created if it doesn't already exist.
+          final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
+
+          // We want to store some data, so we will need a direct ByteBuffer.
+          // Note that LMDB keys cannot exceed maxKeySize bytes (511 bytes by default).
+          // Values can be larger.
+          final ByteBuffer key = allocateDirect(env.getMaxKeySize());
+          final ByteBuffer val = allocateDirect(700);
+          key.put("greeting".getBytes(UTF_8)).flip();
+          val.put("Hello world".getBytes(UTF_8)).flip();
+          final int valSize = val.remaining();
+
+          // Now store it. Dbi.put() internally begins and commits a transaction (Txn).
+          db.put(key, val);
+
+          // To fetch any data from LMDB we need a Txn. A Txn is very important in
+          // LmdbJava because it offers ACID characteristics and internally holds a
+          // read-only key buffer and read-only value buffer. These read-only buffers
+          // are always the same two Java objects, but point to different LMDB-managed
+          // memory as we use Dbi (and Cursor) methods. These read-only buffers remain
+          // valid only until the Txn is released or the next Dbi or Cursor call. If
+          // you need data afterwards, you should copy the bytes to your own buffer.
+          try (Txn<ByteBuffer> txn = env.txnRead()) {
+            final ByteBuffer found = db.get(txn, key);
+            assertThat(found).isNotNull();
+
+            // The fetchedVal is read-only and points to LMDB memory
+            final ByteBuffer fetchedVal = txn.val();
+            assertThat(fetchedVal.remaining()).isEqualTo(valSize);
+
+            // Let's double-check the fetched value is correct
+            assertThat(UTF_8.decode(fetchedVal).toString()).isEqualTo("Hello world");
+          }
+
+          // We can also delete. The simplest way is to let Dbi allocate a new Txn...
+          db.delete(key);
+
+          // Now if we try to fetch the deleted row, it won't be present
+          try (Txn<ByteBuffer> txn = env.txnRead()) {
+            assertThat(db.get(txn, key)).isNull();
+          }
+
+          env.close();
+        });
   }
 
-  /**
-   * In this second tutorial we'll learn more about LMDB's ACID Txns.
-   *
-   * @throws IOException if a path was unavailable for memory mapping
-   * @throws InterruptedException if executor shutdown interrupted
-   */
+  /** In this second tutorial we'll learn more about LMDB's ACID Txns. */
   @Test
-  public void tutorial2() throws IOException, InterruptedException {
-    final Env<ByteBuffer> env = createSimpleEnv(tmp.newFolder());
-    final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
-    final ByteBuffer key = allocateDirect(env.getMaxKeySize());
-    final ByteBuffer val = allocateDirect(700);
-
-    // Let's write and commit "key1" via a Txn. A Txn can include multiple Dbis.
-    // Note write Txns block other write Txns, due to writes being serialized.
-    // It's therefore important to avoid unnecessarily long-lived write Txns.
-    try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      key.put("key1".getBytes(UTF_8)).flip();
-      val.put("lmdb".getBytes(UTF_8)).flip();
-      db.put(txn, key, val);
-
-      // We can read data too, even though this is a write Txn.
-      final ByteBuffer found = db.get(txn, key);
-      assertNotNull(found);
-
-      // An explicit commit is required, otherwise Txn.close() rolls it back.
-      txn.commit();
-    }
-
-    // Open a read-only Txn. It only sees data that existed at Txn creation time.
-    final Txn<ByteBuffer> rtx = env.txnRead();
-
-    // Our read Txn can fetch key1 without problem, as it existed at Txn creation.
-    ByteBuffer found = db.get(rtx, key);
-    assertNotNull(found);
-
-    // Note that our main test thread holds the Txn. Only one Txn per thread is
-    // typically permitted (the exception is a read-only Env with MDB_NOTLS).
-    //
-    // Let's write out a "key2" via a new write Txn in a different thread.
-    final ExecutorService es = newCachedThreadPool();
-    es.execute(
-        () -> {
-          try (Txn<ByteBuffer> txn = env.txnWrite()) {
-            key.clear();
-            key.put("key2".getBytes(UTF_8)).flip();
-            db.put(txn, key, val);
-            txn.commit();
+  void tutorial2() {
+    FileUtil.useTempDir(
+        dir -> {
+          try {
+            final Env<ByteBuffer> env = createSimpleEnv(dir);
+            final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
+            final ByteBuffer key = allocateDirect(env.getMaxKeySize());
+            final ByteBuffer val = allocateDirect(700);
+
+            // Let's write and commit "key1" via a Txn. A Txn can include multiple Dbis.
+            // Note write Txns block other write Txns, due to writes being serialized.
+            // It's therefore important to avoid unnecessarily long-lived write Txns.
+            try (Txn<ByteBuffer> txn = env.txnWrite()) {
+              key.put("key1".getBytes(UTF_8)).flip();
+              val.put("lmdb".getBytes(UTF_8)).flip();
+              db.put(txn, key, val);
+
+              // We can read data too, even though this is a write Txn.
+              final ByteBuffer found = db.get(txn, key);
+              assertThat(found).isNotNull();
+
+              // An explicit commit is required, otherwise Txn.close() rolls it back.
+              txn.commit();
+            }
+
+            // Open a read-only Txn. It only sees data that existed at Txn creation time.
+            final Txn<ByteBuffer> rtx = env.txnRead();
+
+            // Our read Txn can fetch key1 without problem, as it existed at Txn creation.
+            ByteBuffer found = db.get(rtx, key);
+            assertThat(found).isNotNull();
+
+            // Note that our main test thread holds the Txn. Only one Txn per thread is
+            // typically permitted (the exception is a read-only Env with MDB_NOTLS).
+            //
+            // Let's write out a "key2" via a new write Txn in a different thread.
+            final ExecutorService es = newCachedThreadPool();
+            es.execute(
+                () -> {
+                  try (Txn<ByteBuffer> txn = env.txnWrite()) {
+                    key.clear();
+                    key.put("key2".getBytes(UTF_8)).flip();
+                    db.put(txn, key, val);
+                    txn.commit();
+                  }
+                });
+            es.shutdown();
+            es.awaitTermination(10, SECONDS);
+
+            // Even though key2 has been committed, our read Txn still can't see it.
+            found = db.get(rtx, key);
+            assertThat(found).isNull();
+
+            // To see key2, we could create a new Txn. But a reset/renew is much faster.
+            // Reset/renew is also important to avoid long-lived read Txns, as these
+            // prevent the re-use of free pages by write Txns (ie the DB will grow).
+            rtx.reset();
+            // ... potentially long operation here ...
+            rtx.renew();
+            found = db.get(rtx, key);
+            assertThat(found).isNotNull();
+
+            // Don't forget to close the read Txn now we're completely finished. We could
+            // have avoided this if we used a try-with-resources block, but we wanted to
+            // play around with multiple concurrent Txns to demonstrate the "I" in ACID.
+            rtx.close();
+            env.close();
+          } catch (final InterruptedException e) {
+            throw new RuntimeException(e);
           }
         });
-    es.shutdown();
-    es.awaitTermination(10, SECONDS);
-
-    // Even though key2 has been committed, our read Txn still can't see it.
-    found = db.get(rtx, key);
-    assertNull(found);
-
-    // To see key2, we could create a new Txn. But a reset/renew is much faster.
-    // Reset/renew is also important to avoid long-lived read Txns, as these
-    // prevent the re-use of free pages by write Txns (ie the DB will grow).
-    rtx.reset();
-    // ... potentially long operation here ...
-    rtx.renew();
-    found = db.get(rtx, key);
-    assertNotNull(found);
-
-    // Don't forget to close the read Txn now we're completely finished. We could
-    // have avoided this if we used a try-with-resources block, but we wanted to
-    // play around with multiple concurrent Txns to demonstrate the "I" in ACID.
-    rtx.close();
-    env.close();
   }
 
   /**
    * In this third tutorial we'll have a look at the Cursor. Up until now we've just used Dbi, which
    * is good enough for simple cases but unsuitable if you don't know the key to fetch, or want to
    * iterate over all the data etc.
-   *
-   * @throws IOException if a path was unavailable for memory mapping
    */
   @Test
-  public void tutorial3() throws IOException {
-    final Env<ByteBuffer> env = createSimpleEnv(tmp.newFolder());
-    final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
-    final ByteBuffer key = allocateDirect(env.getMaxKeySize());
-    final ByteBuffer val = allocateDirect(700);
-
-    try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      // A cursor always belongs to a particular Dbi.
-      final Cursor<ByteBuffer> c = db.openCursor(txn);
-
-      // We can put via a Cursor. Note we're adding keys in a strange order,
-      // as we want to show you that LMDB returns them in sorted order.
-      key.put("zzz".getBytes(UTF_8)).flip();
-      val.put("lmdb".getBytes(UTF_8)).flip();
-      c.put(key, val);
-      key.clear();
-      key.put("aaa".getBytes(UTF_8)).flip();
-      c.put(key, val);
-      key.clear();
-      key.put("ccc".getBytes(UTF_8)).flip();
-      c.put(key, val);
-
-      // We can read from the Cursor by key.
-      c.get(key, MDB_SET);
-      assertThat(UTF_8.decode(c.key()).toString(), is("ccc"));
-
-      // Let's see that LMDB provides the keys in appropriate order....
-      c.seek(MDB_FIRST);
-      assertThat(UTF_8.decode(c.key()).toString(), is("aaa"));
-
-      c.seek(MDB_LAST);
-      assertThat(UTF_8.decode(c.key()).toString(), is("zzz"));
-
-      c.seek(MDB_PREV);
-      assertThat(UTF_8.decode(c.key()).toString(), is("ccc"));
-
-      // Cursors can also delete the current key.
-      c.delete();
-
-      c.close();
-      txn.commit();
-    }
-
-    // A read-only Cursor can survive its original Txn being closed. This is
-    // useful if you want to close the original Txn (eg maybe you created the
-    // Cursor during the constructor of a singleton with a throw-away Txn). Of
-    // course, you cannot use the Cursor if its Txn is closed or currently reset.
-    final Txn<ByteBuffer> tx1 = env.txnRead();
-    final Cursor<ByteBuffer> c = db.openCursor(tx1);
-    tx1.close();
-
-    // The Cursor becomes usable again by "renewing" it with an active read Txn.
-    final Txn<ByteBuffer> tx2 = env.txnRead();
-    c.renew(tx2);
-    c.seek(MDB_FIRST);
-
-    // As usual with read Txns, we can reset and renew them. The Cursor does
-    // not need any special handling if we do this.
-    tx2.reset();
-    // ... potentially long operation here ...
-    tx2.renew();
-    c.seek(MDB_LAST);
-
-    tx2.close();
-    env.close();
+  void tutorial3() {
+    FileUtil.useTempDir(
+        dir -> {
+          final Env<ByteBuffer> env = createSimpleEnv(dir);
+          final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
+          final ByteBuffer key = allocateDirect(env.getMaxKeySize());
+          final ByteBuffer val = allocateDirect(700);
+
+          try (Txn<ByteBuffer> txn = env.txnWrite()) {
+            // A cursor always belongs to a particular Dbi.
+            final Cursor<ByteBuffer> c = db.openCursor(txn);
+
+            // We can put via a Cursor. Note we're adding keys in a strange order,
+            // as we want to show you that LMDB returns them in sorted order.
+            key.put("zzz".getBytes(UTF_8)).flip();
+            val.put("lmdb".getBytes(UTF_8)).flip();
+            c.put(key, val);
+            key.clear();
+            key.put("aaa".getBytes(UTF_8)).flip();
+            c.put(key, val);
+            key.clear();
+            key.put("ccc".getBytes(UTF_8)).flip();
+            c.put(key, val);
+
+            // We can read from the Cursor by key.
+            c.get(key, MDB_SET);
+            assertThat(UTF_8.decode(c.key()).toString()).isEqualTo("ccc");
+
+            // Let's see that LMDB provides the keys in appropriate order....
+            c.seek(MDB_FIRST);
+            assertThat(UTF_8.decode(c.key()).toString()).isEqualTo("aaa");
+
+            c.seek(MDB_LAST);
+            assertThat(UTF_8.decode(c.key()).toString()).isEqualTo("zzz");
+
+            c.seek(MDB_PREV);
+            assertThat(UTF_8.decode(c.key()).toString()).isEqualTo("ccc");
+
+            // Cursors can also delete the current key.
+            c.delete();
+
+            c.close();
+            txn.commit();
+          }
+
+          // A read-only Cursor can survive its original Txn being closed. This is
+          // useful if you want to close the original Txn (eg maybe you created the
+          // Cursor during the constructor of a singleton with a throw-away Txn). Of
+          // course, you cannot use the Cursor if its Txn is closed or currently reset.
+          final Txn<ByteBuffer> tx1 = env.txnRead();
+          final Cursor<ByteBuffer> c = db.openCursor(tx1);
+          tx1.close();
+
+          // The Cursor becomes usable again by "renewing" it with an active read Txn.
+          final Txn<ByteBuffer> tx2 = env.txnRead();
+          c.renew(tx2);
+          c.seek(MDB_FIRST);
+
+          // As usual with read Txns, we can reset and renew them. The Cursor does
+          // not need any special handling if we do this.
+          tx2.reset();
+          // ... potentially long operation here ...
+          tx2.renew();
+          c.seek(MDB_LAST);
+
+          tx2.close();
+          env.close();
+        });
   }
 
   /**
    * In this fourth tutorial we'll take a quick look at the iterators. These are a more Java
    * idiomatic form of using the Cursors we looked at in tutorial 3.
-   *
-   * @throws IOException if a path was unavailable for memory mapping
    */
   @Test
-  public void tutorial4() throws IOException {
-    final Env<ByteBuffer> env = createSimpleEnv(tmp.newFolder());
-    final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
-
-    try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      final ByteBuffer key = allocateDirect(env.getMaxKeySize());
-      final ByteBuffer val = allocateDirect(700);
-
-      // Insert some data. Note that ByteBuffer order defaults to Big Endian.
-      // LMDB does not persist the byte order, but it's critical to sort keys.
-      // If your numeric keys don't sort as expected, review buffer byte order.
-      val.putInt(100);
-      key.putInt(1);
-      db.put(txn, key, val);
-      key.clear();
-      key.putInt(2);
-      db.put(txn, key, val);
-      key.clear();
-
-      // Each iterable uses a cursor and must be closed when finished. Iterate
-      // forward in terms of key ordering starting with the first key.
-      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-        for (final KeyVal<ByteBuffer> kv : ci) {
-          assertThat(kv.key(), notNullValue());
-          assertThat(kv.val(), notNullValue());
-        }
-      }
-
-      // Iterate backward in terms of key ordering starting with the last key.
-      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.allBackward())) {
-        for (final KeyVal<ByteBuffer> kv : ci) {
-          assertThat(kv.key(), notNullValue());
-          assertThat(kv.val(), notNullValue());
-        }
-      }
-
-      // There are many ways to control the desired key range via KeyRange, such
-      // as arbitrary start and stop values, direction etc. We've adopted Guava's
-      // terminology for our range classes (see KeyRangeType for further details).
-      key.putInt(1);
-      final KeyRange<ByteBuffer> range = KeyRange.atLeastBackward(key);
-      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, range)) {
-        for (final KeyVal<ByteBuffer> kv : ci) {
-          assertThat(kv.key(), notNullValue());
-          assertThat(kv.val(), notNullValue());
-        }
-      }
-    }
-
-    env.close();
+  void tutorial4() {
+    FileUtil.useTempDir(
+        dir -> {
+          final Env<ByteBuffer> env = createSimpleEnv(dir);
+          final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
+
+          try (Txn<ByteBuffer> txn = env.txnWrite()) {
+            final ByteBuffer key = allocateDirect(env.getMaxKeySize());
+            final ByteBuffer val = allocateDirect(700);
+
+            // Insert some data. Note that ByteBuffer order defaults to Big Endian.
+            // LMDB does not persist the byte order, but it's critical to sort keys.
+            // If your numeric keys don't sort as expected, review buffer byte order.
+            val.putInt(100);
+            key.putInt(1);
+            db.put(txn, key, val);
+            key.clear();
+            key.putInt(2);
+            db.put(txn, key, val);
+            key.clear();
+
+            // Each iterable uses a cursor and must be closed when finished. Iterate
+            // forward in terms of key ordering starting with the first key.
+            try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+              for (final KeyVal<ByteBuffer> kv : ci) {
+                assertThat(kv.key()).isNotNull();
+                assertThat(kv.val()).isNotNull();
+              }
+            }
+
+            // Iterate backward in terms of key ordering starting with the last key.
+            try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.allBackward())) {
+              for (final KeyVal<ByteBuffer> kv : ci) {
+                assertThat(kv.key()).isNotNull();
+                assertThat(kv.val()).isNotNull();
+              }
+            }
+
+            // There are many ways to control the desired key range via KeyRange, such
+            // as arbitrary start and stop values, direction etc. We've adopted Guava's
+            // terminology for our range classes (see KeyRangeType for further details).
+            key.putInt(1);
+            final KeyRange<ByteBuffer> range = KeyRange.atLeastBackward(key);
+            try (CursorIterable<ByteBuffer> ci = db.iterate(txn, range)) {
+              for (final KeyVal<ByteBuffer> kv : ci) {
+                assertThat(kv.key()).isNotNull();
+                assertThat(kv.val()).isNotNull();
+              }
+            }
+          }
+
+          env.close();
+        });
   }
 
-  /**
-   * In this fifth tutorial we'll explore multiple values sharing a single key.
-   *
-   * @throws IOException if a path was unavailable for memory mapping
-   */
+  /** In this fifth tutorial we'll explore multiple values sharing a single key. */
   @Test
-  public void tutorial5() throws IOException {
-    final Env<ByteBuffer> env = createSimpleEnv(tmp.newFolder());
-
-    // This time we're going to tell the Dbi it can store > 1 value per key.
-    // There are other flags available if we're storing integers etc.
-    final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE, MDB_DUPSORT);
-
-    // Duplicate support requires both keys and values to be <= max key size.
-    final ByteBuffer key = allocateDirect(env.getMaxKeySize());
-    final ByteBuffer val = allocateDirect(env.getMaxKeySize());
-
-    try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      final Cursor<ByteBuffer> c = db.openCursor(txn);
-
-      // Store one key, but many values, and in non-natural order.
-      key.put("key".getBytes(UTF_8)).flip();
-      val.put("xxx".getBytes(UTF_8)).flip();
-      c.put(key, val);
-      val.clear();
-      val.put("kkk".getBytes(UTF_8)).flip();
-      c.put(key, val);
-      val.clear();
-      val.put("lll".getBytes(UTF_8)).flip();
-      c.put(key, val);
-
-      // Cursor can tell us how many values the current key has.
-      final long count = c.count();
-      assertThat(count, is(3L));
-
-      // Let's position the Cursor. Note sorting still works.
-      c.seek(MDB_FIRST);
-      assertThat(UTF_8.decode(c.val()).toString(), is("kkk"));
-
-      c.seek(MDB_LAST);
-      assertThat(UTF_8.decode(c.val()).toString(), is("xxx"));
-
-      c.seek(MDB_PREV);
-      assertThat(UTF_8.decode(c.val()).toString(), is("lll"));
-
-      c.close();
-      txn.commit();
-    }
-
-    env.close();
+  void tutorial5() {
+    FileUtil.useTempDir(
+        dir -> {
+          final Env<ByteBuffer> env = createSimpleEnv(dir);
+
+          // This time we're going to tell the Dbi it can store > 1 value per key.
+          // There are other flags available if we're storing integers etc.
+          final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE, MDB_DUPSORT);
+
+          // Duplicate support requires both keys and values to be <= max key size.
+          final ByteBuffer key = allocateDirect(env.getMaxKeySize());
+          final ByteBuffer val = allocateDirect(env.getMaxKeySize());
+
+          try (Txn<ByteBuffer> txn = env.txnWrite()) {
+            final Cursor<ByteBuffer> c = db.openCursor(txn);
+
+            // Store one key, but many values, and in non-natural order.
+            key.put("key".getBytes(UTF_8)).flip();
+            val.put("xxx".getBytes(UTF_8)).flip();
+            c.put(key, val);
+            val.clear();
+            val.put("kkk".getBytes(UTF_8)).flip();
+            c.put(key, val);
+            val.clear();
+            val.put("lll".getBytes(UTF_8)).flip();
+            c.put(key, val);
+
+            // Cursor can tell us how many values the current key has.
+            final long count = c.count();
+            assertThat(count).isEqualTo(3L);
+
+            // Let's position the Cursor. Note sorting still works.
+            c.seek(MDB_FIRST);
+            assertThat(UTF_8.decode(c.val()).toString()).isEqualTo("kkk");
+
+            c.seek(MDB_LAST);
+            assertThat(UTF_8.decode(c.val()).toString()).isEqualTo("xxx");
+
+            c.seek(MDB_PREV);
+            assertThat(UTF_8.decode(c.val()).toString()).isEqualTo("lll");
+
+            c.close();
+            txn.commit();
+          }
+
+          env.close();
+        });
   }
 
   /**
    * Next up we'll show you how to easily check your platform (operating system and Java version) is
    * working properly with LmdbJava and the embedded LMDB native library.
-   *
-   * @throws IOException if a path was unavailable for memory mapping
    */
   @Test
-  public void tutorial6() throws IOException {
-    // Note we need to specify the Verifier's DBI_COUNT for the Env.
-    final Env<ByteBuffer> env =
-        create(PROXY_OPTIMAL)
-            .setMapSize(10_485_760)
-            .setMaxDbs(Verifier.DBI_COUNT)
-            .open(tmp.newFolder());
-
-    // Create a Verifier (it's a Callable<Long> for those needing full control).
-    final Verifier v = new Verifier(env);
-
-    // We now run the verifier for 3 seconds; it raises an exception on failure.
-    // The method returns the number of entries it successfully verified.
-    v.runFor(3, SECONDS);
-
-    env.close();
+  void tutorial6() {
+    FileUtil.useTempDir(
+        dir -> {
+          // Note we need to specify the Verifier's DBI_COUNT for the Env.
+          final Env<ByteBuffer> env =
+              create(PROXY_OPTIMAL)
+                  .setMapSize(10_485_760)
+                  .setMaxDbs(Verifier.DBI_COUNT)
+                  .open(dir.toFile());
+
+          // Create a Verifier (it's a Callable<Long> for those needing full control).
+          final Verifier v = new Verifier(env);
+
+          // We now run the verifier for 3 seconds; it raises an exception on failure.
+          // The method returns the number of entries it successfully verified.
+          v.runFor(3, SECONDS);
+
+          env.close();
+        });
   }
 
-  /**
-   * In this final tutorial we'll look at using Agrona's DirectBuffer.
-   *
-   * @throws IOException if a path was unavailable for memory mapping
-   */
+  /** In this final tutorial we'll look at using Agrona's DirectBuffer. */
   @Test
-  public void tutorial7() throws IOException {
-    // The critical difference is we pass the PROXY_DB field to Env.create().
-    // There's also a PROXY_SAFE if you want to stop ByteBuffer's Unsafe use.
-    // Aside from that and a different type argument, it's the same as usual...
-    final Env<DirectBuffer> env =
-        create(PROXY_DB).setMapSize(10_485_760).setMaxDbs(1).open(tmp.newFolder());
-
-    final Dbi<DirectBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
-
-    final ByteBuffer keyBb = allocateDirect(env.getMaxKeySize());
-    final MutableDirectBuffer key = new UnsafeBuffer(keyBb);
-    final MutableDirectBuffer val = new UnsafeBuffer(allocateDirect(700));
-
-    try (Txn<DirectBuffer> txn = env.txnWrite()) {
-      try (Cursor<DirectBuffer> c = db.openCursor(txn)) {
-        // Agrona is faster than ByteBuffer and its methods are nicer...
-        val.putStringWithoutLengthUtf8(0, "The Value");
-        key.putStringWithoutLengthUtf8(0, "yyy");
-        c.put(key, val);
-
-        key.putStringWithoutLengthUtf8(0, "ggg");
-        c.put(key, val);
-
-        c.seek(MDB_FIRST);
-        assertThat(c.key().getStringWithoutLengthUtf8(0, env.getMaxKeySize()), startsWith("ggg"));
-
-        c.seek(MDB_LAST);
-        assertThat(c.key().getStringWithoutLengthUtf8(0, env.getMaxKeySize()), startsWith("yyy"));
-
-        // DirectBuffer has no position concept. Often you don't want to store
-        // the unnecessary bytes of a varying-size buffer. Let's have a look...
-        final int keyLen = key.putStringWithoutLengthUtf8(0, "12characters");
-        assertThat(keyLen, is(12));
-        assertThat(key.capacity(), is(env.getMaxKeySize()));
-
-        // To only store the 12 characters, we simply call wrap:
-        key.wrap(key, 0, keyLen);
-        assertThat(key.capacity(), is(keyLen));
-        c.put(key, val);
-        c.seek(MDB_FIRST);
-        assertThat(c.key().capacity(), is(keyLen));
-        assertThat(c.key().getStringWithoutLengthUtf8(0, c.key().capacity()), is("12characters"));
-
-        // To store bigger values again, just wrap the original buffer.
-        key.wrap(keyBb);
-        assertThat(key.capacity(), is(env.getMaxKeySize()));
-      }
-      txn.commit();
-    }
-
-    env.close();
+  void tutorial7() {
+    FileUtil.useTempDir(
+        dir -> {
+          // The critical difference is we pass the PROXY_DB field to Env.create().
+          // There's also a PROXY_SAFE if you want to stop ByteBuffer's Unsafe use.
+          // Aside from that and a different type argument, it's the same as usual...
+          final Env<DirectBuffer> env =
+              create(PROXY_DB).setMapSize(10_485_760).setMaxDbs(1).open(dir.toFile());
+
+          final Dbi<DirectBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
+
+          final ByteBuffer keyBb = allocateDirect(env.getMaxKeySize());
+          final MutableDirectBuffer key = new UnsafeBuffer(keyBb);
+          final MutableDirectBuffer val = new UnsafeBuffer(allocateDirect(700));
+
+          try (Txn<DirectBuffer> txn = env.txnWrite()) {
+            try (Cursor<DirectBuffer> c = db.openCursor(txn)) {
+              // Agrona is faster than ByteBuffer and its methods are nicer...
+              val.putStringWithoutLengthUtf8(0, "The Value");
+              key.putStringWithoutLengthUtf8(0, "yyy");
+              c.put(key, val);
+
+              key.putStringWithoutLengthUtf8(0, "ggg");
+              c.put(key, val);
+
+              c.seek(MDB_FIRST);
+              assertThat(c.key().getStringWithoutLengthUtf8(0, env.getMaxKeySize()))
+                  .startsWith("ggg");
+
+              c.seek(MDB_LAST);
+              assertThat(c.key().getStringWithoutLengthUtf8(0, env.getMaxKeySize()))
+                  .startsWith("yyy");
+
+              // DirectBuffer has no position concept. Often you don't want to store
+              // the unnecessary bytes of a varying-size buffer. Let's have a look...
+              final int keyLen = key.putStringWithoutLengthUtf8(0, "12characters");
+              assertThat(keyLen).isEqualTo(12);
+              assertThat(key.capacity()).isEqualTo(env.getMaxKeySize());
+
+              // To only store the 12 characters, we simply call wrap:
+              key.wrap(key, 0, keyLen);
+              assertThat(key.capacity()).isEqualTo(keyLen);
+              c.put(key, val);
+              c.seek(MDB_FIRST);
+              assertThat(c.key().capacity()).isEqualTo(keyLen);
+              assertThat(c.key().getStringWithoutLengthUtf8(0, c.key().capacity()))
+                  .isEqualTo("12characters");
+
+              // To store bigger values again, just wrap the original buffer.
+              key.wrap(keyBb);
+              assertThat(key.capacity()).isEqualTo(env.getMaxKeySize());
+            }
+            txn.commit();
+          }
+
+          env.close();
+        });
   }
 
   // You've finished! There are lots of other neat things we could show you (eg
   // how to speed up inserts by appending them in key order, using integer
   // or reverse ordered keys, using Env.DISABLE_CHECKS_PROP etc), but you now
   // know enough to tackle the JavaDocs with confidence. Have fun!
-  private Env<ByteBuffer> createSimpleEnv(final File path) {
-    return create().setMapSize(10_485_760).setMaxDbs(1).setMaxReaders(1).open(path);
+  private Env<ByteBuffer> createSimpleEnv(final Path path) {
+    return create().setMapSize(10_485_760).setMaxDbs(1).setMaxReaders(1).open(path.toFile());
   }
 }
diff --git a/src/test/java/org/lmdbjava/TxnTest.java b/src/test/java/org/lmdbjava/TxnTest.java
index e768e424..46ffeb70 100644
--- a/src/test/java/org/lmdbjava/TxnTest.java
+++ b/src/test/java/org/lmdbjava/TxnTest.java
@@ -13,17 +13,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package org.lmdbjava;
 
 import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
 import static java.nio.ByteBuffer.allocateDirect;
 import static java.nio.charset.StandardCharsets.UTF_8;
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.CoreMatchers.not;
-import static org.hamcrest.CoreMatchers.notNullValue;
-import static org.hamcrest.CoreMatchers.nullValue;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
 import static org.lmdbjava.Env.create;
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
@@ -38,17 +35,15 @@
 import static org.lmdbjava.Txn.State.RESET;
 import static org.lmdbjava.TxnFlags.MDB_RDONLY_TXN;
 
-import java.io.File;
 import java.io.IOException;
 import java.nio.ByteBuffer;
+import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicLong;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 import org.lmdbjava.Dbi.BadValueSizeException;
 import org.lmdbjava.Env.AlreadyClosedException;
 import org.lmdbjava.Txn.EnvIsReadOnly;
@@ -62,36 +57,40 @@
 /** Test {@link Txn}. */
 public final class TxnTest {
 
-  @Rule public final TemporaryFolder tmp = new TemporaryFolder();
+  private Path file;
   private Env<ByteBuffer> env;
-  private File path;
 
-  @After
-  public void after() {
-    env.close();
-  }
-
-  @Before
-  public void before() throws IOException {
-    path = tmp.newFile();
+  @BeforeEach
+  void beforeEach() {
+    file = FileUtil.createTempFile();
     env =
         create()
             .setMapSize(KIBIBYTES.toBytes(256))
             .setMaxReaders(1)
             .setMaxDbs(2)
-            .open(path, POSIX_MODE, MDB_NOSUBDIR);
+            .open(file.toFile(), POSIX_MODE, MDB_NOSUBDIR);
   }
 
-  @Test(expected = BadValueSizeException.class)
-  public void largeKeysRejected() throws IOException {
-    final Dbi<ByteBuffer> dbi = env.openDbi(DB_1, MDB_CREATE);
-    final ByteBuffer key = allocateDirect(env.getMaxKeySize() + 1);
-    key.limit(key.capacity());
-    dbi.put(key, bb(2));
+  @AfterEach
+  void afterEach() {
+    env.close();
+    FileUtil.delete(file);
   }
 
   @Test
-  public void rangeSearch() {
+  void largeKeysRejected() throws IOException {
+    assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> dbi = env.openDbi(DB_1, MDB_CREATE);
+              final ByteBuffer key = allocateDirect(env.getMaxKeySize() + 1);
+              key.limit(key.capacity());
+              dbi.put(key, bb(2));
+            })
+        .isInstanceOf(BadValueSizeException.class);
+  }
+
+  @Test
+  void rangeSearch() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
 
     final ByteBuffer key = allocateDirect(env.getMaxKeySize());
@@ -120,53 +119,69 @@ public void rangeSearch() {
         }
       }
 
-      assertEquals(3, keysFound.size());
+      assertThat(keysFound.size()).isEqualTo(3);
     }
   }
 
   @Test
-  public void readOnlyTxnAllowedInReadOnlyEnv() {
+  void readOnlyTxnAllowedInReadOnlyEnv() {
     env.openDbi(DB_1, MDB_CREATE);
     try (Env<ByteBuffer> roEnv =
-        create().setMaxReaders(1).open(path, MDB_NOSUBDIR, MDB_RDONLY_ENV)) {
-      assertThat(roEnv.txnRead(), is(notNullValue()));
+        create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR, MDB_RDONLY_ENV)) {
+      assertThat(roEnv.txnRead()).isNotNull();
     }
   }
 
-  @Test(expected = EnvIsReadOnly.class)
-  public void readWriteTxnDeniedInReadOnlyEnv() {
-    env.openDbi(DB_1, MDB_CREATE);
-    env.close();
-    try (Env<ByteBuffer> roEnv =
-        create().setMaxReaders(1).open(path, MDB_NOSUBDIR, MDB_RDONLY_ENV)) {
-      roEnv.txnWrite(); // error
-    }
+  @Test
+  void readWriteTxnDeniedInReadOnlyEnv() {
+    assertThatThrownBy(
+            () -> {
+              env.openDbi(DB_1, MDB_CREATE);
+              env.close();
+              try (Env<ByteBuffer> roEnv =
+                  create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR, MDB_RDONLY_ENV)) {
+                roEnv.txnWrite(); // error
+              }
+            })
+        .isInstanceOf(EnvIsReadOnly.class);
   }
 
-  @Test(expected = NotReadyException.class)
-  public void testCheckNotCommitted() {
-    try (Txn<ByteBuffer> txn = env.txnRead()) {
-      txn.commit();
-      txn.checkReady();
-    }
+  @Test
+  void testCheckNotCommitted() {
+    assertThatThrownBy(
+            () -> {
+              try (Txn<ByteBuffer> txn = env.txnRead()) {
+                txn.commit();
+                txn.checkReady();
+              }
+            })
+        .isInstanceOf(NotReadyException.class);
   }
 
-  @Test(expected = ReadOnlyRequiredException.class)
-  public void testCheckReadOnly() {
-    try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      txn.checkReadOnly();
-    }
+  @Test
+  void testCheckReadOnly() {
+    assertThatThrownBy(
+            () -> {
+              try (Txn<ByteBuffer> txn = env.txnWrite()) {
+                txn.checkReadOnly();
+              }
+            })
+        .isInstanceOf(ReadOnlyRequiredException.class);
   }
 
-  @Test(expected = ReadWriteRequiredException.class)
-  public void testCheckWritesAllowed() {
-    try (Txn<ByteBuffer> txn = env.txnRead()) {
-      txn.checkWritesAllowed();
-    }
+  @Test
+  void testCheckWritesAllowed() {
+    assertThatThrownBy(
+            () -> {
+              try (Txn<ByteBuffer> txn = env.txnRead()) {
+                txn.checkWritesAllowed();
+              }
+            })
+        .isInstanceOf(ReadWriteRequiredException.class);
   }
 
   @Test
-  public void testGetId() {
+  void testGetId() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
 
     final AtomicLong txId1 = new AtomicLong();
@@ -182,173 +197,233 @@ public void testGetId() {
       txId2.set(tx2.getId());
     }
     // should not see the same snapshot
-    assertThat(txId1.get(), is(not(txId2.get())));
+    assertThat(txId1.get()).isNotEqualTo(txId2.get());
   }
 
   @Test
-  public void txCanCommitThenCloseWithoutError() {
+  void txCanCommitThenCloseWithoutError() {
     try (Txn<ByteBuffer> txn = env.txnRead()) {
-      assertThat(txn.getState(), is(READY));
+      assertThat(txn.getState()).isEqualTo(READY);
       txn.commit();
-      assertThat(txn.getState(), is(DONE));
+      assertThat(txn.getState()).isEqualTo(DONE);
     }
   }
 
-  @Test(expected = NotReadyException.class)
-  public void txCannotAbortIfAlreadyCommitted() {
-    try (Txn<ByteBuffer> txn = env.txnRead()) {
-      assertThat(txn.getState(), is(READY));
-      txn.commit();
-      assertThat(txn.getState(), is(DONE));
-      txn.abort();
-    }
+  @Test
+  void txCannotAbortIfAlreadyCommitted() {
+    assertThatThrownBy(
+            () -> {
+              try (Txn<ByteBuffer> txn = env.txnRead()) {
+                assertThat(txn.getState()).isEqualTo(READY);
+                txn.commit();
+                assertThat(txn.getState()).isEqualTo(DONE);
+                txn.abort();
+              }
+            })
+        .isInstanceOf(NotReadyException.class);
   }
 
-  @Test(expected = NotReadyException.class)
-  public void txCannotCommitTwice() {
-    try (Txn<ByteBuffer> txn = env.txnRead()) {
-      txn.commit();
-      txn.commit(); // error
-    }
+  @Test
+  void txCannotCommitTwice() {
+    assertThatThrownBy(
+            () -> {
+              try (Txn<ByteBuffer> txn = env.txnRead()) {
+                txn.commit();
+                txn.commit(); // error
+              }
+            })
+        .isInstanceOf(NotReadyException.class);
   }
 
-  @Test(expected = AlreadyClosedException.class)
-  public void txConstructionDeniedIfEnvClosed() {
-    env.close();
-    env.txnRead();
+  @Test
+  void txConstructionDeniedIfEnvClosed() {
+    assertThatThrownBy(
+            () -> {
+              env.close();
+              env.txnRead();
+            })
+        .isInstanceOf(AlreadyClosedException.class);
   }
 
-  @Test(expected = AlreadyClosedException.class)
-  public void txRenewDeniedIfEnvClosed() {
-    final Txn<ByteBuffer> txnRead = env.txnRead();
-    txnRead.close();
-    env.close();
-    txnRead.renew();
+  @Test
+  void txRenewDeniedIfEnvClosed() {
+    assertThatThrownBy(
+            () -> {
+              final Txn<ByteBuffer> txnRead = env.txnRead();
+              txnRead.close();
+              env.close();
+              txnRead.renew();
+            })
+        .isInstanceOf(AlreadyClosedException.class);
   }
 
-  @Test(expected = AlreadyClosedException.class)
-  public void txCloseDeniedIfEnvClosed() {
-    final Txn<ByteBuffer> txnRead = env.txnRead();
-    env.close();
-    txnRead.close();
+  @Test
+  void txCloseDeniedIfEnvClosed() {
+    assertThatThrownBy(
+            () -> {
+              final Txn<ByteBuffer> txnRead = env.txnRead();
+              env.close();
+              txnRead.close();
+            })
+        .isInstanceOf(AlreadyClosedException.class);
   }
 
-  @Test(expected = AlreadyClosedException.class)
-  public void txCommitDeniedIfEnvClosed() {
-    final Txn<ByteBuffer> txnRead = env.txnRead();
-    env.close();
-    txnRead.commit();
+  @Test
+  void txCommitDeniedIfEnvClosed() {
+    assertThatThrownBy(
+            () -> {
+              final Txn<ByteBuffer> txnRead = env.txnRead();
+              env.close();
+              txnRead.commit();
+            })
+        .isInstanceOf(AlreadyClosedException.class);
   }
 
-  @Test(expected = AlreadyClosedException.class)
-  public void txAbortDeniedIfEnvClosed() {
-    final Txn<ByteBuffer> txnRead = env.txnRead();
-    env.close();
-    txnRead.abort();
+  @Test
+  void txAbortDeniedIfEnvClosed() {
+    assertThatThrownBy(
+            () -> {
+              final Txn<ByteBuffer> txnRead = env.txnRead();
+              env.close();
+              txnRead.abort();
+            })
+        .isInstanceOf(AlreadyClosedException.class);
   }
 
-  @Test(expected = AlreadyClosedException.class)
-  public void txResetDeniedIfEnvClosed() {
-    final Txn<ByteBuffer> txnRead = env.txnRead();
-    env.close();
-    txnRead.reset();
+  @Test
+  void txResetDeniedIfEnvClosed() {
+    assertThatThrownBy(
+            () -> {
+              final Txn<ByteBuffer> txnRead = env.txnRead();
+              env.close();
+              txnRead.reset();
+            })
+        .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   public void txParent() {
     try (Txn<ByteBuffer> txRoot = env.txnWrite();
         Txn<ByteBuffer> txChild = env.txn(txRoot)) {
-      assertThat(txRoot.getParent(), is(nullValue()));
-      assertThat(txChild.getParent(), is(txRoot));
+      assertThat(txRoot.getParent()).isNull();
+      assertThat(txChild.getParent()).isEqualTo(txRoot);
     }
   }
 
-  @Test(expected = AlreadyClosedException.class)
-  public void txParentDeniedIfEnvClosed() {
-    try (Txn<ByteBuffer> txRoot = env.txnWrite();
-        Txn<ByteBuffer> txChild = env.txn(txRoot)) {
-      env.close();
-      assertThat(txChild.getParent(), is(txRoot));
-    }
+  @Test
+  void txParentDeniedIfEnvClosed() {
+    assertThatThrownBy(
+            () -> {
+              try (Txn<ByteBuffer> txRoot = env.txnWrite();
+                  Txn<ByteBuffer> txChild = env.txn(txRoot)) {
+                env.close();
+                assertThat(txChild.getParent()).isEqualTo(txRoot);
+              }
+            })
+        .isInstanceOf(AlreadyClosedException.class);
   }
 
-  @Test(expected = IncompatibleParent.class)
-  public void txParentROChildRWIncompatible() {
-    try (Txn<ByteBuffer> txRoot = env.txnRead()) {
-      env.txn(txRoot); // error
-    }
+  @Test
+  void txParentROChildRWIncompatible() {
+    assertThatThrownBy(
+            () -> {
+              try (Txn<ByteBuffer> txRoot = env.txnRead()) {
+                env.txn(txRoot); // error
+              }
+            })
+        .isInstanceOf(IncompatibleParent.class);
   }
 
-  @Test(expected = IncompatibleParent.class)
-  public void txParentRWChildROIncompatible() {
-    try (Txn<ByteBuffer> txRoot = env.txnWrite()) {
-      env.txn(txRoot, MDB_RDONLY_TXN); // error
-    }
+  @Test
+  void txParentRWChildROIncompatible() {
+    assertThatThrownBy(
+            () -> {
+              try (Txn<ByteBuffer> txRoot = env.txnWrite()) {
+                env.txn(txRoot, MDB_RDONLY_TXN); // error
+              }
+            })
+        .isInstanceOf(IncompatibleParent.class);
   }
 
   @Test
-  public void txReadOnly() {
+  void txReadOnly() {
     try (Txn<ByteBuffer> txn = env.txnRead()) {
-      assertThat(txn.getParent(), is(nullValue()));
-      assertThat(txn.getState(), is(READY));
-      assertThat(txn.isReadOnly(), is(true));
+      assertThat(txn.getParent()).isNull();
+      assertThat(txn.getState()).isEqualTo(READY);
+      assertThat(txn.isReadOnly()).isTrue();
       txn.checkReady();
       txn.checkReadOnly();
       txn.reset();
-      assertThat(txn.getState(), is(RESET));
+      assertThat(txn.getState()).isEqualTo(RESET);
       txn.renew();
-      assertThat(txn.getState(), is(READY));
+      assertThat(txn.getState()).isEqualTo(READY);
       txn.commit();
-      assertThat(txn.getState(), is(DONE));
+      assertThat(txn.getState()).isEqualTo(DONE);
       txn.close();
-      assertThat(txn.getState(), is(RELEASED));
+      assertThat(txn.getState()).isEqualTo(RELEASED);
     }
   }
 
   @Test
-  public void txReadWrite() {
+  void txReadWrite() {
     final Txn<ByteBuffer> txn = env.txnWrite();
-    assertThat(txn.getParent(), is(nullValue()));
-    assertThat(txn.getState(), is(READY));
-    assertThat(txn.isReadOnly(), is(false));
+    assertThat(txn.getParent()).isNull();
+    assertThat(txn.getState()).isEqualTo(READY);
+    assertThat(txn.isReadOnly()).isFalse();
     txn.checkReady();
     txn.checkWritesAllowed();
     txn.commit();
-    assertThat(txn.getState(), is(DONE));
+    assertThat(txn.getState()).isEqualTo(DONE);
     txn.close();
-    assertThat(txn.getState(), is(RELEASED));
+    assertThat(txn.getState()).isEqualTo(RELEASED);
   }
 
-  @Test(expected = NotResetException.class)
-  public void txRenewDeniedWithoutPriorReset() {
-    try (Txn<ByteBuffer> txn = env.txnRead()) {
-      txn.renew();
-    }
+  @Test
+  void txRenewDeniedWithoutPriorReset() {
+    assertThatThrownBy(
+            () -> {
+              try (Txn<ByteBuffer> txn = env.txnRead()) {
+                txn.renew();
+              }
+            })
+        .isInstanceOf(NotResetException.class);
   }
 
-  @Test(expected = ResetException.class)
-  public void txResetDeniedForAlreadyResetTransaction() {
-    try (Txn<ByteBuffer> txn = env.txnRead()) {
-      txn.reset();
-      txn.renew();
-      txn.reset();
-      txn.reset();
-    }
+  @Test
+  void txResetDeniedForAlreadyResetTransaction() {
+    assertThatThrownBy(
+            () -> {
+              try (Txn<ByteBuffer> txn = env.txnRead()) {
+                txn.reset();
+                txn.renew();
+                txn.reset();
+                txn.reset();
+              }
+            })
+        .isInstanceOf(ResetException.class);
   }
 
-  @Test(expected = ReadOnlyRequiredException.class)
-  public void txResetDeniedForReadWriteTransaction() {
-    try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      txn.reset();
-    }
+  @Test
+  void txResetDeniedForReadWriteTransaction() {
+    assertThatThrownBy(
+            () -> {
+              try (Txn<ByteBuffer> txn = env.txnWrite()) {
+                txn.reset();
+              }
+            })
+        .isInstanceOf(ReadOnlyRequiredException.class);
   }
 
-  @Test(expected = BadValueSizeException.class)
-  public void zeroByteKeysRejected() throws IOException {
-    final Dbi<ByteBuffer> dbi = env.openDbi(DB_1, MDB_CREATE);
-    final ByteBuffer key = allocateDirect(4);
-    key.putInt(1);
-    assertThat(key.remaining(), is(0)); // because key.flip() skipped
-    dbi.put(key, bb(2));
+  @Test
+  void zeroByteKeysRejected() {
+    assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> dbi = env.openDbi(DB_1, MDB_CREATE);
+              final ByteBuffer key = allocateDirect(4);
+              key.putInt(1);
+              assertThat(key.remaining()).isEqualTo(0); // because key.flip() skipped
+              dbi.put(key, bb(2));
+            })
+        .isInstanceOf(BadValueSizeException.class);
   }
 }
diff --git a/src/test/java/org/lmdbjava/VerifierTest.java b/src/test/java/org/lmdbjava/VerifierTest.java
index c57e26dc..64214568 100644
--- a/src/test/java/org/lmdbjava/VerifierTest.java
+++ b/src/test/java/org/lmdbjava/VerifierTest.java
@@ -13,39 +13,35 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package org.lmdbjava;
 
 import static com.jakewharton.byteunits.BinaryByteUnit.MEBIBYTES;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.greaterThan;
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.lmdbjava.Env.create;
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
 
-import java.io.File;
-import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.util.concurrent.TimeUnit;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
+import org.junit.jupiter.api.Test;
 
 /** Test {@link Verifier}. */
 public final class VerifierTest {
 
-  @Rule public final TemporaryFolder tmp = new TemporaryFolder();
-
   @Test
-  public void verification() throws IOException {
-    final File path = tmp.newFile();
-    try (Env<ByteBuffer> env =
-        create()
-            .setMaxReaders(1)
-            .setMaxDbs(Verifier.DBI_COUNT)
-            .setMapSize(MEBIBYTES.toBytes(10))
-            .open(path, MDB_NOSUBDIR)) {
-      final Verifier v = new Verifier(env);
-      final int seconds = Integer.getInteger("verificationSeconds", 2);
-      assertThat(v.runFor(seconds, TimeUnit.SECONDS), greaterThan(1L));
-    }
+  void verification() {
+    FileUtil.useTempFile(
+        file -> {
+          try (Env<ByteBuffer> env =
+              create()
+                  .setMaxReaders(1)
+                  .setMaxDbs(Verifier.DBI_COUNT)
+                  .setMapSize(MEBIBYTES.toBytes(10))
+                  .open(file.toFile(), MDB_NOSUBDIR)) {
+            final Verifier v = new Verifier(env);
+            final int seconds = Integer.getInteger("verificationSeconds", 2);
+            assertThat(v.runFor(seconds, TimeUnit.SECONDS)).isGreaterThan(1L);
+          }
+        });
   }
 }

From 1b3f94df197b0889e6612418d3a43a9f496ee452 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Tue, 28 Oct 2025 18:21:58 +0000
Subject: [PATCH 233/322] Change CursorIterableTest to use Parameterized

---
 .../java/org/lmdbjava/CursorIterableTest.java | 205 ++++++++++--------
 src/test/java/org/lmdbjava/TestUtils.java     |   1 +
 2 files changed, 116 insertions(+), 90 deletions(-)

diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index 79a9a34c..bf2eb9eb 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -45,6 +45,7 @@
 import static org.lmdbjava.TestUtils.DB_1;
 import static org.lmdbjava.TestUtils.DB_2;
 import static org.lmdbjava.TestUtils.DB_3;
+import static org.lmdbjava.TestUtils.DB_4;
 import static org.lmdbjava.TestUtils.POSIX_MODE;
 import static org.lmdbjava.TestUtils.bb;
 
@@ -59,25 +60,83 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.NoSuchElementException;
+import java.util.function.Function;
 import org.hamcrest.Matchers;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
 import org.lmdbjava.CursorIterable.KeyVal;
 
-/** Test {@link CursorIterable}. */
+/**
+ * Test {@link CursorIterable}.
+ */
+@RunWith(Parameterized.class)
 public final class CursorIterableTest {
 
-  @Rule public final TemporaryFolder tmp = new TemporaryFolder();
-  private Dbi<ByteBuffer> dbJavaComparator;
-  private Dbi<ByteBuffer> dbLmdbComparator;
-  private Dbi<ByteBuffer> dbCallbackComparator;
-  private List<Dbi<ByteBuffer>> dbs = new ArrayList<>();
+  private static final DbiFlagSet dbiFlagSet = MDB_CREATE;
+  private static final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
+
+  @Rule
+  public final TemporaryFolder tmp = new TemporaryFolder();
+
   private Env<ByteBuffer> env;
   private Deque<Integer> list;
 
+  /** Injected by {@link #data()} with appropriate runner. */
+  @Parameterized.Parameter
+  public DbiFactory dbiFactory;
+
+  @Before
+  public void before() throws IOException {
+    final File path = tmp.newFile();
+    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
+    env =
+        create(bufferProxy)
+            .setMapSize(KIBIBYTES.toBytes(256))
+            .setMaxReaders(1)
+            .setMaxDbs(3)
+            .open(path, POSIX_MODE, MDB_NOSUBDIR);
+
+    populateTestDataList();
+  }
+
+  @Parameterized.Parameters(name = "{index}: dbi: {0}")
+  public static Object[] data() {
+    final DbiFactory defaultComparator = new DbiFactory("defaultComparator", env ->
+        env.buildDbi()
+            .withDbName(DB_1)
+            .withDefaultComparator()
+            .withDbiFlags(dbiFlagSet)
+            .open());
+    final DbiFactory nativeComparator = new DbiFactory("nativeComparator", env ->
+        env.buildDbi()
+            .withDbName(DB_2)
+            .withNativeComparator()
+            .withDbiFlags(dbiFlagSet)
+            .open());
+    final DbiFactory callbackComparator = new DbiFactory("callbackComparator", env ->
+        env.buildDbi()
+            .withDbName(DB_3)
+            .withCallbackComparator(bufferProxy.getComparator(dbiFlagSet))
+            .withDbiFlags(dbiFlagSet)
+            .open());
+    final DbiFactory iteratorComparator = new DbiFactory("iteratorComparator", env ->
+        env.buildDbi()
+            .withDbName(DB_4)
+            .withIteratorComparator(bufferProxy.getComparator(dbiFlagSet))
+            .withDbiFlags(dbiFlagSet)
+            .open());
+    return new Object[] {
+        defaultComparator,
+        nativeComparator,
+        callbackComparator,
+        iteratorComparator};
+  }
+
   @After
   public void after() {
     env.close();
@@ -118,49 +177,8 @@ public void atMostTest() {
     verify(atMost(bb(6)), 2, 4, 6);
   }
 
-  @Before
-  public void before() throws IOException {
-    final File path = tmp.newFile();
-    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
-    env =
-        create(bufferProxy)
-            .setMapSize(KIBIBYTES.toBytes(256))
-            .setMaxReaders(1)
-            .setMaxDbs(3)
-            .open(path, POSIX_MODE, MDB_NOSUBDIR);
 
-    final DbiFlagSet dbiFlagSet = MDB_CREATE;
-    // Use a java comparator for start/stop keys only
-    dbJavaComparator = env.buildDbi()
-        .withDbName(DB_1)
-        .withDefaultComparator()
-        .withDbiFlags(dbiFlagSet)
-        .open();
-    // Use LMDB comparator for start/stop keys
-    dbLmdbComparator = env.buildDbi()
-        .withDbName(DB_2)
-        .withNativeComparator()
-        .withDbiFlags(dbiFlagSet)
-        .open();
-    // Use a java comparator for start/stop keys and as a callback comparaotr
-    dbCallbackComparator = env.buildDbi()
-        .withDbName(DB_3)
-        .withCallbackComparator(bufferProxy.getComparator(dbiFlagSet))
-        .withDbiFlags(dbiFlagSet)
-        .open();
-
-    populateList();
-
-    populateDatabase(dbJavaComparator);
-    populateDatabase(dbLmdbComparator);
-    populateDatabase(dbCallbackComparator);
-
-    dbs.add(dbJavaComparator);
-    dbs.add(dbLmdbComparator);
-    dbs.add(dbCallbackComparator);
-  }
-
-  private void populateList() {
+  private void populateTestDataList() {
     list = new LinkedList<>();
     list.addAll(asList(2, 3, 4, 5, 6, 7, 8, 9));
   }
@@ -203,14 +221,6 @@ public void closedTest() {
     verify(closed(bb(1), bb(7)), 2, 4, 6);
   }
 
-  public void closedTest1() {
-    verify(dbLmdbComparator, closed(bb(3), bb(7)), 4, 6);
-  }
-
-  public void closedTest2() {
-    verify(dbJavaComparator, closed(bb(3), bb(7)), 4, 6);
-  }
-
   @Test
   public void greaterThanBackwardTest() {
     verify(greaterThanBackward(bb(6)), 4, 2);
@@ -226,21 +236,19 @@ public void greaterThanTest() {
 
   @Test(expected = IllegalStateException.class)
   public void iterableOnlyReturnedOnce() {
-    for (final Dbi<ByteBuffer> db : dbs) {
-      try (Txn<ByteBuffer> txn = env.txnRead();
-          CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+    final Dbi<ByteBuffer> db = getDb();
+    try (Txn<ByteBuffer> txn = env.txnRead();
+           CursorIterable<ByteBuffer> c = db.iterate(txn)) {
         c.iterator(); // ok
         c.iterator(); // fails
       }
-    }
   }
 
   @Test
   public void iterate() {
-    for (final Dbi<ByteBuffer> db : dbs) {
-      populateList();
+    final Dbi<ByteBuffer> db = getDb();
       try (Txn<ByteBuffer> txn = env.txnRead();
-          CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+           CursorIterable<ByteBuffer> c = db.iterate(txn)) {
 
         int cnt = 0;
         for (final KeyVal<ByteBuffer> kv : c) {
@@ -248,18 +256,16 @@ public void iterate() {
           assertThat(kv.val().getInt(), is(list.pollFirst()));
         }
       }
-    }
   }
 
   @Test(expected = IllegalStateException.class)
   public void iteratorOnlyReturnedOnce() {
-    for (final Dbi<ByteBuffer> db : dbs) {
+    final Dbi<ByteBuffer> db = getDb();
       try (Txn<ByteBuffer> txn = env.txnRead();
-          CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+           CursorIterable<ByteBuffer> c = db.iterate(txn)) {
         c.iterator(); // ok
         c.iterator(); // fails
       }
-    }
   }
 
   @Test
@@ -276,10 +282,10 @@ public void lessThanTest() {
 
   @Test(expected = NoSuchElementException.class)
   public void nextThrowsNoSuchElementExceptionIfNoMoreElements() {
-    for (final Dbi<ByteBuffer> db : dbs) {
-      populateList();
+    final Dbi<ByteBuffer> db = getDb();
+      populateTestDataList();
       try (Txn<ByteBuffer> txn = env.txnRead();
-          CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+           CursorIterable<ByteBuffer> c = db.iterate(txn)) {
         final Iterator<KeyVal<ByteBuffer>> i = c.iterator();
         while (i.hasNext()) {
           final KeyVal<ByteBuffer> kv = i.next();
@@ -289,7 +295,6 @@ public void nextThrowsNoSuchElementExceptionIfNoMoreElements() {
         assertThat(i.hasNext(), is(false));
         i.next();
       }
-    }
   }
 
   @Test
@@ -341,8 +346,8 @@ public void openTest() {
 
   @Test
   public void removeOddElements() {
-    for (final Dbi<ByteBuffer> db : dbs) {
-      verify(db, all(), 2, 4, 6, 8);
+    final Dbi<ByteBuffer> db = getDb();
+    verify(db, all(), 2, 4, 6, 8);
       int idx = -1;
       try (Txn<ByteBuffer> txn = env.txnWrite()) {
         try (CursorIterable<ByteBuffer> ci = db.iterate(txn)) {
@@ -358,12 +363,11 @@ public void removeOddElements() {
         txn.commit();
       }
       verify(db, all(), 4, 8);
-    }
   }
 
   @Test(expected = Env.AlreadyClosedException.class)
   public void nextWithClosedEnvTest() {
-    for (final Dbi<ByteBuffer> db : dbs) {
+    final Dbi<ByteBuffer> db = getDb();
       try (Txn<ByteBuffer> txn = env.txnRead()) {
         try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
           final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
@@ -372,12 +376,11 @@ public void nextWithClosedEnvTest() {
           c.next();
         }
       }
-    }
   }
 
   @Test(expected = Env.AlreadyClosedException.class)
   public void removeWithClosedEnvTest() {
-    for (final Dbi<ByteBuffer> db : dbs) {
+    final Dbi<ByteBuffer> db = getDb();
       try (Txn<ByteBuffer> txn = env.txnWrite()) {
         try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
           final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
@@ -389,12 +392,11 @@ public void removeWithClosedEnvTest() {
           c.remove();
         }
       }
-    }
   }
 
   @Test(expected = Env.AlreadyClosedException.class)
   public void hasNextWithClosedEnvTest() {
-    for (final Dbi<ByteBuffer> db : dbs) {
+    final Dbi<ByteBuffer> db = getDb();
       try (Txn<ByteBuffer> txn = env.txnRead()) {
         try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
           final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
@@ -403,21 +405,20 @@ public void hasNextWithClosedEnvTest() {
           c.hasNext();
         }
       }
-    }
   }
 
   @Test(expected = Env.AlreadyClosedException.class)
   public void forEachRemainingWithClosedEnvTest() {
-    for (final Dbi<ByteBuffer> db : dbs) {
+    final Dbi<ByteBuffer> db = getDb();
       try (Txn<ByteBuffer> txn = env.txnRead()) {
         try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
           final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
 
           env.close();
-          c.forEachRemaining(keyVal -> {});
+          c.forEachRemaining(keyVal -> {
+          });
         }
       }
-    }
   }
 
 //  @Test
@@ -468,10 +469,8 @@ public void forEachRemainingWithClosedEnvTest() {
 //  }
 
   private void verify(final KeyRange<ByteBuffer> range, final int... expected) {
-    // Verify using all comparator types
-    for (final Dbi<ByteBuffer> db : dbs) {
-      verify(range, db, expected);
-    }
+    final Dbi<ByteBuffer> db = getDb();
+    verify(range, db, expected);
   }
 
   private void verify(
@@ -479,13 +478,14 @@ private void verify(
     verify(range, dbi, expected);
   }
 
-  private void verify(
-      final KeyRange<ByteBuffer> range, final Dbi<ByteBuffer> dbi, final int... expected) {
+  private void verify(final KeyRange<ByteBuffer> range,
+                      final Dbi<ByteBuffer> dbi,
+                      final int... expected) {
 
     final List<Integer> results = new ArrayList<>();
 
     try (Txn<ByteBuffer> txn = env.txnRead();
-        CursorIterable<ByteBuffer> c = dbi.iterate(txn, range)) {
+         CursorIterable<ByteBuffer> c = dbi.iterate(txn, range)) {
       for (final KeyVal<ByteBuffer> kv : c) {
         final int key = kv.key().getInt();
         final int val = kv.val().getInt();
@@ -499,4 +499,29 @@ private void verify(
       assertThat(results.get(idx), is(expected[idx]));
     }
   }
+
+  private Dbi<ByteBuffer> getDb() {
+    final Dbi<ByteBuffer> dbi = dbiFactory.factory.apply(env);
+    populateDatabase(dbi);
+    return dbi;
+  }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  private static class DbiFactory {
+    private final String name;
+    private final Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory;
+
+    private DbiFactory(String name, Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory) {
+      this.name = name;
+      this.factory = factory;
+    }
+
+    @Override
+    public String toString() {
+      return name;
+    }
+  }
 }
diff --git a/src/test/java/org/lmdbjava/TestUtils.java b/src/test/java/org/lmdbjava/TestUtils.java
index bc9561ed..c26c1c52 100644
--- a/src/test/java/org/lmdbjava/TestUtils.java
+++ b/src/test/java/org/lmdbjava/TestUtils.java
@@ -33,6 +33,7 @@ final class TestUtils {
   public static final String DB_1 = "test-db-1";
   public static final String DB_2 = "test-db-2";
   public static final String DB_3 = "test-db-3";
+  public static final String DB_4 = "test-db-2";
 
   public static final int POSIX_MODE = 0664;
 

From 05314e8b2bdda8cb71d68eb9c7baeeffe60788fe Mon Sep 17 00:00:00 2001
From: stroomdev66 <stroomdev66@gmail.com>
Date: Tue, 28 Oct 2025 18:32:38 +0000
Subject: [PATCH 234/322] Upgrade to JUnit 5 and replace Hamcrest with AssertJ

---
 src/test/java/org/lmdbjava/DbiTest.java | 79 +++++++++++--------------
 1 file changed, 34 insertions(+), 45 deletions(-)

diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 844a819e..23b6790e 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -29,20 +29,14 @@
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
 import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
-import static org.lmdbjava.DbiFlags.MDB_CREATE;
-import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
-import static org.lmdbjava.DbiFlags.MDB_INTEGERKEY;
-import static org.lmdbjava.DbiFlags.MDB_REVERSEKEY;
+import static org.lmdbjava.DbiFlags.*;
 import static org.lmdbjava.Env.create;
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
 import static org.lmdbjava.GetOp.MDB_SET_KEY;
 import static org.lmdbjava.KeyRange.atMost;
 import static org.lmdbjava.PutFlags.MDB_NODUPDATA;
 import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
-import static org.lmdbjava.TestUtils.DB_1;
-import static org.lmdbjava.TestUtils.ba;
-import static org.lmdbjava.TestUtils.bb;
-import static org.lmdbjava.TestUtils.fromBa;
+import static org.lmdbjava.TestUtils.*;
 
 import java.nio.ByteBuffer;
 import java.nio.file.Path;
@@ -50,11 +44,7 @@
 import java.util.Comparator;
 import java.util.Iterator;
 import java.util.List;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.Future;
-import java.util.concurrent.TimeoutException;
+import java.util.concurrent.*;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.BiConsumer;
 import java.util.function.Function;
@@ -197,44 +187,43 @@ private <T> void doDbiWithComparatorThreadSafety(
 
     final List<Integer> keys = range(0, 1_000).boxed().collect(toList());
 
-    try (final ExecutorService pool = Executors.newCachedThreadPool()) {
-      final AtomicBoolean proceed = new AtomicBoolean(true);
-      final Future<?> reader =
-          pool.submit(
-              () -> {
-                while (proceed.get()) {
-                  try (Txn<T> txn = env.txnRead()) {
-                    db.get(txn, serializer.apply(50));
-                  }
+    final ExecutorService pool = Executors.newCachedThreadPool();
+    final AtomicBoolean proceed = new AtomicBoolean(true);
+    final Future<?> reader =
+        pool.submit(
+            () -> {
+              while (proceed.get()) {
+                try (Txn<T> txn = env.txnRead()) {
+                  db.get(txn, serializer.apply(50));
                 }
-              });
+              }
+            });
 
-      for (final Integer key : keys) {
-        try (Txn<T> txn = env.txnWrite()) {
-          db.put(txn, serializer.apply(key), serializer.apply(3));
-          txn.commit();
-        }
+    for (final Integer key : keys) {
+      try (Txn<T> txn = env.txnWrite()) {
+        db.put(txn, serializer.apply(key), serializer.apply(3));
+        txn.commit();
       }
+    }
 
-      try (Txn<T> txn = env.txnRead();
-          CursorIterable<T> ci = db.iterate(txn)) {
-        final Iterator<KeyVal<T>> iter = ci.iterator();
-        final List<Integer> result = new ArrayList<>();
-        while (iter.hasNext()) {
-          result.add(deserializer.applyAsInt(iter.next().key()));
-        }
-
-        assertThat(result).contains(keys.toArray(new Integer[0]));
+    try (Txn<T> txn = env.txnRead();
+        CursorIterable<T> ci = db.iterate(txn)) {
+      final Iterator<KeyVal<T>> iter = ci.iterator();
+      final List<Integer> result = new ArrayList<>();
+      while (iter.hasNext()) {
+        result.add(deserializer.applyAsInt(iter.next().key()));
       }
 
-      proceed.set(false);
-      try {
-        reader.get(1, SECONDS);
-        pool.shutdown();
-        pool.awaitTermination(1, SECONDS);
-      } catch (ExecutionException | InterruptedException | TimeoutException e) {
-        throw new IllegalStateException(e);
-      }
+      assertThat(result).contains(keys.toArray(new Integer[0]));
+    }
+
+    proceed.set(false);
+    try {
+      reader.get(1, SECONDS);
+      pool.shutdown();
+      pool.awaitTermination(1, SECONDS);
+    } catch (ExecutionException | InterruptedException | TimeoutException e) {
+      throw new IllegalStateException(e);
     }
   }
 

From bc48cff3284719ee477d7c471cf72c48aa212c66 Mon Sep 17 00:00:00 2001
From: stroomdev66 <stroomdev66@gmail.com>
Date: Tue, 28 Oct 2025 18:56:14 +0000
Subject: [PATCH 235/322] Upgrade LMDB C lib to 0.9.33 direct from the OpenLDAP
 repository

---
 cross-compile.sh | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/cross-compile.sh b/cross-compile.sh
index aa8815d5..5243feec 100755
--- a/cross-compile.sh
+++ b/cross-compile.sh
@@ -18,9 +18,9 @@
 
 set -o errexit
 
-rm -rf lmdb
-git clone --depth 1 --branch LMDB_0.9.31 https://github.com/LMDB/lmdb.git
-pushd lmdb/libraries/liblmdb
+rm -rf openldap
+git clone --depth 1 --branch LMDB_0.9.33 https://git.openldap.org/openldap/openldap.git
+pushd openldap/libraries/liblmdb
 trap popd SIGINT
 
 # zig targets | jq -r '.libc[]'

From f2de1bdc6f9586466f31b607209e70e0edf4cf32 Mon Sep 17 00:00:00 2001
From: stroomdev66 <stroomdev66@gmail.com>
Date: Tue, 28 Oct 2025 19:01:56 +0000
Subject: [PATCH 236/322] Upgrade to JUnit 5 and replace Hamcrest with AssertJ

---
 .../java/org/lmdbjava/ComparatorTest.java     | 22 +++++++++----------
 .../java/org/lmdbjava/CursorParamTest.java    | 12 +++++-----
 2 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/src/test/java/org/lmdbjava/ComparatorTest.java b/src/test/java/org/lmdbjava/ComparatorTest.java
index b4946a26..a5e010ab 100644
--- a/src/test/java/org/lmdbjava/ComparatorTest.java
+++ b/src/test/java/org/lmdbjava/ComparatorTest.java
@@ -56,14 +56,14 @@ public final class ComparatorTest {
 
   static Stream<Arguments> comparatorProvider() {
     return Stream.of(
-        Arguments.arguments("StringRunner", new StringRunner()),
-        Arguments.arguments("DirectBufferRunner", new DirectBufferRunner()),
-        Arguments.arguments("ByteArrayRunner", new ByteArrayRunner()),
-        Arguments.arguments("UnsignedByteArrayRunner", new UnsignedByteArrayRunner()),
-        Arguments.arguments("ByteBufferRunner", new ByteBufferRunner()),
-        Arguments.arguments("NettyRunner", new NettyRunner()),
-        Arguments.arguments("GuavaUnsignedBytes", new GuavaUnsignedBytes()),
-        Arguments.arguments("GuavaSignedBytes", new GuavaSignedBytes()));
+        Arguments.argumentSet("StringRunner", new StringRunner()),
+        Arguments.argumentSet("DirectBufferRunner", new DirectBufferRunner()),
+        Arguments.argumentSet("ByteArrayRunner", new ByteArrayRunner()),
+        Arguments.argumentSet("UnsignedByteArrayRunner", new UnsignedByteArrayRunner()),
+        Arguments.argumentSet("ByteBufferRunner", new ByteBufferRunner()),
+        Arguments.argumentSet("NettyRunner", new NettyRunner()),
+        Arguments.argumentSet("GuavaUnsignedBytes", new GuavaUnsignedBytes()),
+        Arguments.argumentSet("GuavaSignedBytes", new GuavaSignedBytes()));
   }
 
   private static byte[] buffer(final int... bytes) {
@@ -76,7 +76,7 @@ private static byte[] buffer(final int... bytes) {
 
   @ParameterizedTest
   @MethodSource("comparatorProvider")
-  void atLeastOneBufferHasEightBytes(final String str, final ComparatorRunner comparator) {
+  void atLeastOneBufferHasEightBytes(final ComparatorRunner comparator) {
     assertThat(get(comparator.compare(HLLLLLLL, LLLLLLLL))).isEqualTo(GREATER_THAN);
     assertThat(get(comparator.compare(LLLLLLLL, HLLLLLLL))).isEqualTo(LESS_THAN);
 
@@ -95,7 +95,7 @@ void atLeastOneBufferHasEightBytes(final String str, final ComparatorRunner comp
 
   @ParameterizedTest
   @MethodSource("comparatorProvider")
-  void buffersOfTwoBytes(final String str, final ComparatorRunner comparator) {
+  void buffersOfTwoBytes(final ComparatorRunner comparator) {
     assertThat(get(comparator.compare(LL, XX))).isEqualTo(GREATER_THAN);
     assertThat(get(comparator.compare(XX, LL))).isEqualTo(LESS_THAN);
 
@@ -111,7 +111,7 @@ void buffersOfTwoBytes(final String str, final ComparatorRunner comparator) {
 
   @ParameterizedTest
   @MethodSource("comparatorProvider")
-  void equalBuffers(final String str, final ComparatorRunner comparator) {
+  void equalBuffers(final ComparatorRunner comparator) {
     assertThat(get(comparator.compare(LL, LL))).isEqualTo(EQUAL_TO);
     assertThat(get(comparator.compare(HX, HX))).isEqualTo(EQUAL_TO);
     assertThat(get(comparator.compare(LH, LH))).isEqualTo(EQUAL_TO);
diff --git a/src/test/java/org/lmdbjava/CursorParamTest.java b/src/test/java/org/lmdbjava/CursorParamTest.java
index 0b2df19e..1a3604be 100644
--- a/src/test/java/org/lmdbjava/CursorParamTest.java
+++ b/src/test/java/org/lmdbjava/CursorParamTest.java
@@ -58,16 +58,16 @@ public final class CursorParamTest {
 
   static Stream<Arguments> data() {
     return Stream.of(
-        Arguments.arguments("ByteBufferRunner(PROXY_OPTIMAL)", new ByteBufferRunner(PROXY_OPTIMAL)),
-        Arguments.arguments("ByteBufferRunner(PROXY_SAFE)", new ByteBufferRunner(PROXY_SAFE)),
-        Arguments.arguments("ByteArrayRunner(PROXY_BA)", new ByteArrayRunner(PROXY_BA)),
-        Arguments.arguments("DirectBufferRunner", new DirectBufferRunner()),
-        Arguments.arguments("NettyBufferRunner", new NettyBufferRunner()));
+        Arguments.argumentSet("ByteBufferRunner(PROXY_OPTIMAL)", new ByteBufferRunner(PROXY_OPTIMAL)),
+        Arguments.argumentSet("ByteBufferRunner(PROXY_SAFE)", new ByteBufferRunner(PROXY_SAFE)),
+        Arguments.argumentSet("ByteArrayRunner(PROXY_BA)", new ByteArrayRunner(PROXY_BA)),
+        Arguments.argumentSet("DirectBufferRunner", new DirectBufferRunner()),
+        Arguments.argumentSet("NettyBufferRunner", new NettyBufferRunner()));
   }
 
   @ParameterizedTest
   @MethodSource("data")
-  void execute(final String name, final BufferRunner<?> runner, @TempDir final Path tmp) {
+  void execute(final BufferRunner<?> runner, @TempDir final Path tmp) {
     runner.execute(tmp);
   }
 

From c0bbe73cb1d128ebb04baf842b9ed98b941a8e7f Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Tue, 28 Oct 2025 21:13:21 +0000
Subject: [PATCH 237/322] Deprecate methods using varargs flags

---
 src/main/java/org/lmdbjava/Cursor.java        | 181 ++++++++++++++++--
 src/main/java/org/lmdbjava/Dbi.java           |  99 +++++++---
 src/main/java/org/lmdbjava/DbiBuilder.java    |  14 +-
 src/main/java/org/lmdbjava/DbiFlagSet.java    |   2 +
 src/main/java/org/lmdbjava/Env.java           | 179 +++++++++--------
 src/main/java/org/lmdbjava/EnvFlagSet.java    |   2 +
 src/main/java/org/lmdbjava/FlagSet.java       |  33 ++++
 src/main/java/org/lmdbjava/MaskedFlag.java    |   4 +
 src/main/java/org/lmdbjava/PutFlagSet.java    |   2 +
 .../org/lmdbjava/CursorIterablePerfTest.java  |   6 +-
 10 files changed, 392 insertions(+), 130 deletions(-)

diff --git a/src/main/java/org/lmdbjava/Cursor.java b/src/main/java/org/lmdbjava/Cursor.java
index 6d31a3d6..c1ac7374 100644
--- a/src/main/java/org/lmdbjava/Cursor.java
+++ b/src/main/java/org/lmdbjava/Cursor.java
@@ -20,8 +20,6 @@
 import static org.lmdbjava.Dbi.KeyNotFoundException.MDB_NOTFOUND;
 import static org.lmdbjava.Env.SHOULD_CHECK;
 import static org.lmdbjava.Library.LIB;
-import static org.lmdbjava.MaskedFlag.isSet;
-import static org.lmdbjava.MaskedFlag.mask;
 import static org.lmdbjava.PutFlags.MDB_MULTIPLE;
 import static org.lmdbjava.PutFlags.MDB_NODUPDATA;
 import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
@@ -97,23 +95,49 @@ public long count() {
     checkRc(LIB.mdb_cursor_count(ptrCursor, longByReference));
     return longByReference.longValue();
   }
+  /**
+   * @deprecated Instead use {@link Cursor#delete(PutFlagSet)}.
+   * <hr>
+   * Delete current key/data pair.
+   *
+   * <p>This function deletes the key/data pair to which the cursor refers.
+   *
+   * @param flags flags (either null or {@link PutFlags#MDB_NODUPDATA}
+   */
+  @Deprecated
+  public void delete(final PutFlags... flags) {
+    delete(PutFlagSet.of(flags));
+  }
+
+  /**
+   * @deprecated Instead use {@link Cursor#delete(PutFlagSet)}.
+   * <hr>
+   * Delete current key/data pair.
+   *
+   * <p>This function deletes the key/data pair to which the cursor refers.
+   */
+  public void delete() {
+    delete(PutFlagSet.EMPTY);
+  }
 
   /**
    * Delete current key/data pair.
    *
    * <p>This function deletes the key/data pair to which the cursor refers.
    *
-   * @param f flags (either null or {@link PutFlags#MDB_NODUPDATA}
+   * @param flags flags (either null or {@link PutFlags#MDB_NODUPDATA}
    */
-  public void delete(final PutFlags... f) {
+  public void delete(final PutFlagSet flags) {
     if (SHOULD_CHECK) {
       env.checkNotClosed();
       checkNotClosed();
       txn.checkReady();
       txn.checkWritesAllowed();
     }
-    final int flags = mask(f);
-    checkRc(LIB.mdb_cursor_del(ptrCursor, flags));
+    final PutFlagSet putFlagSet = flags != null
+        ? flags
+        : PutFlagSet.EMPTY;
+    checkRc(LIB.mdb_cursor_del(ptrCursor, putFlagSet.getMask()));
   }
 
   /**
@@ -235,17 +259,49 @@ public boolean prev() {
   }
 
   /**
+   * @deprecated Use {@link Cursor#put(Object, Object, PutFlagSet)} instead.
+   * <hr>
    * Store by cursor.
    *
    * <p>This function stores key/data pairs into the database.
    *
    * @param key key to store
    * @param val data to store
-   * @param op options for this operation
+   * @param flags options for this operation
+   * @return true if the value was put, false if MDB_NOOVERWRITE or MDB_NODUPDATA were set and the
+   *     key/value existed already.
+   */
+  @Deprecated
+  public boolean put(final T key, final T val, final PutFlags... flags) {
+    return put(key, val, PutFlagSet.of(flags));
+  }
+
+  /**
+   * Store by cursor.
+   *
+   * <p>This function stores key/data pairs into the database.
+   *
+   * @param key key to store
+   * @param val data to store
+   * @return true if the value was put, false if MDB_NOOVERWRITE or MDB_NODUPDATA were set and the
+   *     key/value existed already.
+   */
+  public boolean put(final T key, final T val) {
+    return put(key, val, PutFlagSet.EMPTY);
+  }
+
+  /**
+   * Store by cursor.
+   *
+   * <p>This function stores key/data pairs into the database.
+   *
+   * @param key key to store
+   * @param val data to store
+   * @param flags options for this operation
    * @return true if the value was put, false if MDB_NOOVERWRITE or MDB_NODUPDATA were set and the
    *     key/value existed already.
    */
-  public boolean put(final T key, final T val, final PutFlags... op) {
+  public boolean put(final T key, final T val, final PutFlagSet flags) {
     if (SHOULD_CHECK) {
       requireNonNull(key);
       requireNonNull(val);
@@ -256,12 +312,14 @@ public boolean put(final T key, final T val, final PutFlags... op) {
     }
     final Pointer transientKey = kv.keyIn(key);
     final Pointer transientVal = kv.valIn(val);
-    final int mask = mask(op);
-    final int rc = LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(), mask);
+    final PutFlagSet putFlagSet = flags != null
+        ? flags
+        : PutFlagSet.EMPTY;
+    final int rc = LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(), putFlagSet.getMask());
     if (rc == MDB_KEYEXIST) {
-      if (isSet(mask, MDB_NOOVERWRITE)) {
+      if (putFlagSet.isSet(MDB_NOOVERWRITE)) {
         kv.valOut(); // marked as in,out in LMDB C docs
-      } else if (!isSet(mask, MDB_NODUPDATA)) {
+      } else if (!putFlagSet.isSet(MDB_NODUPDATA)) {
         checkRc(rc);
       }
       return false;
@@ -274,6 +332,42 @@ public boolean put(final T key, final T val, final PutFlags... op) {
     return true;
   }
 
+  /**
+   * @deprecated Use {@link Cursor#put(Object, Object, PutFlagSet)} instead.
+   * <hr>
+   * Put multiple values into the database in one <code>MDB_MULTIPLE</code> operation.
+   *
+   * <p>The database must have been opened with {@link DbiFlags#MDB_DUPFIXED}. The buffer must
+   * contain fixed-sized values to be inserted. The size of each element is calculated from the
+   * buffer's size divided by the given element count. For example, to populate 10 X 4 byte integers
+   * at once, present a buffer of 40 bytes and specify the element as 10.
+   *
+   * @param key key to store in the database (not null)
+   * @param val value to store in the database (not null)
+   * @param elements number of elements contained in the passed value buffer
+   * @param flags options for operation (must set <code>MDB_MULTIPLE</code>)
+   */
+  @Deprecated
+  public void putMultiple(final T key, final T val, final int elements, final PutFlags... flags) {
+    putMultiple(key, val, elements, PutFlagSet.of(flags));
+  }
+
+  /**
+   * Put multiple values into the database in one <code>MDB_MULTIPLE</code> operation.
+   *
+   * <p>The database must have been opened with {@link DbiFlags#MDB_DUPFIXED}. The buffer must
+   * contain fixed-sized values to be inserted. The size of each element is calculated from the
+   * buffer's size divided by the given element count. For example, to populate 10 X 4 byte integers
+   * at once, present a buffer of 40 bytes and specify the element as 10.
+   *
+   * @param key key to store in the database (not null)
+   * @param val value to store in the database (not null)
+   * @param elements number of elements contained in the passed value buffer
+   */
+  public void putMultiple(final T key, final T val, final int elements) {
+    putMultiple(key, val, elements, PutFlagSet.EMPTY);
+  }
+
   /**
    * Put multiple values into the database in one <code>MDB_MULTIPLE</code> operation.
    *
@@ -285,9 +379,10 @@ public boolean put(final T key, final T val, final PutFlags... op) {
    * @param key key to store in the database (not null)
    * @param val value to store in the database (not null)
    * @param elements number of elements contained in the passed value buffer
-   * @param op options for operation (must set <code>MDB_MULTIPLE</code>)
+   * @param flags options for operation (must set <code>MDB_MULTIPLE</code>)
+   *              Either a {@link PutFlagSet} or a single {@link PutFlags}.
    */
-  public void putMultiple(final T key, final T val, final int elements, final PutFlags... op) {
+  public void putMultiple(final T key, final T val, final int elements, final PutFlagSet flags) {
     if (SHOULD_CHECK) {
       requireNonNull(txn);
       requireNonNull(key);
@@ -296,13 +391,15 @@ public void putMultiple(final T key, final T val, final int elements, final PutF
       txn.checkReady();
       txn.checkWritesAllowed();
     }
-    final int mask = mask(op);
-    if (SHOULD_CHECK && !isSet(mask, MDB_MULTIPLE)) {
+    final PutFlagSet putFlagSet = flags != null
+        ? flags
+        : PutFlagSet.EMPTY;
+    if (SHOULD_CHECK && !putFlagSet.isSet(MDB_MULTIPLE)) {
       throw new IllegalArgumentException("Must set " + MDB_MULTIPLE + " flag");
     }
     final Pointer transientKey = txn.kv().keyIn(key);
     final Pointer dataPtr = txn.kv().valInMulti(val, elements);
-    final int rc = LIB.mdb_cursor_put(ptrCursor, txn.kv().pointerKey(), dataPtr, mask);
+    final int rc = LIB.mdb_cursor_put(ptrCursor, txn.kv().pointerKey(), dataPtr, putFlagSet.getMask());
     checkRc(rc);
     ReferenceUtil.reachabilityFence0(transientKey);
     ReferenceUtil.reachabilityFence0(dataPtr);
@@ -334,6 +431,8 @@ public void renew(final Txn<T> newTxn) {
   }
 
   /**
+   * @deprecated Use {@link Cursor#reserve(Object, int, PutFlagSet)} instead.
+   * <hr>
    * Reserve space for data of the given size, but don't copy the given val. Instead, return a
    * pointer to the reserved space, which the caller can fill in later - before the next update
    * operation or the transaction ends. This saves an extra memcpy if the data is being generated
@@ -344,10 +443,46 @@ public void renew(final Txn<T> newTxn) {
    *
    * @param key key to store in the database (not null)
    * @param size size of the value to be stored in the database (not null)
-   * @param op options for this operation
+   * @param flags options for this operation
+   * @return a buffer that can be used to modify the value
+   */
+  @Deprecated
+  public T reserve(final T key, final int size, final PutFlags... flags) {
+    return reserve(key, size, PutFlagSet.of(flags));
+  }
+
+  /**
+   * Reserve space for data of the given size, but don't copy the given val. Instead, return a
+   * pointer to the reserved space, which the caller can fill in later - before the next update
+   * operation or the transaction ends. This saves an extra {@code memcpy} if the data is being generated
+   * later. LMDB does nothing else with this memory, the caller is expected to modify all the
+   * space requested.
+   *
+   * <p>This flag must not be specified if the database was opened with MDB_DUPSORT
+   *
+   * @param key key to store in the database (not null)
+   * @param size size of the value to be stored in the database (not null)
+   * @return a buffer that can be used to modify the value
+   */
+  public T reserve(final T key, final int size) {
+    return reserve(key, size, PutFlagSet.EMPTY);
+  }
+
+  /**
+   * Reserve space for data of the given size, but don't copy the given val. Instead, return a
+   * pointer to the reserved space, which the caller can fill in later - before the next update
+   * operation or the transaction ends. This saves an extra memcpy if the data is being generated
+   * later. LMDB does nothing else with this memory, the caller is expected to modify all of the
+   * space requested.
+   *
+   * <p>This flag must not be specified if the database was opened with MDB_DUPSORT
+   *
+   * @param key key to store in the database (not null)
+   * @param size size of the value to be stored in the database (not null)
+   * @param flags options for this operation
    * @return a buffer that can be used to modify the value
    */
-  public T reserve(final T key, final int size, final PutFlags... op) {
+  public T reserve(final T key, final int size, final PutFlagSet flags) {
     if (SHOULD_CHECK) {
       requireNonNull(key);
       env.checkNotClosed();
@@ -357,8 +492,12 @@ public T reserve(final T key, final int size, final PutFlags... op) {
     }
     final Pointer transientKey = kv.keyIn(key);
     final Pointer transientVal = kv.valIn(size);
-    final int flags = mask(op) | MDB_RESERVE.getMask();
-    checkRc(LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(), flags));
+    final PutFlagSet putFlagSet = flags != null
+        ? flags
+        : PutFlagSet.EMPTY;
+    // This is inconsistent with putMultiple which require MDB_MULTIPLE to be in the set.
+    final int flagsMask = putFlagSet.getMaskWith(MDB_RESERVE);
+    checkRc(LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(), flagsMask));
     kv.valOut();
     ReferenceUtil.reachabilityFence0(transientKey);
     ReferenceUtil.reachabilityFence0(transientVal);
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index c66dc780..bcb1ccfc 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -31,7 +31,7 @@
 import static org.lmdbjava.PutFlags.MDB_RESERVE;
 import static org.lmdbjava.ResultCodeMapper.checkRc;
 
-import java.nio.charset.StandardCharsets;
+import java.nio.charset.Charset;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Comparator;
@@ -261,6 +261,31 @@ public byte[] getName() {
     return name == null ? null : Arrays.copyOf(name, name.length);
   }
 
+  public String getNameAsString() {
+    return getNameAsString(Env.DEFAULT_NAME_CHARSET);
+  }
+
+
+  /**
+   * Obtains the name of this database, using the supplied {@link Charset}.
+   *
+   * @return The name of the database. If this is the unnamed database an empty
+   * string will be returned.
+   * @throws RuntimeException if the name can't be decoded.
+   */
+  public String getNameAsString(final Charset charset) {
+    if (name == null) {
+      return "";
+    } else {
+      // Assume a UTF8 encoding as we don't know, thus swallow if it fails
+      try {
+        return new String(name, requireNonNull(charset));
+      } catch (Exception e) {
+        throw new RuntimeException("Unable to decode database name using charset " + charset);
+      }
+    }
+  }
+
   /**
    * Iterate the database from the first item and forwards.
    *
@@ -345,18 +370,22 @@ public Cursor<T> openCursor(final Txn<T> txn) {
    *
    * @param key key to store in the database (not null)
    * @param val value to store in the database (not null)
-   * @see #put(org.lmdbjava.Txn, java.lang.Object, java.lang.Object, org.lmdbjava.PutFlags...)
+   * @see #put(Txn, Object, Object, PutFlagSet)
    */
   public void put(final T key, final T val) {
     try (Txn<T> txn = env.txnWrite()) {
-      put(txn, key, val);
+      put(txn, key, val, PutFlagSet.EMPTY);
       txn.commit();
     }
   }
 
   /**
+   * @deprecated Use {@link Dbi#put(Txn, Object, Object, PutFlagSet)} instead, with a statically
+   * held {@link PutFlagSet}.
+   * <hr>
+   * <p>
    * Store a key/value pair in the database.
-   *
+   * </p>
    * <p>This function stores key/data pairs in the database. The default behavior is to enter the
    * new key/data pair, replacing any previously existing key if duplicates are disallowed, or
    * adding a duplicate data item if duplicates are allowed ({@link DbiFlags#MDB_DUPSORT}).
@@ -368,7 +397,40 @@ public void put(final T key, final T val) {
    * @return true if the value was put, false if MDB_NOOVERWRITE or MDB_NODUPDATA were set and the
    *     key/value existed already.
    */
+  @Deprecated
   public boolean put(final Txn<T> txn, final T key, final T val, final PutFlags... flags) {
+    return put(txn, key, val, PutFlagSet.of(flags));
+  }
+
+  /**
+   * Store a key/value pair in the database.
+   *
+   * @param txn transaction handle (not null; not committed; must be R-W)
+   * @param key key to store in the database (not null)
+   * @param val value to store in the database (not null)
+   * @return true if the value was put, false if MDB_NOOVERWRITE or MDB_NODUPDATA were set and the
+   *     key/value existed already.
+   * @see #put(Txn, Object, Object, PutFlagSet)
+   */
+  public boolean put(final Txn<T> txn, final T key, final T val) {
+    return put(txn, key, val, PutFlagSet.EMPTY);
+  }
+
+  /**
+   * Store a key/value pair in the database.
+   *
+   * <p>This function stores key/data pairs in the database. The default behavior is to enter the
+   * new key/data pair, replacing any previously existing key if duplicates are disallowed, or
+   * adding a duplicate data item if duplicates are allowed ({@link DbiFlags#MDB_DUPSORT}).
+   *
+   * @param txn transaction handle (not null; not committed; must be R-W)
+   * @param key key to store in the database (not null)
+   * @param val value to store in the database (not null)
+   * @param flags Special options for this operation.
+   * @return true if the value was put, false if MDB_NOOVERWRITE or MDB_NODUPDATA were set and the
+   *     key/value existed already.
+   */
+  public boolean put(final Txn<T> txn, final T key, final T val, final PutFlagSet flags) {
     if (SHOULD_CHECK) {
       requireNonNull(txn);
       requireNonNull(key);
@@ -377,14 +439,14 @@ public boolean put(final Txn<T> txn, final T key, final T val, final PutFlags...
       txn.checkReady();
       txn.checkWritesAllowed();
     }
+    final PutFlagSet flagSet = flags != null ? flags : PutFlagSet.empty();
     final Pointer transientKey = txn.kv().keyIn(key);
     final Pointer transientVal = txn.kv().valIn(val);
-    final int mask = mask(flags);
-    final int rc = LIB.mdb_put(txn.pointer(), ptr, txn.kv().pointerKey(), txn.kv().pointerVal(), mask);
+    final int rc = LIB.mdb_put(txn.pointer(), ptr, txn.kv().pointerKey(), txn.kv().pointerVal(), flagSet.getMask());
     if (rc == MDB_KEYEXIST) {
-      if (isSet(mask, MDB_NOOVERWRITE)) {
+      if (flagSet.isSet(MDB_NOOVERWRITE)) {
         txn.kv().valOut(); // marked as in,out in LMDB C docs
-      } else if (!isSet(mask, MDB_NODUPDATA)) {
+      } else if (!flagSet.isSet(MDB_NODUPDATA)) {
         checkRc(rc);
       }
       return false;
@@ -461,23 +523,16 @@ private void clean() {
     cleaned = true;
   }
 
-  private String getNameAsString() {
-    if (name == null) {
-      return "";
-    } else {
-      try {
-        // Assume a UTF8 encoding as we don't know, thus swallow if it fails
-        return new String(name, StandardCharsets.UTF_8);
-      } catch (Exception e) {
-        return "?";
-      }
-    }
-  }
-
   @Override
   public String toString() {
+    String name;
+    try {
+      name = getNameAsString();
+    } catch (Exception e) {
+      name = "?";
+    }
     return "Dbi{" +
-            "name='" + getNameAsString() +
+            "name='" + name +
             "', dbiFlagSet=" + dbiFlagSet +
             '}';
   }
diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
index dcf34d0a..2b4e6ad8 100644
--- a/src/main/java/org/lmdbjava/DbiBuilder.java
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -28,6 +28,7 @@
  */
 public class DbiBuilder<T> {
 
+
   private final Env<T> env;
   private final BufferProxy<T> proxy;
   private final boolean readOnly;
@@ -56,7 +57,7 @@ public DbiBuilderStage2<T> withDbName(final String name) {
     // Null name is allowed so no null check
     final byte[] nameBytes = name == null
         ? null
-        : name.getBytes(StandardCharsets.UTF_8);
+        : name.getBytes(Env.DEFAULT_NAME_CHARSET);
     return withDbName(nameBytes);
   }
 
@@ -252,7 +253,7 @@ private DbiBuilderStage3(DbiBuilderStage2<T> dbiBuilderStage2) {
      * Clears all flags currently set by previous calls to
      * {@link DbiBuilderStage3#withDbiFlags(Collection)},
      * {@link DbiBuilderStage3#withDbiFlags(DbiFlags...)}
-     * or {@link DbiBuilderStage3#setDbiFlag(DbiFlags)}.
+     * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
      * </p>
      *
      * @param dbiFlags to open the database with.
@@ -277,7 +278,7 @@ public DbiBuilderStage3<T> withDbiFlags(final Collection<DbiFlags> dbiFlags) {
      * Clears all flags currently set by previous calls to
      * {@link DbiBuilderStage3#withDbiFlags(Collection)},
      * {@link DbiBuilderStage3#withDbiFlags(DbiFlags...)}
-     * or {@link DbiBuilderStage3#setDbiFlag(DbiFlags)}.
+     * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
      * </p>
      *
      * @param dbiFlags to open the database with.
@@ -302,7 +303,7 @@ public DbiBuilderStage3<T> withDbiFlags(final DbiFlags... dbiFlags) {
      * Clears all flags currently set by previous calls to
      * {@link DbiBuilderStage3#withDbiFlags(Collection)},
      * {@link DbiBuilderStage3#withDbiFlags(DbiFlags...)}
-     * or {@link DbiBuilderStage3#setDbiFlag(DbiFlags)}.
+     * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
      * </p>
      *
      * @param dbiFlagSet to open the database with.
@@ -320,12 +321,12 @@ public DbiBuilderStage3<T> withDbiFlags(final DbiFlagSet dbiFlagSet) {
      * Adds a dbiFlag to those flags already added to this builder by
      * {@link DbiBuilderStage3#withDbiFlags(DbiFlags...)},
      * {@link DbiBuilderStage3#withDbiFlags(Collection)}
-     * or {@link DbiBuilderStage3#setDbiFlag(DbiFlags)}.
+     * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
      *
      * @param dbiFlag to open the database with. A null value is a no-op.
      * @return this builder instance.
      */
-    public DbiBuilderStage3<T> setDbiFlag(final DbiFlags dbiFlag) {
+    public DbiBuilderStage3<T> addDbiFlag(final DbiFlags dbiFlag) {
       this.flagSetBuilder.setFlag(dbiFlag);
       return this;
     }
@@ -409,7 +410,6 @@ private Dbi<T> open(final Txn<T> txn,
       final ComparatorType comparatorType = dbiBuilderStage2.comparatorType;
       final Comparator<T> comparator = getComparator(dbiBuilder, comparatorType, dbiFlagSet);
       final boolean useNativeCallback = comparatorType == ComparatorType.CALLBACK;
-
       return new Dbi<>(
           dbiBuilder.env,
           txn,
diff --git a/src/main/java/org/lmdbjava/DbiFlagSet.java b/src/main/java/org/lmdbjava/DbiFlagSet.java
index 28f5e4f1..5edf10c7 100644
--- a/src/main/java/org/lmdbjava/DbiFlagSet.java
+++ b/src/main/java/org/lmdbjava/DbiFlagSet.java
@@ -21,6 +21,8 @@
 
 public interface DbiFlagSet extends FlagSet<DbiFlags> {
 
+  DbiFlagSet EMPTY = DbiFlagSetImpl.EMPTY;
+
   static DbiFlagSet empty() {
     return DbiFlagSetImpl.EMPTY;
   }
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index efc4e240..55c88ec1 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -29,6 +29,8 @@
 
 import java.io.File;
 import java.nio.ByteBuffer;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
@@ -46,8 +48,11 @@
  */
 public final class Env<T> implements AutoCloseable {
 
-  /** Java system property name that can be set to disable optional checks. */
+  /**
+   * Java system property name that can be set to disable optional checks.
+   */
   public static final String DISABLE_CHECKS_PROP = "lmdbjava.disable.checks";
+  public static final Charset DEFAULT_NAME_CHARSET = StandardCharsets.UTF_8;
 
   /**
    * Indicates whether optional checks should be applied in LmdbJava. Optional checks are only
@@ -88,7 +93,7 @@ public static Builder<ByteBuffer> create() {
   /**
    * Create an {@link Env} using the passed {@link BufferProxy}.
    *
-   * @param <T> buffer type
+   * @param <T>   buffer type
    * @param proxy the proxy to use (required)
    * @return the environment (never null)
    */
@@ -100,13 +105,15 @@ public static <T> Builder<T> create(final BufferProxy<T> proxy) {
    * Opens an environment with a single default database in 0664 mode using the {@link
    * ByteBufferProxy#PROXY_OPTIMAL}.
    *
-   * @param path file system destination
-   * @param size size in megabytes
+   * @param path  file system destination
+   * @param size  size in megabytes
    * @param flags the flags for this new environment
    * @return env the environment (never null)
    */
   public static Env<ByteBuffer> open(final File path, final int size, final EnvFlags... flags) {
-    return new Builder<>(PROXY_OPTIMAL).setMapSize(size * 1_024L * 1_024L).open(path, flags);
+    return new Builder<>(PROXY_OPTIMAL)
+        .setMapSize(size * 1_024L * 1_024L)
+        .open(path, flags);
   }
 
   /**
@@ -159,7 +166,7 @@ public void copy(final File path) {
    * transactions, because it employs a read-only transaction. See long-lived transactions under
    * "Caveats" in the LMDB native documentation.
    *
-   * @param path writable destination path as described above
+   * @param path  writable destination path as described above
    * @param flags special options for this copy
    */
   public void copy(final File path, final CopyFlagSet flags) {
@@ -183,7 +190,7 @@ public List<byte[]> getDbiNames() {
     final List<byte[]> result = new ArrayList<>();
     final Dbi<T> names = openDbi((byte[]) null);
     try (Txn<T> txn = txnRead();
-        Cursor<T> cursor = names.openCursor(txn)) {
+         Cursor<T> cursor = names.openCursor(txn)) {
       if (!cursor.first()) {
         return Collections.emptyList();
       }
@@ -263,6 +270,7 @@ public boolean isReadOnly() {
   /**
    * Open (and optionally creates, if {@link DbiFlags#MDB_CREATE} is set)
    * a {@link Dbi} using a builder.
+   *
    * @return A new builder instance for creating/opening a {@link Dbi}.
    */
   public DbiBuilder<T> buildDbi() {
@@ -270,13 +278,12 @@ public DbiBuilder<T> buildDbi() {
   }
 
   /**
+   * @param name  name of the database (or null if no name is required)
+   * @param flags to open the database with
+   * @return a database that is ready to use
    * @deprecated Instead use {@link Env#buildDbi()}
    * Convenience method that opens a {@link Dbi} with a UTF-8 database name and default {@link
    * Comparator} that is not invoked from native code.
-   *
-   * @param name name of the database (or null if no name is required)
-   * @param flags to open the database with
-   * @return a database that is ready to use
    */
   @Deprecated()
   public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
@@ -285,6 +292,11 @@ public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
   }
 
   /**
+   * @param name       name of the database (or null if no name is required)
+   * @param comparator custom comparator for cursor start/stop key comparisons. If null, LMDB's
+   *                   comparator will be used.
+   * @param flags      to open the database with
+   * @return a database that is ready to use
    * @deprecated Instead use {@link Env#buildDbi()}
    * Convenience method that opens a {@link Dbi} with a UTF-8 database name and associated {@link
    * Comparator} for use by {@link CursorIterable} when comparing start/stop keys.
@@ -293,88 +305,83 @@ public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
    * LMDB uses for its insertion order (for the type of data that will be stored in the database),
    * or you fully understand the implications of them behaving differently. LMDB's comparator is
    * unsigned lexicographical, unless {@link DbiFlags#MDB_INTEGERKEY} is used.
-   *
-   * @param name name of the database (or null if no name is required)
-   * @param comparator custom comparator for cursor start/stop key comparisons. If null, LMDB's
-   *     comparator will be used.
-   * @param flags to open the database with
-   * @return a database that is ready to use
    */
   @Deprecated()
-  public Dbi<T> openDbi(
-      final String name, final Comparator<T> comparator, final DbiFlags... flags) {
+  public Dbi<T> openDbi(final String name,
+                        final Comparator<T> comparator,
+                        final DbiFlags... flags) {
     final byte[] nameBytes = name == null ? null : name.getBytes(UTF_8);
     return openDbi(nameBytes, comparator, false, flags);
   }
 
   /**
+   * @param name       name of the database (or null if no name is required)
+   * @param comparator custom comparator for cursor start/stop key comparisons and optionally for
+   *                   LMDB to call back to. If null, LMDB's comparator will be used.
+   * @param nativeCb   whether LMDB native code calls back to the Java comparator
+   * @param flags      to open the database with
+   * @return a database that is ready to use
    * @deprecated Instead use {@link Env#buildDbi()}
    * Convenience method that opens a {@link Dbi} with a UTF-8 database name and associated {@link
    * Comparator}. The comparator will be used by {@link CursorIterable} when comparing start/stop
    * keys as a minimum. If nativeCb is {@code true}, this comparator will also be called by LMDB to
    * determine insertion/iteration order. Calling back to a java comparator may significantly impact
    * performance.
-   *
-   * @param name name of the database (or null if no name is required)
-   * @param comparator custom comparator for cursor start/stop key comparisons and optionally for
-   *     LMDB to call back to. If null, LMDB's comparator will be used.
-   * @param nativeCb whether LMDB native code calls back to the Java comparator
-   * @param flags to open the database with
-   * @return a database that is ready to use
    */
   @Deprecated()
-  public Dbi<T> openDbi(
-      final String name,
-      final Comparator<T> comparator,
-      final boolean nativeCb,
-      final DbiFlags... flags) {
+  public Dbi<T> openDbi(final String name,
+                        final Comparator<T> comparator,
+                        final boolean nativeCb,
+                        final DbiFlags... flags) {
     final byte[] nameBytes = name == null ? null : name.getBytes(UTF_8);
     return openDbi(nameBytes, comparator, nativeCb, flags);
   }
 
   /**
+   * @param name  name of the database (or null if no name is required)
+   * @param flags to open the database with
+   * @return a database that is ready to use
    * @deprecated Instead use {@link Env#buildDbi()}
+   * <hr>
    * Convenience method that opens a {@link Dbi} with a default {@link Comparator} that is not
    * invoked from native code.
-   *
-   * @param name name of the database (or null if no name is required)
-   * @param flags to open the database with
-   * @return a database that is ready to use
    */
   @Deprecated()
-  public Dbi<T> openDbi(final byte[] name, final DbiFlags... flags) {
+  public Dbi<T> openDbi(final byte[] name,
+                        final DbiFlags... flags) {
     return openDbi(name, null, false, flags);
   }
 
   /**
+   * @param name       name of the database (or null if no name is required)
+   * @param comparator custom comparator callback (or null to use LMDB default)
+   * @param flags      to open the database with
+   * @return a database that is ready to use
    * @deprecated Instead use {@link Env#buildDbi()}
+   * <hr>
    * Convenience method that opens a {@link Dbi} with an associated {@link Comparator} that is not
    * invoked from native code.
-   *
-   * @param name name of the database (or null if no name is required)
-   * @param comparator custom comparator callback (or null to use LMDB default)
-   * @param flags to open the database with
-   * @return a database that is ready to use
    */
   @Deprecated()
-  public Dbi<T> openDbi(
-      final byte[] name, final Comparator<T> comparator, final DbiFlags... flags) {
+  public Dbi<T> openDbi(final byte[] name,
+                        final Comparator<T> comparator,
+                        final DbiFlags... flags) {
     return openDbi(name, comparator, false, flags);
   }
 
   /**
+   * @param name       name of the database (or null if no name is required)
+   * @param comparator custom comparator callback (or null to use LMDB default)
+   * @param nativeCb   whether native code calls back to the Java comparator
+   * @param flags      to open the database with
+   * @return a database that is ready to use
    * @deprecated Instead use {@link Env#buildDbi()}
+   * <hr>
    * Convenience method that opens a {@link Dbi} with an associated {@link Comparator} that may be
    * invoked from native code if specified.
    *
    * <p>This method will automatically commit the private transaction before returning. This ensures
    * the <code>Dbi</code> is available in the <code>Env</code>.
-   *
-   * @param name name of the database (or null if no name is required)
-   * @param comparator custom comparator callback (or null to use LMDB default)
-   * @param nativeCb whether native code calls back to the Java comparator
-   * @param flags to open the database with
-   * @return a database that is ready to use
    */
   @Deprecated()
   public Dbi<T> openDbi(
@@ -390,6 +397,12 @@ public Dbi<T> openDbi(
   }
 
   /**
+   * @param txn        transaction to use (required; not closed)
+   * @param name       name of the database (or null if no name is required)
+   * @param comparator custom comparator callback (or null to use LMDB default)
+   * @param nativeCb   whether native LMDB code should call back to the Java comparator
+   * @param flags      to open the database with
+   * @return a database that is ready to use
    * @deprecated Instead use {@link Env#buildDbi()}
    * Open the {@link Dbi} using the passed {@link Txn}.
    *
@@ -409,13 +422,6 @@ public Dbi<T> openDbi(
    *
    * <p>This method (and its overloaded convenience variants) must not be called from concurrent
    * threads.
-   *
-   * @param txn transaction to use (required; not closed)
-   * @param name name of the database (or null if no name is required)
-   * @param comparator custom comparator callback (or null to use LMDB default)
-   * @param nativeCb whether native LMDB code should call back to the Java comparator
-   * @param flags to open the database with
-   * @return a database that is ready to use
    */
   @Deprecated()
   public Dbi<T> openDbi(
@@ -455,7 +461,7 @@ public Stat stat() {
    * Flushes the data buffers to disk.
    *
    * @param force force a synchronous flush (otherwise if the environment has the MDB_NOSYNC flag
-   *     set the flushes will be omitted, and with MDB_MAPASYNC they will be asynchronous)
+   *              set the flushes will be omitted, and with MDB_MAPASYNC they will be asynchronous)
    */
   public void sync(final boolean force) {
     if (closed) {
@@ -466,13 +472,12 @@ public void sync(final boolean force) {
   }
 
   /**
-   * @deprecated Instead use {@link Env#txn(Txn, TxnFlagSet)}
-   *
-   * Obtain a transaction with the requested parent and flags.
-   *
    * @param parent parent transaction (may be null if no parent)
-   * @param flags applicable flags (eg for a reusable, read-only transaction)
+   * @param flags  applicable flags (eg for a reusable, read-only transaction)
    * @return a transaction (never null)
+   * @deprecated Instead use {@link Env#txn(Txn, TxnFlagSet)}
+   * <p>
+   * Obtain a transaction with the requested parent and flags.
    */
   @Deprecated
   public Txn<T> txn(final Txn<T> parent, final TxnFlags... flags) {
@@ -495,7 +500,7 @@ public Txn<T> txn(final Txn<T> parent) {
    * Obtain a transaction with the requested parent and flags.
    *
    * @param parent parent transaction (may be null if no parent)
-   * @param flag applicable flag (eg for a reusable, read-only transaction)
+   * @param flag   applicable flag (eg for a reusable, read-only transaction)
    * @return a transaction (never null)
    */
   public Txn<T> txn(final Txn<T> parent, final TxnFlags flag) {
@@ -507,9 +512,9 @@ public Txn<T> txn(final Txn<T> parent, final TxnFlags flag) {
    * Obtain a transaction with the requested parent and flags.
    *
    * @param parent parent transaction (may be null if no parent)
-   * @param flags applicable flags (e.g. for a reusable, read-only transaction).
-   *              If the set of flags is used frequently it is recommended to hold
-   *              a static instance of the {@link TxnFlagSet} for re-use.
+   * @param flags  applicable flags (e.g. for a reusable, read-only transaction).
+   *               If the set of flags is used frequently it is recommended to hold
+   *               a static instance of the {@link TxnFlagSet} for re-use.
    * @return a transaction (never null)
    */
   public Txn<T> txn(final Txn<T> parent, final TxnFlagSet flags) {
@@ -581,23 +586,31 @@ public int readerCheck() {
     return resultPtr.intValue();
   }
 
-  /** Object has already been closed and the operation is therefore prohibited. */
+  /**
+   * Object has already been closed and the operation is therefore prohibited.
+   */
   public static final class AlreadyClosedException extends LmdbException {
 
     private static final long serialVersionUID = 1L;
 
-    /** Creates a new instance. */
+    /**
+     * Creates a new instance.
+     */
     public AlreadyClosedException() {
       super("Environment has already been closed");
     }
   }
 
-  /** Object has already been opened and the operation is therefore prohibited. */
+  /**
+   * Object has already been opened and the operation is therefore prohibited.
+   */
   public static final class AlreadyOpenException extends LmdbException {
 
     private static final long serialVersionUID = 1L;
 
-    /** Creates a new instance. */
+    /**
+     * Creates a new instance.
+     */
     public AlreadyOpenException() {
       super("Environment has already been opened");
     }
@@ -625,8 +638,8 @@ public static final class Builder<T> {
     /**
      * Opens the environment.
      *
-     * @param path file system destination
-     * @param mode Unix permissions to set on created files and semaphores
+     * @param path  file system destination
+     * @param mode  Unix permissions to set on created files and semaphores
      * @param flags the flags for this new environment
      * @return an environment ready for use
      */
@@ -657,7 +670,7 @@ public Env<T> open(final File path, final int mode, final EnvFlags... flags) {
     /**
      * Opens the environment with 0664 mode.
      *
-     * @param path file system destination
+     * @param path  file system destination
      * @param flags the flags for this new environment
      * @return an environment ready for use
      */
@@ -711,7 +724,9 @@ public Builder<T> setMaxReaders(final int readers) {
     }
   }
 
-  /** File is not a valid LMDB file. */
+  /**
+   * File is not a valid LMDB file.
+   */
   public static final class FileInvalidException extends LmdbNativeException {
 
     static final int MDB_INVALID = -30_793;
@@ -722,7 +737,9 @@ public static final class FileInvalidException extends LmdbNativeException {
     }
   }
 
-  /** The specified copy destination is invalid. */
+  /**
+   * The specified copy destination is invalid.
+   */
   public static final class InvalidCopyDestination extends LmdbException {
 
     private static final long serialVersionUID = 1L;
@@ -737,7 +754,9 @@ public InvalidCopyDestination(final String message) {
     }
   }
 
-  /** Environment mapsize reached. */
+  /**
+   * Environment mapsize reached.
+   */
   public static final class MapFullException extends LmdbNativeException {
 
     static final int MDB_MAP_FULL = -30_792;
@@ -748,7 +767,9 @@ public static final class MapFullException extends LmdbNativeException {
     }
   }
 
-  /** Environment maxreaders reached. */
+  /**
+   * Environment maxreaders reached.
+   */
   public static final class ReadersFullException extends LmdbNativeException {
 
     static final int MDB_READERS_FULL = -30_790;
@@ -759,7 +780,9 @@ public static final class ReadersFullException extends LmdbNativeException {
     }
   }
 
-  /** Environment version mismatch. */
+  /**
+   * Environment version mismatch.
+   */
   public static final class VersionMismatchException extends LmdbNativeException {
 
     static final int MDB_VERSION_MISMATCH = -30_794;
diff --git a/src/main/java/org/lmdbjava/EnvFlagSet.java b/src/main/java/org/lmdbjava/EnvFlagSet.java
index f1bab2d0..a3c8d1fa 100644
--- a/src/main/java/org/lmdbjava/EnvFlagSet.java
+++ b/src/main/java/org/lmdbjava/EnvFlagSet.java
@@ -21,6 +21,8 @@
 
 public interface EnvFlagSet extends FlagSet<EnvFlags> {
 
+  EnvFlagSet EMPTY = EnvFlagSetImpl.EMPTY;
+
   static EnvFlagSet empty() {
     return EnvFlagSetImpl.EMPTY;
   }
diff --git a/src/main/java/org/lmdbjava/FlagSet.java b/src/main/java/org/lmdbjava/FlagSet.java
index 89b955a0..668e33ba 100644
--- a/src/main/java/org/lmdbjava/FlagSet.java
+++ b/src/main/java/org/lmdbjava/FlagSet.java
@@ -28,24 +28,57 @@
  */
 public interface FlagSet<T extends MaskedFlag> extends Iterable<T> {
 
+  /**
+   * @return The combined mask for this flagSet.
+   */
   int getMask();
 
+  /**
+   * @return The result of combining the mask of this {@link FlagSet}
+   * with the mask of the other {@link FlagSet}.
+   */
+  default int getMaskWith(final FlagSet<T> other) {
+    if (other != null) {
+      return MaskedFlag.mask(getMask(), other.getMask());
+    } else {
+      return getMask();
+    }
+  }
+
+  /**
+   * @return The set of flags in this {@link FlagSet}.
+   */
   Set<T> getFlags();
 
+  /**
+   * @return True if flag is non-null and included in this {@link FlagSet}.
+   */
   boolean isSet(T flag);
 
+  /**
+   * @return The size of this {@link FlagSet}
+   */
   default int size() {
     return getFlags().size();
   }
 
+  /**
+   * @return True if this {@link FlagSet} is empty.
+   */
   default boolean isEmpty() {
     return getFlags().isEmpty();
   }
 
+  /**
+   * @return The {@link Iterator} (in no particular order) for the flags in this {@link FlagSet}.
+   */
   default Iterator<T> iterator() {
     return getFlags().iterator();
   }
 
+  /**
+   * Convert this {@link FlagSet} to a string for use in toString methods.
+   */
   static <T extends MaskedFlag> String asString(final FlagSet<T> flagSet) {
     Objects.requireNonNull(flagSet);
     final String flagsStr = flagSet.getFlags()
diff --git a/src/main/java/org/lmdbjava/MaskedFlag.java b/src/main/java/org/lmdbjava/MaskedFlag.java
index f2f08274..271bb122 100644
--- a/src/main/java/org/lmdbjava/MaskedFlag.java
+++ b/src/main/java/org/lmdbjava/MaskedFlag.java
@@ -59,6 +59,10 @@ static <M extends MaskedFlag> int mask(final M... flags) {
     }
   }
 
+  static <M extends MaskedFlag> int mask(final int mask1, final int mask2) {
+    return mask1 | mask2;
+  }
+
   static <M extends MaskedFlag> int mask(final Collection<M> flags) {
     if (flags == null || flags.isEmpty()) {
       return EMPTY_MASK;
diff --git a/src/main/java/org/lmdbjava/PutFlagSet.java b/src/main/java/org/lmdbjava/PutFlagSet.java
index 85de014b..9d3a7288 100644
--- a/src/main/java/org/lmdbjava/PutFlagSet.java
+++ b/src/main/java/org/lmdbjava/PutFlagSet.java
@@ -21,6 +21,8 @@
 
 public interface PutFlagSet extends FlagSet<PutFlags> {
 
+    PutFlagSet EMPTY = PutFlagSetImpl.EMPTY;
+
     static PutFlagSet empty() {
         return PutFlagSetImpl.EMPTY;
     }
diff --git a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
index e2c54346..c5240215 100644
--- a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
@@ -110,6 +110,8 @@ private void populateDatabases(final boolean randomOrder) {
       data = this.data;
     }
 
+    final PutFlagSet noOverwriteAndAppendFlagSet = PutFlagSet.of(MDB_NOOVERWRITE, MDB_APPEND);
+
     for (int round = 0; round < 3; round++) {
       System.out.println("round: " + round + " -----------------------------------------");
 
@@ -122,14 +124,14 @@ private void populateDatabases(final boolean randomOrder) {
           }
         }
 
-        final String dbName = new String(db.getName(), StandardCharsets.UTF_8);
+        final String dbName = db.getNameAsString(StandardCharsets.UTF_8);
         final Instant start = Instant.now();
         try (Txn<ByteBuffer> txn = env.txnWrite()) {
           for (final Integer i : data) {
             if (randomOrder) {
               db.put(txn, bb(i), bb(i + 1), MDB_NOOVERWRITE);
             } else {
-              db.put(txn, bb(i), bb(i + 1), MDB_NOOVERWRITE, MDB_APPEND);
+              db.put(txn, bb(i), bb(i + 1), noOverwriteAndAppendFlagSet);
             }
           }
           txn.commit();

From 4fd89fff1755e1572929da3097809dfdad5fa1bb Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Wed, 29 Oct 2025 11:32:38 +0000
Subject: [PATCH 238/322] Add int key compare method to
 (Direct|Byte)BufferProxy

---
 .../java/org/lmdbjava/AbstractFlagSet.java    |  27 +-
 src/main/java/org/lmdbjava/BufferProxy.java   |  27 +-
 .../java/org/lmdbjava/ByteArrayProxy.java     |  31 --
 src/main/java/org/lmdbjava/ByteBufProxy.java  |  10 -
 .../java/org/lmdbjava/ByteBufferProxy.java    | 122 ++++----
 .../java/org/lmdbjava/DirectBufferProxy.java  |  60 ++--
 src/main/java/org/lmdbjava/FlagSet.java       |  39 ++-
 .../org/lmdbjava/ByteBufferProxyTest.java     |  90 +++++-
 .../CursorIterableIntegerKeyTest.java         | 293 +++++++++++-------
 .../java/org/lmdbjava/CursorIterableTest.java |  45 +--
 .../java/org/lmdbjava/DbiBuilderTest.java     |   1 -
 11 files changed, 453 insertions(+), 292 deletions(-)

diff --git a/src/main/java/org/lmdbjava/AbstractFlagSet.java b/src/main/java/org/lmdbjava/AbstractFlagSet.java
index 5e62b437..25aa328b 100644
--- a/src/main/java/org/lmdbjava/AbstractFlagSet.java
+++ b/src/main/java/org/lmdbjava/AbstractFlagSet.java
@@ -64,7 +64,6 @@ public boolean isSet(final T flag) {
     // Probably cheaper to compare the masks than to use EnumSet.contains()
     return flag != null
         && MaskedFlag.isSet(mask, flag);
-
   }
 
   /**
@@ -93,9 +92,7 @@ public Iterator<T> iterator() {
 
   @Override
   public boolean equals(Object object) {
-    if (this == object) return true;
-//    if (object == null || getClass() != object.getClass()) return false;
-    return FlagSet.equals(this, (FlagSet<?>) object);
+    return FlagSet.equals(this, object);
   }
 
   @Override
@@ -141,6 +138,15 @@ public boolean isSet(final T flag) {
       return this.flag == flag;
     }
 
+    @Override
+    public boolean areAnySet(FlagSet<T> flags) {
+      if (flags == null) {
+        return false;
+      } else {
+        return flags.isSet(this.flag);
+      }
+    }
+
     @Override
     public int size() {
       return 1;
@@ -167,9 +173,7 @@ public String toString() {
 
     @Override
     public boolean equals(Object object) {
-      if (this == object) return true;
-//      if (object == null || getClass() != object.getClass()) return false;
-      return FlagSet.equals(this, (FlagSet<?>) object);
+      return FlagSet.equals(this, object);
     }
 
     @Override
@@ -205,6 +209,11 @@ public boolean isSet(final T flag) {
       return false;
     }
 
+    @Override
+    public boolean areAnySet(final FlagSet<T> flags) {
+      return false;
+    }
+
     @Override
     public int size() {
       return 0;
@@ -227,9 +236,7 @@ public String toString() {
 
     @Override
     public boolean equals(Object object) {
-      if (this == object) return true;
-//      if (object == null || getClass() != object.getClass()) return false;
-      return FlagSet.equals(this, (FlagSet<?>) object);
+      return FlagSet.equals(this, object);
     }
 
     @Override
diff --git a/src/main/java/org/lmdbjava/BufferProxy.java b/src/main/java/org/lmdbjava/BufferProxy.java
index 60272209..af0c7f06 100644
--- a/src/main/java/org/lmdbjava/BufferProxy.java
+++ b/src/main/java/org/lmdbjava/BufferProxy.java
@@ -40,6 +40,11 @@ public abstract class BufferProxy<T> {
   /** Offset from a pointer of the <code>MDB_val.mv_size</code> field. */
   protected static final int STRUCT_FIELD_OFFSET_SIZE = 0;
 
+  /** The set of {@link DbiFlags} that indicate unsigned integer keys are being used. */
+  protected static final DbiFlagSet INTEGER_KEY_FLAGS = DbiFlagSet.of(
+      DbiFlags.MDB_INTEGERKEY,
+      DbiFlags.MDB_INTEGERDUP);
+
   /** Explicitly-defined default constructor to avoid warnings. */
   protected BufferProxy() {}
 
@@ -88,28 +93,6 @@ public Comparator<T> getComparator() {
     return getComparator(DbiFlagSet.empty());
   }
 
-//  /**
-//   * Get a suitable default {@link Comparator} to compare numeric key values as signed.
-//   *
-//   * <p>Note: LMDB's default comparator is unsigned so if this is used only for the {@link
-//   * CursorIterable} start/stop key comparisons then its behaviour will differ from the iteration
-//   * order. Use with caution.
-//   *
-//   * @return a comparator that can be used (never null)
-//   */
-//  public abstract Comparator<T> getSignedComparator();
-//
-//  /**
-//   * Get a suitable default {@link Comparator} to compare numeric key values as unsigned.
-//   * <p>
-//   * This should match the behaviour of the LMDB's mdb_cmp comparator as it may be used for
-//   * {@link CursorIterable} start/stop keys comparisons, which must match LMDB's insertion order.
-//   * </p>
-//   *
-//   * @return a comparator that can be used (never null)
-//   */
-//  public abstract Comparator<T> getUnsignedComparator(final DbiFlagSet dbiFlagSet);
-
   /**
    * Called when the <code>MDB_val</code> should be set to reflect the passed buffer. This buffer
    * will have been created by end users, not {@link #allocate()}.
diff --git a/src/main/java/org/lmdbjava/ByteArrayProxy.java b/src/main/java/org/lmdbjava/ByteArrayProxy.java
index 5231ed51..d7c23919 100644
--- a/src/main/java/org/lmdbjava/ByteArrayProxy.java
+++ b/src/main/java/org/lmdbjava/ByteArrayProxy.java
@@ -36,7 +36,6 @@ public final class ByteArrayProxy extends BufferProxy<byte[]> {
 
   private static final MemoryManager MEM_MGR = RUNTIME.getMemoryManager();
 
-  private static final Comparator<byte[]> signedComparator = ByteArrayProxy::compareArraysSigned;
   private static final Comparator<byte[]> unsignedComparator = ByteArrayProxy::compareArrays;
 
   private ByteArrayProxy() {}
@@ -68,26 +67,6 @@ public static int compareArrays(final byte[] o1, final byte[] o2) {
     return o1.length - o2.length;
   }
 
-  /**
-   * Compare two byte arrays.
-   *
-   * @param b1 left operand (required)
-   * @param b2 right operand (required)
-   * @return as specified by {@link Comparable} interface
-   */
-  public static int compareArraysSigned(final byte[] b1, final byte[] b2) {
-    requireNonNull(b1);
-    requireNonNull(b2);
-
-    if (b1 == b2) return 0;
-
-    for (int i = 0; i < min(b1.length, b2.length); ++i) {
-      if (b1[i] != b2[i]) return b1[i] - b2[i];
-    }
-
-    return b1.length - b2.length;
-  }
-
   @Override
   protected byte[] allocate() {
     return new byte[0];
@@ -108,16 +87,6 @@ public Comparator<byte[]> getComparator(final DbiFlagSet dbiFlagSet) {
     return unsignedComparator;
   }
 
-  //  @Override
-//  public Comparator<byte[]> getSignedComparator() {
-//    return signedComparator;
-//  }
-//
-//  @Override
-//  public Comparator<byte[]> getUnsignedComparator() {
-//    return unsignedComparator;
-//  }
-
   @Override
   protected Pointer in(final byte[] buffer, final Pointer ptr) {
     final Pointer pointer = MEM_MGR.allocateDirect(buffer.length);
diff --git a/src/main/java/org/lmdbjava/ByteBufProxy.java b/src/main/java/org/lmdbjava/ByteBufProxy.java
index fc14b58f..319256fb 100644
--- a/src/main/java/org/lmdbjava/ByteBufProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufProxy.java
@@ -118,16 +118,6 @@ public Comparator<ByteBuf> getComparator(final DbiFlagSet dbiFlagSet) {
     return comparator;
   }
 
-  //  @Override
-//  public Comparator<ByteBuf> getSignedComparator() {
-//    return comparator;
-//  }
-//
-//  @Override
-//  public Comparator<ByteBuf> getUnsignedComparator() {
-//    return comparator;
-//  }
-
   @Override
   protected void deallocate(final ByteBuf buff) {
     buff.release();
diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
index 4875572b..ca4deba3 100644
--- a/src/main/java/org/lmdbjava/ByteBufferProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -54,15 +54,19 @@ public final class ByteBufferProxy {
    */
   public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
 
-  /** The safe, reflective {@link ByteBuffer} proxy for this system. Guaranteed to never be null. */
+  /**
+   * The safe, reflective {@link ByteBuffer} proxy for this system. Guaranteed to never be null.
+   */
   public static final BufferProxy<ByteBuffer> PROXY_SAFE;
 
+
   static {
     PROXY_SAFE = new ReflectiveProxy();
     PROXY_OPTIMAL = getProxyOptimal();
   }
 
-  private ByteBufferProxy() {}
+  private ByteBufferProxy() {
+  }
 
   private static BufferProxy<ByteBuffer> getProxyOptimal() {
     try {
@@ -72,17 +76,25 @@ private static BufferProxy<ByteBuffer> getProxyOptimal() {
     }
   }
 
-  /** The buffer must be a direct buffer (not heap allocated). */
+  /**
+   * The buffer must be a direct buffer (not heap allocated).
+   */
   public static final class BufferMustBeDirectException extends LmdbException {
 
     private static final long serialVersionUID = 1L;
 
-    /** Creates a new instance. */
+    /**
+     * Creates a new instance.
+     */
     public BufferMustBeDirectException() {
       super("The buffer must be a direct buffer (not heap allocated");
     }
   }
 
+
+  // --------------------------------------------------------------------------------
+
+
   /**
    * Provides {@link ByteBuffer} pooling and address resolution for concrete {@link BufferProxy}
    * implementations.
@@ -92,16 +104,6 @@ abstract static class AbstractByteBufferProxy extends BufferProxy<ByteBuffer> {
     protected static final String FIELD_NAME_ADDRESS = "address";
     protected static final String FIELD_NAME_CAPACITY = "capacity";
 
-    private static final Comparator<ByteBuffer> signedComparator =
-        (o1, o2) -> {
-          requireNonNull(o1);
-          requireNonNull(o2);
-
-          return o1.compareTo(o2);
-        };
-    private static final Comparator<ByteBuffer> unsignedComparator =
-        AbstractByteBufferProxy::compareBuff;
-
     /**
      * A thread-safe pool for a given length. If the buffer found is valid (ie not of a negative
      * length) then that buffer is used. If no valid buffer is found, a new buffer is created.
@@ -116,7 +118,7 @@ abstract static class AbstractByteBufferProxy extends BufferProxy<ByteBuffer> {
      * @param o2 right operand (required)
      * @return as specified by {@link Comparable} interface
      */
-    public static int compareBuff(final ByteBuffer o1, final ByteBuffer o2) {
+    public static int compareLexicographically(final ByteBuffer o1, final ByteBuffer o2) {
       requireNonNull(o1);
       requireNonNull(o2);
       if (o1.equals(o2)) {
@@ -148,34 +150,42 @@ public static int compareBuff(final ByteBuffer o1, final ByteBuffer o2) {
       return o1.remaining() - o2.remaining();
     }
 
-//    /**
-//     * Possible compareBuff method specifically for 4/8 byte keys when using MDB_INTEGER_KEY
-//     */
-//    public static int compareBuff(final ByteBuffer o1, final ByteBuffer o2) {
-//      requireNonNull(o1);
-//      requireNonNull(o2);
-//      // Both buffers should be same len
-//      final int len1 = o1.limit();
-//      final int len2 = o2.limit();
-//      if (len1 != len2) {
-//        throw new RuntimeException("Length mismatch, len1: " + len1 + ", len2: " + len2
-//            + ". Lengths must be identical and either 4 or 8 bytes.");
-//      }
-//      final boolean reverse1 = o1.order() == LITTLE_ENDIAN;
-//      final boolean reverse2 = o2.order() == LITTLE_ENDIAN;
-//      if (len1 == 8) {
-//          final long lw = reverse1 ? Long.reverseBytes(o1.getLong()) : o1.getLong();
-//          final long rw = reverse2 ? Long.reverseBytes(o2.getLong()) : o2.getLong();
-//          return Long.compareUnsigned(lw, rw);
-//      } else if (len1 == 4) {
-//        final int lw = reverse1 ? Integer.reverseBytes(o1.getInt()) : o1.getInt();
-//        final int rw = reverse2 ? Integer.reverseBytes(o2.getInt()) : o2.getInt();
-//          return Integer.compareUnsigned(lw, rw);
-//      } else {
-//        throw new RuntimeException("Unexpected length len1: " + len1 + ", len2: " + len2
-//            + ". Lengths must be identical and either 4 or 8 bytes.");
-//      }
-//    }
+    /**
+     * Buffer comparator specifically for 4/8 byte keys that are unsigned ints/longs,
+     * i.e. when using MDB_INTEGER_KEY/MDB_INTEGERDUP. Compares the buffers numerically.
+     * <p>
+     * Both buffer must have 4 or 8 bytes remaining
+     * </p>
+     *
+     * @param o1 left operand (required)
+     * @param o2 right operand (required)
+     * @return as specified by {@link Comparable} interface
+     */
+    public static int compareAsIntegerKeys(final ByteBuffer o1, final ByteBuffer o2) {
+      requireNonNull(o1);
+      requireNonNull(o2);
+      // Both buffers should be same len
+      final int len1 = o1.limit();
+      final int len2 = o2.limit();
+      if (len1 != len2) {
+        throw new RuntimeException("Length mismatch, len1: " + len1 + ", len2: " + len2
+            + ". Lengths must be identical and either 4 or 8 bytes.");
+      }
+      final boolean reverse1 = o1.order() == LITTLE_ENDIAN;
+      final boolean reverse2 = o2.order() == LITTLE_ENDIAN;
+      if (len1 == 8) {
+        final long lw = reverse1 ? Long.reverseBytes(o1.getLong(0)) : o1.getLong(0);
+        final long rw = reverse2 ? Long.reverseBytes(o2.getLong(0)) : o2.getLong(0);
+        return Long.compareUnsigned(lw, rw);
+      } else if (len1 == 4) {
+        final int lw = reverse1 ? Integer.reverseBytes(o1.getInt(0)) : o1.getInt(0);
+        final int rw = reverse2 ? Integer.reverseBytes(o2.getInt(0)) : o2.getInt(0);
+        return Integer.compareUnsigned(lw, rw);
+      } else {
+        throw new RuntimeException("Unexpected length1: " + len1
+            + ". Lengths must be identical and either 4 or 8 bytes.");
+      }
+    }
 
     static Field findField(final Class<?> c, final String name) {
       Class<?> clazz = c;
@@ -211,20 +221,14 @@ protected final ByteBuffer allocate() {
     }
 
     @Override
-    public Comparator<ByteBuffer> getComparator(DbiFlagSet dbiFlagSet) {
-      return unsignedComparator;
+    public Comparator<ByteBuffer> getComparator(final DbiFlagSet dbiFlagSet) {
+      if (dbiFlagSet.areAnySet(INTEGER_KEY_FLAGS)) {
+        return AbstractByteBufferProxy::compareAsIntegerKeys;
+      } else {
+        return AbstractByteBufferProxy::compareLexicographically;
+      }
     }
 
-    //    @Override
-//    public Comparator<ByteBuffer> getSignedComparator() {
-//      return signedComparator;
-//    }
-//
-//    @Override
-//    public Comparator<ByteBuffer> getUnsignedComparator(final DbiFlagSet dbiFlagSet) {
-//      return unsignedComparator;
-//    }
-
     @Override
     protected final void deallocate(final ByteBuffer buff) {
       buff.order(BIG_ENDIAN);
@@ -240,6 +244,10 @@ protected byte[] getBytes(final ByteBuffer buffer) {
     }
   }
 
+
+  // --------------------------------------------------------------------------------
+
+
   /**
    * A proxy that uses Java reflection to modify byte buffer fields, and official JNR-FFF methods to
    * manipulate native pointers.
@@ -284,6 +292,10 @@ protected ByteBuffer out(final ByteBuffer buffer, final Pointer ptr) {
     }
   }
 
+
+  // --------------------------------------------------------------------------------
+
+
   /**
    * A proxy that uses Java's "unsafe" class to directly manipulate byte buffer fields and JNR-FFF
    * allocated memory pointers.
diff --git a/src/main/java/org/lmdbjava/DirectBufferProxy.java b/src/main/java/org/lmdbjava/DirectBufferProxy.java
index 514c04ab..9c90d98b 100644
--- a/src/main/java/org/lmdbjava/DirectBufferProxy.java
+++ b/src/main/java/org/lmdbjava/DirectBufferProxy.java
@@ -35,14 +35,6 @@
  * <p>This class requires {@link UnsafeAccess} and Agrona must be in the classpath.
  */
 public final class DirectBufferProxy extends BufferProxy<DirectBuffer> {
-  private static final Comparator<DirectBuffer> signedComparator =
-      (o1, o2) -> {
-        requireNonNull(o1);
-        requireNonNull(o2);
-
-        return o1.compareTo(o2);
-      };
-  private static final Comparator<DirectBuffer> unsignedComparator = DirectBufferProxy::compareBuff;
 
   /**
    * The {@link MutableDirectBuffer} proxy. Guaranteed to never be null, although a class
@@ -67,7 +59,7 @@ private DirectBufferProxy() {}
    * @param o2 right operand (required)
    * @return as specified by {@link Comparable} interface
    */
-  public static int compareBuff(final DirectBuffer o1, final DirectBuffer o2) {
+  public static int compareLexicographically(final DirectBuffer o1, final DirectBuffer o2) {
     requireNonNull(o1);
     requireNonNull(o2);
     if (o1.equals(o2)) {
@@ -97,6 +89,40 @@ public static int compareBuff(final DirectBuffer o1, final DirectBuffer o2) {
     return o1.capacity() - o2.capacity();
   }
 
+  /**
+   * Buffer comparator specifically for 4/8 byte keys that are unsigned ints/longs,
+   * i.e. when using MDB_INTEGER_KEY/MDB_INTEGERDUP. Compares the buffers numerically.
+   * <p>
+   * Both buffer must have 4 or 8 bytes remaining
+   * </p>
+   * @param o1 left operand (required)
+   * @param o2 right operand (required)
+   * @return as specified by {@link Comparable} interface
+   */
+  public static int compareAsIntegerKeys(final DirectBuffer o1, final DirectBuffer o2) {
+    requireNonNull(o1);
+    requireNonNull(o2);
+    // Both buffers should be same len
+    final int len1 = o1.capacity();
+    final int len2 = o2.capacity();
+    if (len1 != len2) {
+      throw new RuntimeException("Length mismatch, len1: " + len1 + ", len2: " + len2
+          + ". Lengths must be identical and either 4 or 8 bytes.");
+    }
+    if (len1 == 8) {
+      final long lw = o1.getLong(0, BIG_ENDIAN);
+      final long rw = o2.getLong(0, BIG_ENDIAN);
+      return Long.compareUnsigned(lw, rw);
+    } else if (len1 == 4) {
+      final int lw = o1.getInt(0, BIG_ENDIAN);
+      final int rw = o2.getInt(0, BIG_ENDIAN);
+      return Integer.compareUnsigned(lw, rw);
+    } else {
+      throw new RuntimeException("Unexpected length len1: " + len1 + ", len2: " + len2
+          + ". Lengths must be identical and either 4 or 8 bytes.");
+    }
+  }
+
   @Override
   protected DirectBuffer allocate() {
     final ArrayDeque<DirectBuffer> q = BUFFERS.get();
@@ -112,19 +138,13 @@ protected DirectBuffer allocate() {
 
   @Override
   public Comparator<DirectBuffer> getComparator(final DbiFlagSet dbiFlagSet) {
-    return unsignedComparator;
+    if (dbiFlagSet.areAnySet(INTEGER_KEY_FLAGS)) {
+      return DirectBufferProxy::compareAsIntegerKeys;
+    } else {
+      return DirectBufferProxy::compareLexicographically;
+    }
   }
 
-  //  @Override
-//  public Comparator<DirectBuffer> getSignedComparator() {
-//    return signedComparator;
-//  }
-//
-//  @Override
-//  public Comparator<DirectBuffer> getUnsignedComparator(final DbiFlagSet dbiFlagSet) {
-//    return unsignedComparator;
-//  }
-
   @Override
   protected void deallocate(final DirectBuffer buff) {
     final ArrayDeque<DirectBuffer> q = BUFFERS.get();
diff --git a/src/main/java/org/lmdbjava/FlagSet.java b/src/main/java/org/lmdbjava/FlagSet.java
index 668e33ba..27513fcd 100644
--- a/src/main/java/org/lmdbjava/FlagSet.java
+++ b/src/main/java/org/lmdbjava/FlagSet.java
@@ -55,6 +55,22 @@ default int getMaskWith(final FlagSet<T> other) {
    */
   boolean isSet(T flag);
 
+  /**
+   * @return True if at least one of flags are included in thie {@link FlagSet}
+   */
+  default boolean areAnySet(final FlagSet<T> flags) {
+    if (flags == null) {
+      return false;
+    } else {
+      for (final T flag : flags) {
+        if (isSet(flag)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
   /**
    * @return The size of this {@link FlagSet}
    */
@@ -92,17 +108,20 @@ static <T extends MaskedFlag> String asString(final FlagSet<T> flagSet) {
         '}';
   }
 
-  static boolean equals(final FlagSet<?> flagSet1,
-                        final FlagSet<?> flagSet2) {
-    if (flagSet1 == flagSet2) {
-      return true;
-    } else if (flagSet1 != null && flagSet2 == null) {
-      return false;
-    } else if (flagSet1 == null) {
-      return false;
+  static boolean equals(final FlagSet<?> flagSet,
+                        final Object other) {
+    if (other instanceof FlagSet) {
+      final FlagSet<?> flagSet2 = (FlagSet<?>) other;
+      if (flagSet == flagSet2) {
+        return true;
+      } else if (flagSet == null) {
+        return false;
+      } else {
+        return flagSet.getMask() == flagSet2.getMask()
+            && Objects.equals(flagSet.getFlags(), flagSet2.getFlags());
+      }
     } else {
-      return flagSet1.getMask() == flagSet2.getMask()
-          && Objects.equals(flagSet1.getFlags(), flagSet2.getFlags());
+      return false;
     }
   }
 
diff --git a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
index b68f39ef..1372b74a 100644
--- a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
+++ b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
@@ -40,20 +40,31 @@
 import java.io.IOException;
 import java.lang.reflect.Field;
 import java.nio.ByteBuffer;
+import java.time.Duration;
+import java.time.Instant;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.Random;
+import java.util.Set;
 import jnr.ffi.Pointer;
 import jnr.ffi.provider.MemoryManager;
+import org.junit.Assert;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
 import org.lmdbjava.ByteBufferProxy.BufferMustBeDirectException;
 import org.lmdbjava.Env.ReadersFullException;
 
-/** Test {@link ByteBufferProxy}. */
+/**
+ * Test {@link ByteBufferProxy}.
+ */
 public final class ByteBufferProxyTest {
 
   static final MemoryManager MEM_MGR = RUNTIME.getMemoryManager();
 
-  @Rule public final TemporaryFolder tmp = new TemporaryFolder();
+  @Rule
+  public final TemporaryFolder tmp = new TemporaryFolder();
 
   @Test(expected = BufferMustBeDirectException.class)
   public void buffersMustBeDirect() throws IOException {
@@ -129,6 +140,81 @@ public void unsafeIsDefault() {
     assertThat(v.getClass().getSimpleName(), startsWith("Unsafe"));
   }
 
+  /**
+   * For 100 rounds of 1,000,000 comparisons
+   * compareAsIntegerKeys: PT0.267813487S
+   * compareLexicographically: PT0.644165235S
+   */
+  @Test
+  public void comparatorPerformance() {
+    final Random random = new Random();
+    final ByteBuffer buffer1 = ByteBuffer.allocateDirect(Long.BYTES);
+    final ByteBuffer buffer2 = ByteBuffer.allocateDirect(Long.BYTES);
+    buffer1.limit(Long.BYTES);
+    buffer2.limit(Long.BYTES);
+    final long[] values = random.longs(1_000_000).toArray();
+
+    Instant time = Instant.now();
+    int x = 0;
+    for (int rounds = 0; rounds < 100; rounds++) {
+      for (int i = 1; i < values.length; i++) {
+        buffer1.putLong(0, values[i - 1]);
+        buffer2.putLong(0, values[i]);
+        final int result = ByteBufferProxy.AbstractByteBufferProxy.compareAsIntegerKeys(buffer1, buffer2);
+        x += result;
+      }
+    }
+    System.out.println("compareAsIntegerKeys: " + Duration.between(time, Instant.now()));
+
+    time = Instant.now();
+    x = 0;
+    for (int rounds = 0; rounds < 100; rounds++) {
+      for (int i = 1; i < values.length; i++) {
+        buffer1.putLong(0, values[i - 1]);
+        buffer2.putLong(0, values[i]);
+        final int result = ByteBufferProxy.AbstractByteBufferProxy.compareLexicographically(buffer1, buffer2);
+        x += result;
+      }
+    }
+    System.out.println("compareLexicographically: " + Duration.between(time, Instant.now()));
+  }
+
+  @Test
+  public void verifyComparators() {
+    final Random random = new Random(203948);
+    final ByteBuffer buffer1 = ByteBuffer.allocateDirect(Long.BYTES);
+    final ByteBuffer buffer2 = ByteBuffer.allocateDirect(Long.BYTES);
+    buffer1.limit(Long.BYTES);
+    buffer2.limit(Long.BYTES);
+    final long[] values = random.longs(10_000_000).toArray();
+
+    final LinkedHashMap<String, Comparator<ByteBuffer>> comparators = new LinkedHashMap<>();
+    comparators.put("compareAsIntegerKeys", ByteBufferProxy.AbstractByteBufferProxy::compareAsIntegerKeys);
+    comparators.put("compareLexicographically", ByteBufferProxy.AbstractByteBufferProxy::compareLexicographically);
+
+    final LinkedHashMap<String, Integer> results = new LinkedHashMap<>(comparators.size());
+    final Set<Integer> uniqueResults = new HashSet<>(comparators.size());
+
+    for (int i = 1; i < values.length; i++) {
+      final long val1 = values[i - 1];
+      final long val2 = values[i];
+      buffer1.putLong(0, val1);
+      buffer2.putLong(0, val2);
+      uniqueResults.clear();
+
+      // Make sure all comparators give the same result for the same inputs
+      comparators.forEach((name, comparator) -> {
+        final int result = comparator.compare(buffer1, buffer2);
+        results.put(name, result);
+        uniqueResults.add(result);
+      });
+
+      if (uniqueResults.size() != 1) {
+        Assert.fail("Comparator mismatch for values: " + val1 + " and " + val2 + ". Results: " + results);
+      }
+    }
+  }
+
   private void checkInOut(final BufferProxy<ByteBuffer> v) {
     // allocate a buffer larger than max key size
     final ByteBuffer b = allocateDirect(1_000);
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
index aefe9d43..85c0a567 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
@@ -46,6 +46,7 @@
 import static org.lmdbjava.TestUtils.DB_1;
 import static org.lmdbjava.TestUtils.DB_2;
 import static org.lmdbjava.TestUtils.DB_3;
+import static org.lmdbjava.TestUtils.DB_4;
 import static org.lmdbjava.TestUtils.POSIX_MODE;
 import static org.lmdbjava.TestUtils.bb;
 import static org.lmdbjava.TestUtils.bbNative;
@@ -63,26 +64,128 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.NoSuchElementException;
+import java.util.function.Function;
 import org.hamcrest.Matchers;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TemporaryFolder;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
 import org.lmdbjava.CursorIterable.KeyVal;
 
-/** Test {@link CursorIterable} using {@link DbiFlags#MDB_INTEGERKEY} to ensure that
- * comparators work with native order integer keys. */
+/**
+ * Test {@link CursorIterable} using {@link DbiFlags#MDB_INTEGERKEY} to ensure that
+ * comparators work with native order integer keys.
+ */
+@RunWith(Parameterized.class)
 public final class CursorIterableIntegerKeyTest {
 
-  @Rule public final TemporaryFolder tmp = new TemporaryFolder();
-  private Dbi<ByteBuffer> dbJavaComparator;
-  private Dbi<ByteBuffer> dbLmdbComparator;
-  private Dbi<ByteBuffer> dbCallbackComparator;
-  private List<Dbi<ByteBuffer>> dbs = new ArrayList<>();
+  private static final DbiFlagSet DBI_FLAGS = DbiFlagSet.of(MDB_CREATE, MDB_INTEGERKEY);
+  private static final BufferProxy<ByteBuffer> BUFFER_PROXY = ByteBufferProxy.PROXY_OPTIMAL;
+
+  @Rule
+  public final TemporaryFolder tmp = new TemporaryFolder();
+
   private Env<ByteBuffer> env;
   private Deque<Integer> list;
 
+  /**
+   * Injected by {@link #data()} with appropriate runner.
+   */
+  @SuppressWarnings("ClassEscapesDefinedScope")
+  @Parameterized.Parameter
+  public DbiFactory dbiFactory;
+
+  @Parameterized.Parameters(name = "{index}: dbi: {0}")
+  public static Object[] data() {
+    final DbiFactory defaultComparator = new DbiFactory("defaultComparator", env ->
+        env.buildDbi()
+            .withDbName(DB_1)
+            .withDefaultComparator()
+            .withDbiFlags(DBI_FLAGS)
+            .open());
+    final DbiFactory nativeComparator = new DbiFactory("nativeComparator", env ->
+        env.buildDbi()
+            .withDbName(DB_2)
+            .withNativeComparator()
+            .withDbiFlags(DBI_FLAGS)
+            .open());
+    final DbiFactory callbackComparator = new DbiFactory("callbackComparator", env ->
+        env.buildDbi()
+            .withDbName(DB_3)
+            .withCallbackComparator(BUFFER_PROXY.getComparator(DBI_FLAGS))
+            .withDbiFlags(DBI_FLAGS)
+            .open());
+    final DbiFactory iteratorComparator = new DbiFactory("iteratorComparator", env ->
+        env.buildDbi()
+            .withDbName(DB_4)
+            .withIteratorComparator(BUFFER_PROXY.getComparator(DBI_FLAGS))
+            .withDbiFlags(DBI_FLAGS)
+            .open());
+    return new Object[]{
+        defaultComparator,
+        nativeComparator,
+        callbackComparator,
+        iteratorComparator};
+  }
+
+  @Before
+  public void before() throws IOException {
+    final File path = tmp.newFile();
+    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
+    env =
+        create(bufferProxy)
+            .setMapSize(KIBIBYTES.toBytes(256))
+            .setMaxReaders(1)
+            .setMaxDbs(3)
+            .open(path, POSIX_MODE, MDB_NOSUBDIR);
+
+    populateTestDataList();
+//    final File path = tmp.newFile();
+//    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
+//    env =
+//        create(bufferProxy)
+//            .setMapSize(KIBIBYTES.toBytes(256))
+//            .setMaxReaders(1)
+//            .setMaxDbs(3)
+//            .open(path, POSIX_MODE, MDB_NOSUBDIR);
+//
+//    // Use a java comparator for start/stop keys only
+//    DbiFlagSet dbiFlagSet = DbiFlagSet.of(MDB_CREATE, MDB_INTEGERKEY);
+//
+//    dbJavaComparator = env.buildDbi()
+//        .withDbName(DB_1)
+//        .withIteratorComparator(bufferProxy.getComparator(dbiFlagSet))
+//        .withDbiFlags(dbiFlagSet)
+//        .open();
+//
+//    // Use LMDB comparator for start/stop keys
+//    dbLmdbComparator = env.buildDbi()
+//        .withDbName(DB_2)
+//        .withDefaultComparator()
+//        .withDbiFlags(dbiFlagSet)
+//        .open();
+//
+//    // Use a java comparator for start/stop keys and as a callback comparaotr
+//    dbCallbackComparator = env.buildDbi()
+//        .withDbName(DB_3)
+//        .withCallbackComparator(bufferProxy.getComparator(dbiFlagSet))
+//        .withDbiFlags(dbiFlagSet)
+//        .open();
+//
+//    populateTestDataList();
+//
+//    populateDatabase(dbJavaComparator);
+//    populateDatabase(dbLmdbComparator);
+//    populateDatabase(dbCallbackComparator);
+//
+//    dbs.add(dbJavaComparator);
+//    dbs.add(dbLmdbComparator);
+//    dbs.add(dbCallbackComparator);
+  }
+
   @After
   public void after() {
     env.close();
@@ -123,52 +226,8 @@ public void atMostTest() {
     verify(atMost(bbNative(6)), 2, 4, 6);
   }
 
-  @Before
-  public void before() throws IOException {
-    final File path = tmp.newFile();
-    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
-    env =
-        create(bufferProxy)
-            .setMapSize(KIBIBYTES.toBytes(256))
-            .setMaxReaders(1)
-            .setMaxDbs(3)
-            .open(path, POSIX_MODE, MDB_NOSUBDIR);
-
-    // Use a java comparator for start/stop keys only
-    DbiFlagSet dbiFlagSet = DbiFlagSet.of(MDB_CREATE, MDB_INTEGERKEY);
-
-    dbJavaComparator = env.buildDbi()
-        .withDbName(DB_1)
-        .withIteratorComparator(bufferProxy.getComparator(dbiFlagSet))
-        .withDbiFlags(dbiFlagSet)
-        .open();
-
-    // Use LMDB comparator for start/stop keys
-    dbLmdbComparator = env.buildDbi()
-        .withDbName(DB_2)
-        .withDefaultComparator()
-        .withDbiFlags(dbiFlagSet)
-        .open();
 
-    // Use a java comparator for start/stop keys and as a callback comparaotr
-    dbCallbackComparator = env.buildDbi()
-        .withDbName(DB_3)
-        .withCallbackComparator(bufferProxy.getComparator(dbiFlagSet))
-        .withDbiFlags(dbiFlagSet)
-        .open();
-
-    populateList();
-
-    populateDatabase(dbJavaComparator);
-    populateDatabase(dbLmdbComparator);
-    populateDatabase(dbCallbackComparator);
-
-    dbs.add(dbJavaComparator);
-    dbs.add(dbLmdbComparator);
-    dbs.add(dbCallbackComparator);
-  }
-
-  private void populateList() {
+  private void populateTestDataList() {
     list = new LinkedList<>();
     list.addAll(asList(2, 3, 4, 5, 6, 7, 8, 9));
   }
@@ -226,40 +285,37 @@ public void greaterThanTest() {
 
   @Test(expected = IllegalStateException.class)
   public void iterableOnlyReturnedOnce() {
-    for (final Dbi<ByteBuffer> db : dbs) {
-      try (Txn<ByteBuffer> txn = env.txnRead();
-          CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-        c.iterator(); // ok
-        c.iterator(); // fails
-      }
+    final Dbi<ByteBuffer> db = getDb();
+    try (Txn<ByteBuffer> txn = env.txnRead();
+         CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+      c.iterator(); // ok
+      c.iterator(); // fails
     }
   }
 
   @Test
   public void iterate() {
-    for (final Dbi<ByteBuffer> db : dbs) {
-      populateList();
-      try (Txn<ByteBuffer> txn = env.txnRead();
-          CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+    populateTestDataList();
+    final Dbi<ByteBuffer> db = getDb();
+    try (Txn<ByteBuffer> txn = env.txnRead();
+         CursorIterable<ByteBuffer> c = db.iterate(txn)) {
 
-        int cnt = 0;
-        for (final KeyVal<ByteBuffer> kv : c) {
-          assertThat(getNativeInt(kv.key()), is(list.pollFirst()));
-          assertThat(kv.val().getInt(), is(list.pollFirst()));
-        }
+      int cnt = 0;
+      for (final KeyVal<ByteBuffer> kv : c) {
+        assertThat(getNativeInt(kv.key()), is(list.pollFirst()));
+        assertThat(kv.val().getInt(), is(list.pollFirst()));
       }
     }
   }
 
   @Test(expected = IllegalStateException.class)
   public void iteratorOnlyReturnedOnce() {
-    for (final Dbi<ByteBuffer> db : dbs) {
+    final Dbi<ByteBuffer> db = getDb();
       try (Txn<ByteBuffer> txn = env.txnRead();
-          CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+           CursorIterable<ByteBuffer> c = db.iterate(txn)) {
         c.iterator(); // ok
         c.iterator(); // fails
       }
-    }
   }
 
   @Test
@@ -276,19 +332,18 @@ public void lessThanTest() {
 
   @Test(expected = NoSuchElementException.class)
   public void nextThrowsNoSuchElementExceptionIfNoMoreElements() {
-    for (final Dbi<ByteBuffer> db : dbs) {
-      populateList();
-      try (Txn<ByteBuffer> txn = env.txnRead();
-          CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-        final Iterator<KeyVal<ByteBuffer>> i = c.iterator();
-        while (i.hasNext()) {
-          final KeyVal<ByteBuffer> kv = i.next();
-          assertThat(TestUtils.getNativeInt(kv.key()), is(list.pollFirst()));
-          assertThat(kv.val().getInt(), is(list.pollFirst()));
-        }
-        assertThat(i.hasNext(), is(false));
-        i.next();
+    populateTestDataList();
+    final Dbi<ByteBuffer> db = getDb();
+    try (Txn<ByteBuffer> txn = env.txnRead();
+         CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+      final Iterator<KeyVal<ByteBuffer>> i = c.iterator();
+      while (i.hasNext()) {
+        final KeyVal<ByteBuffer> kv = i.next();
+        assertThat(TestUtils.getNativeInt(kv.key()), is(list.pollFirst()));
+        assertThat(kv.val().getInt(), is(list.pollFirst()));
       }
+      assertThat(i.hasNext(), is(false));
+      i.next();
     }
   }
 
@@ -341,29 +396,28 @@ public void openTest() {
 
   @Test
   public void removeOddElements() {
-    for (final Dbi<ByteBuffer> db : dbs) {
-      verify(db, all(), 2, 4, 6, 8);
-      int idx = -1;
-      try (Txn<ByteBuffer> txn = env.txnWrite()) {
-        try (CursorIterable<ByteBuffer> ci = db.iterate(txn)) {
-          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
-          while (c.hasNext()) {
-            c.next();
-            idx++;
-            if (idx % 2 == 0) {
-              c.remove();
-            }
+    final Dbi<ByteBuffer> db = getDb();
+    verify(db, all(), 2, 4, 6, 8);
+    int idx = -1;
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn)) {
+        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+        while (c.hasNext()) {
+          c.next();
+          idx++;
+          if (idx % 2 == 0) {
+            c.remove();
           }
         }
-        txn.commit();
       }
-      verify(db, all(), 4, 8);
+      txn.commit();
     }
+    verify(db, all(), 4, 8);
   }
 
   @Test(expected = Env.AlreadyClosedException.class)
   public void nextWithClosedEnvTest() {
-    for (final Dbi<ByteBuffer> db : dbs) {
+    final Dbi<ByteBuffer> db = getDb();
       try (Txn<ByteBuffer> txn = env.txnRead()) {
         try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
           final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
@@ -372,12 +426,11 @@ public void nextWithClosedEnvTest() {
           c.next();
         }
       }
-    }
   }
 
   @Test(expected = Env.AlreadyClosedException.class)
   public void removeWithClosedEnvTest() {
-    for (final Dbi<ByteBuffer> db : dbs) {
+    final Dbi<ByteBuffer> db = getDb();
       try (Txn<ByteBuffer> txn = env.txnWrite()) {
         try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
           final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
@@ -389,12 +442,11 @@ public void removeWithClosedEnvTest() {
           c.remove();
         }
       }
-    }
   }
 
   @Test(expected = Env.AlreadyClosedException.class)
   public void hasNextWithClosedEnvTest() {
-    for (final Dbi<ByteBuffer> db : dbs) {
+    final Dbi<ByteBuffer> db = getDb();
       try (Txn<ByteBuffer> txn = env.txnRead()) {
         try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
           final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
@@ -403,21 +455,20 @@ public void hasNextWithClosedEnvTest() {
           c.hasNext();
         }
       }
-    }
   }
 
   @Test(expected = Env.AlreadyClosedException.class)
   public void forEachRemainingWithClosedEnvTest() {
-    for (final Dbi<ByteBuffer> db : dbs) {
+    final Dbi<ByteBuffer> db = getDb();
       try (Txn<ByteBuffer> txn = env.txnRead()) {
         try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
           final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
 
           env.close();
-          c.forEachRemaining(keyVal -> {});
+          c.forEachRemaining(keyVal -> {
+          });
         }
       }
-    }
   }
 
 //  @Test
@@ -469,9 +520,8 @@ public void forEachRemainingWithClosedEnvTest() {
 
   private void verify(final KeyRange<ByteBuffer> range, final int... expected) {
     // Verify using all comparator types
-    for (final Dbi<ByteBuffer> db : dbs) {
-      verify(range, db, expected);
-    }
+    final Dbi<ByteBuffer> db = getDb();
+    verify(range, db, expected);
   }
 
   private void verify(
@@ -485,7 +535,7 @@ private void verify(
     final List<Integer> results = new ArrayList<>();
 
     try (Txn<ByteBuffer> txn = env.txnRead();
-        CursorIterable<ByteBuffer> c = dbi.iterate(txn, range)) {
+         CursorIterable<ByteBuffer> c = dbi.iterate(txn, range)) {
       for (final KeyVal<ByteBuffer> kv : c) {
         final int key = kv.key().order(ByteOrder.nativeOrder()).getInt();
         final int val = kv.val().getInt();
@@ -499,4 +549,29 @@ private void verify(
       assertThat(results.get(idx), is(expected[idx]));
     }
   }
+
+  private Dbi<ByteBuffer> getDb() {
+    final Dbi<ByteBuffer> dbi = dbiFactory.factory.apply(env);
+    populateDatabase(dbi);
+    return dbi;
+  }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  private static class DbiFactory {
+    private final String name;
+    private final Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory;
+
+    private DbiFactory(String name, Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory) {
+      this.name = name;
+      this.factory = factory;
+    }
+
+    @Override
+    public String toString() {
+      return name;
+    }
+  }
 }
diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index bf2eb9eb..7bcbd851 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -77,8 +77,8 @@
 @RunWith(Parameterized.class)
 public final class CursorIterableTest {
 
-  private static final DbiFlagSet dbiFlagSet = MDB_CREATE;
-  private static final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
+  private static final DbiFlagSet DBI_FLAGS = MDB_CREATE;
+  private static final BufferProxy<ByteBuffer> BUFFER_PROXY = ByteBufferProxy.PROXY_OPTIMAL;
 
   @Rule
   public final TemporaryFolder tmp = new TemporaryFolder();
@@ -87,48 +87,35 @@ public final class CursorIterableTest {
   private Deque<Integer> list;
 
   /** Injected by {@link #data()} with appropriate runner. */
+  @SuppressWarnings("ClassEscapesDefinedScope")
   @Parameterized.Parameter
   public DbiFactory dbiFactory;
 
-  @Before
-  public void before() throws IOException {
-    final File path = tmp.newFile();
-    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
-    env =
-        create(bufferProxy)
-            .setMapSize(KIBIBYTES.toBytes(256))
-            .setMaxReaders(1)
-            .setMaxDbs(3)
-            .open(path, POSIX_MODE, MDB_NOSUBDIR);
-
-    populateTestDataList();
-  }
-
   @Parameterized.Parameters(name = "{index}: dbi: {0}")
   public static Object[] data() {
     final DbiFactory defaultComparator = new DbiFactory("defaultComparator", env ->
         env.buildDbi()
             .withDbName(DB_1)
             .withDefaultComparator()
-            .withDbiFlags(dbiFlagSet)
+            .withDbiFlags(DBI_FLAGS)
             .open());
     final DbiFactory nativeComparator = new DbiFactory("nativeComparator", env ->
         env.buildDbi()
             .withDbName(DB_2)
             .withNativeComparator()
-            .withDbiFlags(dbiFlagSet)
+            .withDbiFlags(DBI_FLAGS)
             .open());
     final DbiFactory callbackComparator = new DbiFactory("callbackComparator", env ->
         env.buildDbi()
             .withDbName(DB_3)
-            .withCallbackComparator(bufferProxy.getComparator(dbiFlagSet))
-            .withDbiFlags(dbiFlagSet)
+            .withCallbackComparator(BUFFER_PROXY.getComparator(DBI_FLAGS))
+            .withDbiFlags(DBI_FLAGS)
             .open());
     final DbiFactory iteratorComparator = new DbiFactory("iteratorComparator", env ->
         env.buildDbi()
             .withDbName(DB_4)
-            .withIteratorComparator(bufferProxy.getComparator(dbiFlagSet))
-            .withDbiFlags(dbiFlagSet)
+            .withIteratorComparator(BUFFER_PROXY.getComparator(DBI_FLAGS))
+            .withDbiFlags(DBI_FLAGS)
             .open());
     return new Object[] {
         defaultComparator,
@@ -137,6 +124,20 @@ public static Object[] data() {
         iteratorComparator};
   }
 
+  @Before
+  public void before() throws IOException {
+    final File path = tmp.newFile();
+    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
+    env =
+        create(bufferProxy)
+            .setMapSize(KIBIBYTES.toBytes(256))
+            .setMaxReaders(1)
+            .setMaxDbs(3)
+            .open(path, POSIX_MODE, MDB_NOSUBDIR);
+
+    populateTestDataList();
+  }
+
   @After
   public void after() {
     env.close();
diff --git a/src/test/java/org/lmdbjava/DbiBuilderTest.java b/src/test/java/org/lmdbjava/DbiBuilderTest.java
index da9341c6..74fbd8f5 100644
--- a/src/test/java/org/lmdbjava/DbiBuilderTest.java
+++ b/src/test/java/org/lmdbjava/DbiBuilderTest.java
@@ -45,7 +45,6 @@ public void after() {
 
   @Before
   public void before() throws IOException {
-    System.out.println("before");
     final File path = tmp.newFile();
     env = create()
         .setMapSize(MEBIBYTES.toBytes(64))

From 58dcc6e8bb1b393188ef3c1d86015ae15b50e1fb Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Wed, 29 Oct 2025 16:09:53 +0000
Subject: [PATCH 239/322] Tidy code

---
 .../java/org/lmdbjava/ByteArrayProxy.java     |   6 +-
 .../java/org/lmdbjava/ByteBufferProxy.java    |   2 +-
 .../CursorIterableIntegerDupTest.java         | 563 ++++++++++++++++++
 .../CursorIterableIntegerKeyTest.java         |  89 ---
 4 files changed, 566 insertions(+), 94 deletions(-)
 create mode 100644 src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java

diff --git a/src/main/java/org/lmdbjava/ByteArrayProxy.java b/src/main/java/org/lmdbjava/ByteArrayProxy.java
index d7c23919..82b7721c 100644
--- a/src/main/java/org/lmdbjava/ByteArrayProxy.java
+++ b/src/main/java/org/lmdbjava/ByteArrayProxy.java
@@ -36,8 +36,6 @@ public final class ByteArrayProxy extends BufferProxy<byte[]> {
 
   private static final MemoryManager MEM_MGR = RUNTIME.getMemoryManager();
 
-  private static final Comparator<byte[]> unsignedComparator = ByteArrayProxy::compareArrays;
-
   private ByteArrayProxy() {}
 
   /**
@@ -47,7 +45,7 @@ private ByteArrayProxy() {}
    * @param o2 right operand (required)
    * @return as specified by {@link Comparable} interface
    */
-  public static int compareArrays(final byte[] o1, final byte[] o2) {
+  public static int compareLexicographically(final byte[] o1, final byte[] o2) {
     requireNonNull(o1);
     requireNonNull(o2);
     if (o1 == o2) {
@@ -84,7 +82,7 @@ protected byte[] getBytes(final byte[] buffer) {
 
   @Override
   public Comparator<byte[]> getComparator(final DbiFlagSet dbiFlagSet) {
-    return unsignedComparator;
+    return ByteArrayProxy::compareLexicographically;
   }
 
   @Override
diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
index ca4deba3..89931587 100644
--- a/src/main/java/org/lmdbjava/ByteBufferProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -154,7 +154,7 @@ public static int compareLexicographically(final ByteBuffer o1, final ByteBuffer
      * Buffer comparator specifically for 4/8 byte keys that are unsigned ints/longs,
      * i.e. when using MDB_INTEGER_KEY/MDB_INTEGERDUP. Compares the buffers numerically.
      * <p>
-     * Both buffer must have 4 or 8 bytes remaining
+     * Both buffers must have 4 or 8 bytes remaining
      * </p>
      *
      * @param o1 left operand (required)
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
new file mode 100644
index 00000000..1acf4328
--- /dev/null
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
@@ -0,0 +1,563 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.hasSize;
+import static org.lmdbjava.DbiFlags.MDB_CREATE;
+import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
+import static org.lmdbjava.DbiFlags.MDB_INTEGERDUP;
+import static org.lmdbjava.Env.create;
+import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
+import static org.lmdbjava.KeyRange.all;
+import static org.lmdbjava.KeyRange.allBackward;
+import static org.lmdbjava.KeyRange.atLeast;
+import static org.lmdbjava.KeyRange.atLeastBackward;
+import static org.lmdbjava.KeyRange.atMost;
+import static org.lmdbjava.KeyRange.atMostBackward;
+import static org.lmdbjava.KeyRange.closed;
+import static org.lmdbjava.KeyRange.closedBackward;
+import static org.lmdbjava.KeyRange.closedOpen;
+import static org.lmdbjava.KeyRange.closedOpenBackward;
+import static org.lmdbjava.KeyRange.greaterThan;
+import static org.lmdbjava.KeyRange.greaterThanBackward;
+import static org.lmdbjava.KeyRange.lessThan;
+import static org.lmdbjava.KeyRange.lessThanBackward;
+import static org.lmdbjava.KeyRange.open;
+import static org.lmdbjava.KeyRange.openBackward;
+import static org.lmdbjava.KeyRange.openClosed;
+import static org.lmdbjava.KeyRange.openClosedBackward;
+import static org.lmdbjava.TestUtils.DB_1;
+import static org.lmdbjava.TestUtils.DB_2;
+import static org.lmdbjava.TestUtils.DB_3;
+import static org.lmdbjava.TestUtils.DB_4;
+import static org.lmdbjava.TestUtils.POSIX_MODE;
+import static org.lmdbjava.TestUtils.bb;
+import static org.lmdbjava.TestUtils.bbNative;
+import static org.lmdbjava.TestUtils.getNativeInt;
+
+import com.google.common.primitives.UnsignedBytes;
+import java.io.File;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.AbstractMap;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.Deque;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.hamcrest.CoreMatchers;
+import org.hamcrest.Matchers;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TemporaryFolder;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.lmdbjava.CursorIterable.KeyVal;
+
+/**
+ * Test {@link CursorIterable} using {@link DbiFlags#MDB_INTEGERKEY} to ensure that
+ * comparators work with native order integer keys.
+ */
+@Ignore // Waiting for the merge of stroomdev66's cursor tests
+@RunWith(Parameterized.class)
+public final class CursorIterableIntegerDupTest {
+
+  private static final DbiFlagSet DBI_FLAGS = DbiFlagSet.of(MDB_CREATE, MDB_INTEGERDUP, MDB_DUPSORT);
+  private static final BufferProxy<ByteBuffer> BUFFER_PROXY = ByteBufferProxy.PROXY_OPTIMAL;
+  private static final List<Map.Entry<Integer, Integer>> INPUT_DATA;
+
+  static {
+    // 2 => 21
+    // 2 => 22
+    // 3 => 31
+    // ...
+    // 9 => 92
+    INPUT_DATA = new ArrayList<>();
+    for (int i = 2; i <= 9; i++) {
+      final int val1 = (i * 10) + 1;
+      final int val2 = (i * 10) + 2;
+      INPUT_DATA.add(new AbstractMap.SimpleEntry<>(i, val1));
+      INPUT_DATA.add(new AbstractMap.SimpleEntry<>(i, val2));
+    }
+  }
+
+  @Rule
+  public final TemporaryFolder tmp = new TemporaryFolder();
+
+  private Env<ByteBuffer> env;
+  private Deque<Map.Entry<Integer, Integer>> expectedEntriesDeque;
+
+  /**
+   * Injected by {@link #data()} with appropriate runner.
+   */
+  @SuppressWarnings("ClassEscapesDefinedScope")
+  @Parameterized.Parameter
+  public DbiFactory dbiFactory;
+
+  @Parameterized.Parameters(name = "{index}: dbi: {0}")
+  public static Object[] data() {
+    final DbiFactory defaultComparator = new DbiFactory("defaultComparator", env ->
+        env.buildDbi()
+            .withDbName(DB_1)
+            .withDefaultComparator()
+            .withDbiFlags(DBI_FLAGS)
+            .open());
+    final DbiFactory nativeComparator = new DbiFactory("nativeComparator", env ->
+        env.buildDbi()
+            .withDbName(DB_2)
+            .withNativeComparator()
+            .withDbiFlags(DBI_FLAGS)
+            .open());
+    final DbiFactory callbackComparator = new DbiFactory("callbackComparator", env ->
+        env.buildDbi()
+            .withDbName(DB_3)
+            .withCallbackComparator(BUFFER_PROXY.getComparator(DBI_FLAGS))
+            .withDbiFlags(DBI_FLAGS)
+            .open());
+    final DbiFactory iteratorComparator = new DbiFactory("iteratorComparator", env ->
+        env.buildDbi()
+            .withDbName(DB_4)
+            .withIteratorComparator(BUFFER_PROXY.getComparator(DBI_FLAGS))
+            .withDbiFlags(DBI_FLAGS)
+            .open());
+    return new Object[]{
+        defaultComparator,
+        nativeComparator,
+        callbackComparator,
+        iteratorComparator};
+  }
+
+  @Before
+  public void before() throws IOException {
+    final File path = tmp.newFile();
+    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
+    env =
+        create(bufferProxy)
+            .setMapSize(KIBIBYTES.toBytes(256))
+            .setMaxReaders(1)
+            .setMaxDbs(3)
+            .open(path, POSIX_MODE, MDB_NOSUBDIR);
+
+    populateExpectedEntriesDeque();
+  }
+
+  @After
+  public void after() {
+    env.close();
+  }
+
+  @Test
+  public void allBackwardTest() {
+    verify(allBackward(), 8, 6, 4, 2);
+  }
+
+  @Test
+  public void allTest() {
+    verify(all(), 2, 4, 6, 8);
+  }
+
+  @Test
+  public void atLeastBackwardTest() {
+    verify(atLeastBackward(bbNative(5)), 4, 2);
+    verify(atLeastBackward(bbNative(6)), 6, 4, 2);
+    verify(atLeastBackward(bbNative(9)), 8, 6, 4, 2);
+  }
+
+  @Test
+  public void atLeastTest() {
+    verify(atLeast(bbNative(5)), 6, 8);
+    verify(atLeast(bbNative(6)), 6, 8);
+  }
+
+  @Test
+  public void atMostBackwardTest() {
+    verify(atMostBackward(bbNative(5)), 8, 6);
+    verify(atMostBackward(bbNative(6)), 8, 6);
+  }
+
+  @Test
+  public void atMostTest() {
+    verify(atMost(bbNative(5)), 2, 4);
+    verify(atMost(bbNative(6)), 2, 4, 6);
+  }
+
+  private void populateExpectedEntriesDeque() {
+    expectedEntriesDeque = new LinkedList<>();
+    expectedEntriesDeque.addAll(INPUT_DATA);
+  }
+
+  private void populateDatabase(final Dbi<ByteBuffer> dbi) {
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      final Cursor<ByteBuffer> c = dbi.openCursor(txn);
+      for (Map.Entry<Integer, Integer> entry : INPUT_DATA) {
+        c.put(bbNative(entry.getKey()), bb(entry.getValue()));
+      }
+      txn.commit();
+    }
+
+    try (Txn<ByteBuffer> txn = env.txnRead();
+         CursorIterable<ByteBuffer> c = dbi.iterate(txn)) {
+
+      for (final KeyVal<ByteBuffer> kv : c) {
+        System.out.print(getNativeInt(kv.key()) + " => " + kv.val().getInt());
+        System.out.print(", ");
+      }
+      System.out.println();
+    }
+  }
+
+  private int[] rangeInc(final int fromInc, final int toInc) {
+    int idx = 0;
+    if (fromInc <= toInc) {
+      // Forwards
+      final int[] arr = new int[toInc - fromInc + 1];
+      for (int i = fromInc; i <= toInc; i++) {
+        arr[idx++] = i;
+      }
+      return arr;
+    } else {
+      // Backwards
+      final int[] arr = new int[fromInc - toInc + 1];
+      for (int i = fromInc; i >= toInc; i--) {
+        arr[idx++] = i;
+      }
+      return arr;
+    }
+  }
+
+  @Test
+  public void closedBackwardTest() {
+    verify(closedBackward(bbNative(7), bbNative(3)), rangeInc(7, 3));
+    verify(closedBackward(bbNative(6), bbNative(2)), rangeInc(6, 2));
+    verify(closedBackward(bbNative(9), bbNative(3)), rangeInc(9, 3));
+  }
+
+  @Test
+  public void closedOpenBackwardTest() {
+    verify(closedOpenBackward(bbNative(8), bbNative(3)), rangeInc(8, 4));
+    verify(closedOpenBackward(bbNative(7), bbNative(2)), rangeInc(7, 3));
+    verify(closedOpenBackward(bbNative(9), bbNative(3)), rangeInc(9, 4));
+  }
+
+  @Test
+  public void closedOpenTest() {
+    verify(closedOpen(bbNative(3), bbNative(8)), rangeInc(3, 7));
+    verify(closedOpen(bbNative(2), bbNative(6)), rangeInc(2, 5));
+  }
+
+  @Test
+  public void closedTest() {
+    verify(closed(bbNative(3), bbNative(7)), rangeInc(3, 7));
+    verify(closed(bbNative(2), bbNative(6)), rangeInc(2, 6));
+    verify(closed(bbNative(1), bbNative(7)), rangeInc(2, 7));
+  }
+
+  @Test
+  public void greaterThanBackwardTest() {
+    verify(greaterThanBackward(bbNative(6)), rangeInc(5, 2));
+    verify(greaterThanBackward(bbNative(7)), rangeInc(6, 2));
+    verify(greaterThanBackward(bbNative(9)), rangeInc(8, 2));
+  }
+
+  @Test
+  public void greaterThanTest() {
+    verify(greaterThan(bbNative(4)), rangeInc(5, 9));
+    verify(greaterThan(bbNative(3)), rangeInc(4, 9));
+  }
+
+  @Test(expected = IllegalStateException.class)
+  public void iterableOnlyReturnedOnce() {
+    final Dbi<ByteBuffer> db = getDb();
+    try (Txn<ByteBuffer> txn = env.txnRead();
+         CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+      c.iterator(); // ok
+      c.iterator(); // fails
+    }
+  }
+
+  @Test
+  public void iterate() {
+    populateExpectedEntriesDeque();
+    final Dbi<ByteBuffer> db = getDb();
+    try (Txn<ByteBuffer> txn = env.txnRead();
+         CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+
+      for (final KeyVal<ByteBuffer> kv : c) {
+        final Map.Entry<Integer, Integer> entry = expectedEntriesDeque.pollFirst();
+//        System.out.println(entry.getKey() + " => " + entry.getValue());
+        assertThat(getNativeInt(kv.key()), is(entry.getKey()));
+        assertThat(kv.val().getInt(), is(entry.getValue()));
+      }
+    }
+  }
+
+  @Test(expected = IllegalStateException.class)
+  public void iteratorOnlyReturnedOnce() {
+    final Dbi<ByteBuffer> db = getDb();
+    try (Txn<ByteBuffer> txn = env.txnRead();
+         CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+      c.iterator(); // ok
+      c.iterator(); // fails
+    }
+  }
+
+  @Test
+  public void lessThanBackwardTest() {
+    verify(lessThanBackward(bbNative(5)), 8, 6);
+    verify(lessThanBackward(bbNative(2)), 8, 6, 4);
+  }
+
+  @Test
+  public void lessThanTest() {
+    verify(lessThan(bbNative(5)), 2, 4);
+    verify(lessThan(bbNative(8)), 2, 4, 6);
+  }
+
+  @Test(expected = NoSuchElementException.class)
+  public void nextThrowsNoSuchElementExceptionIfNoMoreElements() {
+    populateExpectedEntriesDeque();
+    final Dbi<ByteBuffer> db = getDb();
+    try (Txn<ByteBuffer> txn = env.txnRead();
+         CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+      final Iterator<KeyVal<ByteBuffer>> i = c.iterator();
+      while (i.hasNext()) {
+        final KeyVal<ByteBuffer> kv = i.next();
+        assertThat(getNativeInt(kv.key()), is(expectedEntriesDeque.pollFirst()));
+        assertThat(kv.val().getInt(), is(expectedEntriesDeque.pollFirst()));
+      }
+      assertThat(i.hasNext(), is(false));
+      i.next();
+    }
+  }
+
+  @Test
+  public void openBackwardTest() {
+    verify(openBackward(bbNative(7), bbNative(2)), 6, 4);
+    verify(openBackward(bbNative(8), bbNative(1)), 6, 4, 2);
+    verify(openBackward(bbNative(9), bbNative(4)), 8, 6);
+  }
+
+  @Test
+  public void openClosedBackwardTest() {
+    verify(openClosedBackward(bbNative(7), bbNative(2)), 6, 4, 2);
+    verify(openClosedBackward(bbNative(8), bbNative(4)), 6, 4);
+    verify(openClosedBackward(bbNative(9), bbNative(4)), 8, 6, 4);
+  }
+
+  @Test
+  public void openClosedBackwardTestWithGuava() {
+    final Comparator<byte[]> guava = UnsignedBytes.lexicographicalComparator();
+    final Comparator<ByteBuffer> comparator =
+        (bb1, bb2) -> {
+          final byte[] array1 = new byte[bb1.remaining()];
+          final byte[] array2 = new byte[bb2.remaining()];
+          bb1.mark();
+          bb2.mark();
+          bb1.get(array1);
+          bb2.get(array2);
+          bb1.reset();
+          bb2.reset();
+          return guava.compare(array1, array2);
+        };
+    final Dbi<ByteBuffer> guavaDbi = env.openDbi(DB_1, comparator, MDB_CREATE);
+    populateDatabase(guavaDbi);
+    verify(openClosedBackward(bbNative(7), bbNative(2)), guavaDbi, 6, 4, 2);
+    verify(openClosedBackward(bbNative(8), bbNative(4)), guavaDbi, 6, 4);
+  }
+
+  @Test
+  public void openClosedTest() {
+    verify(openClosed(bbNative(3), bbNative(8)), 4, 6, 8);
+    verify(openClosed(bbNative(2), bbNative(6)), 4, 6);
+  }
+
+  @Test
+  public void openTest() {
+    verify(open(bbNative(3), bbNative(7)), 4, 6);
+    verify(open(bbNative(2), bbNative(8)), 4, 6);
+  }
+
+  @Test
+  public void removeOddElements() {
+    final Dbi<ByteBuffer> db = getDb();
+    verify(db, all(), 2, 4, 6, 8);
+    int idx = -1;
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn)) {
+        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+        while (c.hasNext()) {
+          c.next();
+          idx++;
+          if (idx % 2 == 0) {
+            c.remove();
+          }
+        }
+      }
+      txn.commit();
+    }
+    verify(db, all(), 4, 8);
+  }
+
+  @Test(expected = Env.AlreadyClosedException.class)
+  public void nextWithClosedEnvTest() {
+    final Dbi<ByteBuffer> db = getDb();
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+        env.close();
+        c.next();
+      }
+    }
+  }
+
+  @Test(expected = Env.AlreadyClosedException.class)
+  public void removeWithClosedEnvTest() {
+    final Dbi<ByteBuffer> db = getDb();
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+        final KeyVal<ByteBuffer> keyVal = c.next();
+        assertThat(keyVal, Matchers.notNullValue());
+
+        env.close();
+        c.remove();
+      }
+    }
+  }
+
+  @Test(expected = Env.AlreadyClosedException.class)
+  public void hasNextWithClosedEnvTest() {
+    final Dbi<ByteBuffer> db = getDb();
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+        env.close();
+        c.hasNext();
+      }
+    }
+  }
+
+  @Test(expected = Env.AlreadyClosedException.class)
+  public void forEachRemainingWithClosedEnvTest() {
+    final Dbi<ByteBuffer> db = getDb();
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+        env.close();
+        c.forEachRemaining(keyVal -> {
+        });
+      }
+    }
+  }
+
+  private void verify(final KeyRange<ByteBuffer> range, final int... expectedKeys) {
+    // Verify using all comparator types
+    final Dbi<ByteBuffer> db = getDb();
+    verify(range, db, expectedKeys);
+  }
+
+  private void verify(final Dbi<ByteBuffer> dbi,
+                      final KeyRange<ByteBuffer> range,
+                      final int... expectedKeys) {
+    verify(range, dbi, expectedKeys);
+  }
+
+  private void verify(final KeyRange<ByteBuffer> range,
+                      final Dbi<ByteBuffer> dbi,
+                      final int... expectedKeys) {
+    final boolean isForward = range.getType().isDirectionForward();
+
+    final List<Integer> expectedValues = Arrays.stream(expectedKeys)
+        .boxed()
+        .flatMap(key -> {
+          final int base = key * 10;
+          return isForward
+              ? Stream.of(base + 1, base + 2)
+              : Stream.of(base + 2, base + 1);
+        })
+        .collect(Collectors.toList());
+
+    final List<Integer> results = new ArrayList<>();
+    System.out.println(rangeToString(range) + ", expected: " + expectedValues);
+
+    try (Txn<ByteBuffer> txn = env.txnRead();
+         CursorIterable<ByteBuffer> c = dbi.iterate(txn, range)) {
+      for (final KeyVal<ByteBuffer> kv : c) {
+        final int key = getNativeInt(kv.key());
+        final int val = kv.val().getInt();
+        System.out.println(key + " => " + val);
+        results.add(val);
+        assertThat(val, CoreMatchers.anyOf(
+            CoreMatchers.is((key * 10) + 1),
+            CoreMatchers.is((key * 10) + 2)));
+      }
+    }
+
+    assertThat(results, hasSize(expectedValues.size()));
+    for (int idx = 0; idx < results.size(); idx++) {
+      assertThat(results.get(idx), is(expectedValues.get(idx)));
+    }
+  }
+
+  private String rangeToString(final KeyRange<ByteBuffer> range) {
+    final ByteBuffer start = range.getStart();
+    final ByteBuffer stop = range.getStop();
+    return range.getType() + " start: " + (start != null ? getNativeInt(start) : "")
+        + " stop: " + (stop != null ? getNativeInt(stop) : "");
+  }
+
+  private Dbi<ByteBuffer> getDb() {
+    final Dbi<ByteBuffer> dbi = dbiFactory.factory.apply(env);
+    populateDatabase(dbi);
+    return dbi;
+  }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  private static class DbiFactory {
+    private final String name;
+    private final Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory;
+
+    private DbiFactory(String name, Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory) {
+      this.name = name;
+      this.factory = factory;
+    }
+
+    @Override
+    public String toString() {
+      return name;
+    }
+  }
+}
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
index 85c0a567..bac95e13 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
@@ -143,47 +143,6 @@ public void before() throws IOException {
             .open(path, POSIX_MODE, MDB_NOSUBDIR);
 
     populateTestDataList();
-//    final File path = tmp.newFile();
-//    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
-//    env =
-//        create(bufferProxy)
-//            .setMapSize(KIBIBYTES.toBytes(256))
-//            .setMaxReaders(1)
-//            .setMaxDbs(3)
-//            .open(path, POSIX_MODE, MDB_NOSUBDIR);
-//
-//    // Use a java comparator for start/stop keys only
-//    DbiFlagSet dbiFlagSet = DbiFlagSet.of(MDB_CREATE, MDB_INTEGERKEY);
-//
-//    dbJavaComparator = env.buildDbi()
-//        .withDbName(DB_1)
-//        .withIteratorComparator(bufferProxy.getComparator(dbiFlagSet))
-//        .withDbiFlags(dbiFlagSet)
-//        .open();
-//
-//    // Use LMDB comparator for start/stop keys
-//    dbLmdbComparator = env.buildDbi()
-//        .withDbName(DB_2)
-//        .withDefaultComparator()
-//        .withDbiFlags(dbiFlagSet)
-//        .open();
-//
-//    // Use a java comparator for start/stop keys and as a callback comparaotr
-//    dbCallbackComparator = env.buildDbi()
-//        .withDbName(DB_3)
-//        .withCallbackComparator(bufferProxy.getComparator(dbiFlagSet))
-//        .withDbiFlags(dbiFlagSet)
-//        .open();
-//
-//    populateTestDataList();
-//
-//    populateDatabase(dbJavaComparator);
-//    populateDatabase(dbLmdbComparator);
-//    populateDatabase(dbCallbackComparator);
-//
-//    dbs.add(dbJavaComparator);
-//    dbs.add(dbLmdbComparator);
-//    dbs.add(dbCallbackComparator);
   }
 
   @After
@@ -226,7 +185,6 @@ public void atMostTest() {
     verify(atMost(bbNative(6)), 2, 4, 6);
   }
 
-
   private void populateTestDataList() {
     list = new LinkedList<>();
     list.addAll(asList(2, 3, 4, 5, 6, 7, 8, 9));
@@ -471,53 +429,6 @@ public void forEachRemainingWithClosedEnvTest() {
       }
   }
 
-//  @Test
-//  public void testSignedVsUnsigned() {
-//    final ByteBuffer val1 = bbNative(1);
-//    final ByteBuffer val2 = bbNative(2);
-//    final ByteBuffer val110 = bbNative(110);
-//    final ByteBuffer val111 = bbNative(111);
-//    final ByteBuffer val150 = bbNative(150);
-//
-//    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
-//    final Comparator<ByteBuffer> unsignedComparator = bufferProxy.getUnsignedComparator();
-//    final Comparator<ByteBuffer> signedComparator = bufferProxy.getSignedComparator();
-//
-//    // Compare the same
-//    assertThat(
-//        unsignedComparator.compare(val1, val2), Matchers.is(signedComparator.compare(val1, val2)));
-//
-//    // Compare differently
-//    assertThat(
-//        unsignedComparator.compare(val110, val150),
-//        Matchers.not(signedComparator.compare(val110, val150)));
-//
-//    // Compare differently
-//    assertThat(
-//        unsignedComparator.compare(val111, val150),
-//        Matchers.not(signedComparator.compare(val111, val150)));
-//
-//    // This will fail if the db is using a signed comparator for the start/stop keys
-//    for (final Dbi<ByteBuffer> db : dbs) {
-//      db.put(val110, val110);
-//      db.put(val150, val150);
-//
-//      final ByteBuffer startKeyBuf = val111;
-//      KeyRange<ByteBuffer> keyRange = KeyRange.atLeastBackward(startKeyBuf);
-//
-//      try (Txn<ByteBuffer> txn = env.txnRead();
-//          CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
-//        for (final KeyVal<ByteBuffer> kv : c) {
-//          final int key = getNativeInt(kv.key());
-//          final int val = kv.val().getInt();
-//          //          System.out.println("key: " + key + " val: " + val);
-//          assertThat(key, is(110));
-//          break;
-//        }
-//      }
-//    }
-//  }
-
   private void verify(final KeyRange<ByteBuffer> range, final int... expected) {
     // Verify using all comparator types
     final Dbi<ByteBuffer> db = getDb();

From 26665ba0cfaafaa082d3e22feeb4080cb0bc7849 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Wed, 29 Oct 2025 17:45:21 +0000
Subject: [PATCH 240/322] Fix byte order issues with compareAsIntegerKeys

---
 src/main/java/org/lmdbjava/BufferProxy.java   |  4 -
 .../java/org/lmdbjava/ByteBufferProxy.java    | 32 ++++---
 src/main/java/org/lmdbjava/Dbi.java           | 30 ++++--
 src/main/java/org/lmdbjava/DbiFlagSet.java    |  6 ++
 src/main/java/org/lmdbjava/DbiFlags.java      |  2 +-
 .../java/org/lmdbjava/DirectBufferProxy.java  |  2 +-
 .../org/lmdbjava/ByteBufferProxyTest.java     | 39 +++++---
 .../CursorIterableIntegerKeyTest.java         | 96 +++++++++++++++++++
 src/test/java/org/lmdbjava/TestUtils.java     | 33 ++++++-
 9 files changed, 204 insertions(+), 40 deletions(-)

diff --git a/src/main/java/org/lmdbjava/BufferProxy.java b/src/main/java/org/lmdbjava/BufferProxy.java
index af0c7f06..f857ade7 100644
--- a/src/main/java/org/lmdbjava/BufferProxy.java
+++ b/src/main/java/org/lmdbjava/BufferProxy.java
@@ -40,10 +40,6 @@ public abstract class BufferProxy<T> {
   /** Offset from a pointer of the <code>MDB_val.mv_size</code> field. */
   protected static final int STRUCT_FIELD_OFFSET_SIZE = 0;
 
-  /** The set of {@link DbiFlags} that indicate unsigned integer keys are being used. */
-  protected static final DbiFlagSet INTEGER_KEY_FLAGS = DbiFlagSet.of(
-      DbiFlags.MDB_INTEGERKEY,
-      DbiFlags.MDB_INTEGERDUP);
 
   /** Explicitly-defined default constructor to avoid warnings. */
   protected BufferProxy() {}
diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
index 89931587..5d5aa2ca 100644
--- a/src/main/java/org/lmdbjava/ByteBufferProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -27,6 +27,7 @@
 import java.lang.reflect.Field;
 import java.nio.Buffer;
 import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
 import java.util.ArrayDeque;
 import java.util.Comparator;
 import jnr.ffi.Pointer;
@@ -153,9 +154,6 @@ public static int compareLexicographically(final ByteBuffer o1, final ByteBuffer
     /**
      * Buffer comparator specifically for 4/8 byte keys that are unsigned ints/longs,
      * i.e. when using MDB_INTEGER_KEY/MDB_INTEGERDUP. Compares the buffers numerically.
-     * <p>
-     * Both buffers must have 4 or 8 bytes remaining
-     * </p>
      *
      * @param o1 left operand (required)
      * @param o2 right operand (required)
@@ -164,26 +162,34 @@ public static int compareLexicographically(final ByteBuffer o1, final ByteBuffer
     public static int compareAsIntegerKeys(final ByteBuffer o1, final ByteBuffer o2) {
       requireNonNull(o1);
       requireNonNull(o2);
-      // Both buffers should be same len
+      // Both buffers should be same lenght according to LMDB API.
       final int len1 = o1.limit();
       final int len2 = o2.limit();
       if (len1 != len2) {
         throw new RuntimeException("Length mismatch, len1: " + len1 + ", len2: " + len2
             + ". Lengths must be identical and either 4 or 8 bytes.");
       }
-      final boolean reverse1 = o1.order() == LITTLE_ENDIAN;
-      final boolean reverse2 = o2.order() == LITTLE_ENDIAN;
+      // Keys for MDB_INTEGER_KEY are written in native order so ensure we read them in that order
+      o1.order(ByteOrder.nativeOrder());
+      o2.order(ByteOrder.nativeOrder());
+      // TODO it might be worth the DbiBuilder having a method to capture fixedKeyLength() or -1
+      //  for variable length keys. This can be passed to getComparator(..) so it can return a
+      //  comparator that doesn't need to test the length every time. There may be other benefits
+      //  to the Dbi knowing the key length if it is fixed.
       if (len1 == 8) {
-        final long lw = reverse1 ? Long.reverseBytes(o1.getLong(0)) : o1.getLong(0);
-        final long rw = reverse2 ? Long.reverseBytes(o2.getLong(0)) : o2.getLong(0);
+        final long lw = o1.getLong(0);
+        final long rw = o2.getLong(0);
         return Long.compareUnsigned(lw, rw);
       } else if (len1 == 4) {
-        final int lw = reverse1 ? Integer.reverseBytes(o1.getInt(0)) : o1.getInt(0);
-        final int rw = reverse2 ? Integer.reverseBytes(o2.getInt(0)) : o2.getInt(0);
+        final int lw = o1.getInt(0);
+        final int rw = o2.getInt(0);
         return Integer.compareUnsigned(lw, rw);
       } else {
-        throw new RuntimeException("Unexpected length1: " + len1
-            + ". Lengths must be identical and either 4 or 8 bytes.");
+        // size_t and int are likely to be 8bytes and 4bytes respectively on 64bit.
+        // If 32bit then would be 4/2 respectively.
+        // Short.compareUnsigned is not available in Java8.
+        // For now just fall back to our standard comparator
+        return compareLexicographically(o1, o2);
       }
     }
 
@@ -222,7 +228,7 @@ protected final ByteBuffer allocate() {
 
     @Override
     public Comparator<ByteBuffer> getComparator(final DbiFlagSet dbiFlagSet) {
-      if (dbiFlagSet.areAnySet(INTEGER_KEY_FLAGS)) {
+      if (dbiFlagSet.areAnySet(DbiFlagSet.INTEGER_KEY_FLAGS)) {
         return AbstractByteBufferProxy::compareAsIntegerKeys;
       } else {
         return AbstractByteBufferProxy::compareLexicographically;
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index bcb1ccfc..5e8fa2f2 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -82,15 +82,27 @@ public final class Dbi<T> {
     if (nativeCb) {
       requireNonNull(comparator, "comparator cannot be null if nativeCb is set");
       // LMDB will call back to this comparator for insertion/iteration order
-      this.callbackComparator =
-          (keyA, keyB) -> {
-            final T compKeyA  = proxy.out(proxy.allocate(), keyA);
-            final T compKeyB = proxy.out(proxy.allocate(), keyB);
-            final int result = this.comparator.compare(compKeyA, compKeyB);
-            proxy.deallocate(compKeyA);
-            proxy.deallocate(compKeyB);
-            return result;
-          };
+//      if (dbiFlagSet.areAnySet(DbiFlagSet.INTEGER_KEY_FLAGS)) {
+//        this.callbackComparator =
+//            (keyA, keyB) -> {
+//              final T compKeyA  = proxy.out(proxy.allocate(), keyA);
+//              final T compKeyB = proxy.out(proxy.allocate(), keyB);
+//              final int result = this.comparator.compare(compKeyA, compKeyB);
+//              proxy.deallocate(compKeyA);
+//              proxy.deallocate(compKeyB);
+//              return result;
+//            };
+//      } else {
+        this.callbackComparator =
+            (keyA, keyB) -> {
+              final T compKeyA  = proxy.out(proxy.allocate(), keyA);
+              final T compKeyB = proxy.out(proxy.allocate(), keyB);
+              final int result = this.comparator.compare(compKeyA, compKeyB);
+              proxy.deallocate(compKeyA);
+              proxy.deallocate(compKeyB);
+              return result;
+            };
+//      }
       LIB.mdb_set_compare(txn.pointer(), ptr, callbackComparator);
     } else {
       callbackComparator = null;
diff --git a/src/main/java/org/lmdbjava/DbiFlagSet.java b/src/main/java/org/lmdbjava/DbiFlagSet.java
index 5edf10c7..5a0bc83e 100644
--- a/src/main/java/org/lmdbjava/DbiFlagSet.java
+++ b/src/main/java/org/lmdbjava/DbiFlagSet.java
@@ -21,8 +21,14 @@
 
 public interface DbiFlagSet extends FlagSet<DbiFlags> {
 
+  /** An immutable empty {@link DbiFlagSet}. */
   DbiFlagSet EMPTY = DbiFlagSetImpl.EMPTY;
 
+  /** The set of {@link DbiFlags} that indicate unsigned integer keys are being used. */
+  DbiFlagSet INTEGER_KEY_FLAGS = DbiFlagSet.of(
+      DbiFlags.MDB_INTEGERKEY,
+      DbiFlags.MDB_INTEGERDUP);
+
   static DbiFlagSet empty() {
     return DbiFlagSetImpl.EMPTY;
   }
diff --git a/src/main/java/org/lmdbjava/DbiFlags.java b/src/main/java/org/lmdbjava/DbiFlags.java
index 10952da9..7c4b6794 100644
--- a/src/main/java/org/lmdbjava/DbiFlags.java
+++ b/src/main/java/org/lmdbjava/DbiFlags.java
@@ -41,7 +41,7 @@ public enum DbiFlags implements MaskedFlag, DbiFlagSet {
   MDB_DUPSORT(0x04),
   /**
    * Numeric keys in native byte order: either unsigned int or size_t.
-   * The keys must all be of the same size.
+   * <strong>The keys must all be of the same size.</strong>
    * <p>
    * This is an optimisation that is available when your keys are 4 or 8 byte unsigned numeric values.
    * There are performance benefits for both ordered and un-ordered puts as compared to not using
diff --git a/src/main/java/org/lmdbjava/DirectBufferProxy.java b/src/main/java/org/lmdbjava/DirectBufferProxy.java
index 9c90d98b..180eee0a 100644
--- a/src/main/java/org/lmdbjava/DirectBufferProxy.java
+++ b/src/main/java/org/lmdbjava/DirectBufferProxy.java
@@ -138,7 +138,7 @@ protected DirectBuffer allocate() {
 
   @Override
   public Comparator<DirectBuffer> getComparator(final DbiFlagSet dbiFlagSet) {
-    if (dbiFlagSet.areAnySet(INTEGER_KEY_FLAGS)) {
+    if (dbiFlagSet.areAnySet(DbiFlagSet.INTEGER_KEY_FLAGS)) {
       return DirectBufferProxy::compareAsIntegerKeys;
     } else {
       return DirectBufferProxy::compareLexicographically;
diff --git a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
index 1372b74a..c7d8333f 100644
--- a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
+++ b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
@@ -40,6 +40,7 @@
 import java.io.IOException;
 import java.lang.reflect.Field;
 import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
 import java.time.Duration;
 import java.time.Instant;
 import java.util.Comparator;
@@ -158,8 +159,10 @@ public void comparatorPerformance() {
     int x = 0;
     for (int rounds = 0; rounds < 100; rounds++) {
       for (int i = 1; i < values.length; i++) {
-        buffer1.putLong(0, values[i - 1]);
-        buffer2.putLong(0, values[i]);
+        buffer1.order(ByteOrder.nativeOrder())
+            .putLong(0, values[i - 1]);
+        buffer2.order(ByteOrder.nativeOrder())
+            .putLong(0, values[i]);
         final int result = ByteBufferProxy.AbstractByteBufferProxy.compareAsIntegerKeys(buffer1, buffer2);
         x += result;
       }
@@ -170,8 +173,10 @@ public void comparatorPerformance() {
     x = 0;
     for (int rounds = 0; rounds < 100; rounds++) {
       for (int i = 1; i < values.length; i++) {
-        buffer1.putLong(0, values[i - 1]);
-        buffer2.putLong(0, values[i]);
+        buffer1.order(BIG_ENDIAN)
+            .putLong(0, values[i - 1]);
+        buffer2.order(BIG_ENDIAN)
+            .putLong(0, values[i]);
         final int result = ByteBufferProxy.AbstractByteBufferProxy.compareLexicographically(buffer1, buffer2);
         x += result;
       }
@@ -182,10 +187,14 @@ public void comparatorPerformance() {
   @Test
   public void verifyComparators() {
     final Random random = new Random(203948);
-    final ByteBuffer buffer1 = ByteBuffer.allocateDirect(Long.BYTES);
-    final ByteBuffer buffer2 = ByteBuffer.allocateDirect(Long.BYTES);
-    buffer1.limit(Long.BYTES);
-    buffer2.limit(Long.BYTES);
+    final ByteBuffer buffer1native = ByteBuffer.allocateDirect(Long.BYTES).order(ByteOrder.nativeOrder());
+    final ByteBuffer buffer2native = ByteBuffer.allocateDirect(Long.BYTES).order(ByteOrder.nativeOrder());
+    final ByteBuffer buffer1be = ByteBuffer.allocateDirect(Long.BYTES).order(BIG_ENDIAN);
+    final ByteBuffer buffer2be = ByteBuffer.allocateDirect(Long.BYTES).order(BIG_ENDIAN);
+    buffer1native.limit(Long.BYTES);
+    buffer2native.limit(Long.BYTES);
+    buffer1be.limit(Long.BYTES);
+    buffer2be.limit(Long.BYTES);
     final long[] values = random.longs(10_000_000).toArray();
 
     final LinkedHashMap<String, Comparator<ByteBuffer>> comparators = new LinkedHashMap<>();
@@ -198,13 +207,21 @@ public void verifyComparators() {
     for (int i = 1; i < values.length; i++) {
       final long val1 = values[i - 1];
       final long val2 = values[i];
-      buffer1.putLong(0, val1);
-      buffer2.putLong(0, val2);
+      buffer1native.putLong(0, val1);
+      buffer2native.putLong(0, val2);
+      buffer1be.putLong(0, val1);
+      buffer2be.putLong(0, val2);
       uniqueResults.clear();
 
       // Make sure all comparators give the same result for the same inputs
       comparators.forEach((name, comparator) -> {
-        final int result = comparator.compare(buffer1, buffer2);
+        final int result;
+        // IntegerKey comparator expects keys to have been written in native order so need different buffers.
+        if (name.equals("compareAsIntegerKeys")) {
+          result = comparator.compare(buffer1native, buffer2native);
+        } else {
+          result = comparator.compare(buffer1be, buffer2be);
+        }
         results.put(name, result);
         uniqueResults.add(result);
       });
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
index bac95e13..be91ea4c 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
@@ -51,20 +51,24 @@
 import static org.lmdbjava.TestUtils.bb;
 import static org.lmdbjava.TestUtils.bbNative;
 import static org.lmdbjava.TestUtils.getNativeInt;
+import static org.lmdbjava.TestUtils.getString;
 
 import com.google.common.primitives.UnsignedBytes;
 import java.io.File;
 import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
+import java.util.AbstractMap;
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.Deque;
 import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.function.Function;
+import java.util.stream.Collectors;
 import org.hamcrest.Matchers;
 import org.junit.After;
 import org.junit.Before;
@@ -150,6 +154,98 @@ public void after() {
     env.close();
   }
 
+  @Test
+  public void testNumericOrderLong() {
+    final Dbi<ByteBuffer> dbi = dbiFactory.factory.apply(env);
+
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      final Cursor<ByteBuffer> c = dbi.openCursor(txn);
+      long i = 1;
+      while (true) {
+//        System.out.println("putting " + i);
+        c.put(bbNative(i), bb(i + "-long"));
+          final long i2 = i * 10;
+          if (i2 < i) {
+            // Overflowed
+            break;
+          }
+        i = i2;
+      }
+      txn.commit();
+    }
+
+    final List<Map.Entry<Long, String>> entries = new ArrayList<>();
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      try (CursorIterable<ByteBuffer> iterable = dbi.iterate(txn)) {
+        for (KeyVal<ByteBuffer> keyVal : iterable) {
+          final String val = getString(keyVal.val());
+          final long key = TestUtils.getNativeLong(keyVal.key());
+          entries.add(new AbstractMap.SimpleEntry<>(key, val));
+//          System.out.println(val);
+        }
+      }
+    }
+
+    final List<Long> dbKeys = entries.stream()
+        .map(Map.Entry::getKey)
+        .collect(Collectors.toList());
+    final List<Long> dbKeysSorted = entries.stream()
+        .map(Map.Entry::getKey)
+        .sorted()
+        .collect(Collectors.toList());
+    for (int i = 0; i < dbKeys.size(); i++) {
+      final long dbKey1 = dbKeys.get(i);
+      final long dbKey2 = dbKeysSorted.get(i);
+      assertThat(dbKey1, is(dbKey2));
+    }
+  }
+
+  @Test
+  public void testNumericOrderInt() {
+    final Dbi<ByteBuffer> dbi = dbiFactory.factory.apply(env);
+
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      final Cursor<ByteBuffer> c = dbi.openCursor(txn);
+      int i = 1;
+      while (true) {
+//        System.out.println("putting " + i);
+        c.put(bbNative(i), bb(i + "-int"));
+        final int i2 = i * 10;
+        if (i2 < i) {
+          // Overflowed
+          break;
+        }
+        i = i2;
+      }
+      txn.commit();
+    }
+
+    final List<Map.Entry<Integer, String>> entries = new ArrayList<>();
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      try (CursorIterable<ByteBuffer> iterable = dbi.iterate(txn)) {
+        for (KeyVal<ByteBuffer> keyVal : iterable) {
+          final String val = getString(keyVal.val());
+          final int key = TestUtils.getNativeInt(keyVal.key());
+          entries.add(new AbstractMap.SimpleEntry<>(key, val));
+//          System.out.println(val);
+        }
+      }
+    }
+
+    final List<Integer> dbKeys = entries.stream()
+        .map(Map.Entry::getKey)
+        .collect(Collectors.toList());
+    final List<Integer> dbKeysSorted = entries.stream()
+        .map(Map.Entry::getKey)
+        .sorted()
+        .collect(Collectors.toList());
+    for (int i = 0; i < dbKeys.size(); i++) {
+      final long dbKey1 = dbKeys.get(i);
+      final long dbKey2 = dbKeysSorted.get(i);
+      assertThat(dbKey1, is(dbKey2));
+    }
+  }
+
   @Test
   public void allBackwardTest() {
     verify(allBackward(), 8, 6, 4, 2);
diff --git a/src/test/java/org/lmdbjava/TestUtils.java b/src/test/java/org/lmdbjava/TestUtils.java
index c26c1c52..511619fe 100644
--- a/src/test/java/org/lmdbjava/TestUtils.java
+++ b/src/test/java/org/lmdbjava/TestUtils.java
@@ -24,6 +24,7 @@
 import java.lang.reflect.InvocationTargetException;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
+import java.nio.charset.StandardCharsets;
 import org.agrona.MutableDirectBuffer;
 import org.agrona.concurrent.UnsafeBuffer;
 
@@ -55,13 +56,29 @@ static ByteBuffer bb(final int value) {
     return bb;
   }
 
+  static ByteBuffer bb(final String value) {
+    final ByteBuffer bb = allocateDirect(100);
+    if (value != null) {
+      bb.put(value.getBytes(StandardCharsets.UTF_8));
+      bb.flip();
+    }
+    return bb;
+  }
+
   static ByteBuffer bbNative(final int value) {
-    final ByteBuffer bb = allocateDirect(Long.BYTES)
+    final ByteBuffer bb = allocateDirect(Integer.BYTES)
         .order(ByteOrder.nativeOrder());
     bb.putInt(value).flip();
     return bb;
   }
 
+  static ByteBuffer bbNative(final long value) {
+    final ByteBuffer bb = allocateDirect(Long.BYTES)
+        .order(ByteOrder.nativeOrder());
+    bb.putLong(value).flip();
+    return bb;
+  }
+
   static int getNativeInt(final ByteBuffer bb) {
     final int val = bb.order(ByteOrder.nativeOrder())
         .getInt();
@@ -69,6 +86,20 @@ static int getNativeInt(final ByteBuffer bb) {
     return val;
   }
 
+  static long getNativeLong(final ByteBuffer bb) {
+    final long val = bb.order(ByteOrder.nativeOrder())
+        .getLong();
+    bb.rewind();
+    return val;
+  }
+
+  static String getString(final ByteBuffer bb) {
+    final String str = StandardCharsets.UTF_8.decode(bb)
+        .toString();
+    bb.rewind();
+    return str;
+  }
+
   static void invokePrivateConstructor(final Class<?> clazz) {
     try {
       final Constructor<?> c = clazz.getDeclaredConstructor();

From dc0b96b4ab5489bd986f58895a35b653166016fb Mon Sep 17 00:00:00 2001
From: stroomdev66 <stroomdev66@gmail.com>
Date: Wed, 29 Oct 2025 19:02:36 +0000
Subject: [PATCH 241/322] #267 Fix to establish start key when iterating
 backwards from a start key using DUPSORT

---
 .gitignore                                    |   2 +-
 cross-compile.sh                              |   1 +
 .../java/org/lmdbjava/CursorIterable.java     |  34 +-
 src/main/java/org/lmdbjava/KeyRangeType.java  |  64 +-
 .../org/lmdbjava/ByteBufferProxyTest.java     |  23 +-
 .../org/lmdbjava/CursorIterableRangeTest.java | 430 +++++-----
 .../java/org/lmdbjava/CursorIterableTest.java |   9 +-
 .../java/org/lmdbjava/CursorParamTest.java    |   3 +-
 src/test/java/org/lmdbjava/CursorTest.java    |   7 +-
 src/test/java/org/lmdbjava/DbiTest.java       |  49 +-
 src/test/java/org/lmdbjava/EnvTest.java       | 546 ++++++-------
 src/test/java/org/lmdbjava/FileUtil.java      |  41 -
 .../org/lmdbjava/GarbageCollectionTest.java   |  97 +--
 src/test/java/org/lmdbjava/TempDir.java       |  57 ++
 src/test/java/org/lmdbjava/TestUtils.java     |   9 +
 src/test/java/org/lmdbjava/TutorialTest.java  | 734 +++++++++---------
 src/test/java/org/lmdbjava/TxnTest.java       |  10 +-
 src/test/java/org/lmdbjava/VerifierTest.java  |  27 +-
 .../testSignedComparatorDupsort.csv           |   2 +-
 .../testUnsignedComparatorDupsort.csv         |  13 +-
 20 files changed, 1097 insertions(+), 1061 deletions(-)
 create mode 100644 src/test/java/org/lmdbjava/TempDir.java

diff --git a/.gitignore b/.gitignore
index f46b8b6f..44fe1d51 100644
--- a/.gitignore
+++ b/.gitignore
@@ -16,5 +16,5 @@ dependency-reduced-pom.xml
 gpg-sign.json
 mvn-sync.json
 secrets.tar
-lmdb
+openldap
 pom.xml.versionsBackup
diff --git a/cross-compile.sh b/cross-compile.sh
index 5243feec..18d4ce07 100755
--- a/cross-compile.sh
+++ b/cross-compile.sh
@@ -20,6 +20,7 @@ set -o errexit
 
 rm -rf openldap
 git clone --depth 1 --branch LMDB_0.9.33 https://git.openldap.org/openldap/openldap.git
+rm -rf openldap/.git
 pushd openldap/libraries/liblmdb
 trap popd SIGINT
 
diff --git a/src/main/java/org/lmdbjava/CursorIterable.java b/src/main/java/org/lmdbjava/CursorIterable.java
index 6a03bd90..b6d58e3d 100644
--- a/src/main/java/org/lmdbjava/CursorIterable.java
+++ b/src/main/java/org/lmdbjava/CursorIterable.java
@@ -15,11 +15,7 @@
  */
 package org.lmdbjava;
 
-import static org.lmdbjava.CursorIterable.State.RELEASED;
-import static org.lmdbjava.CursorIterable.State.REQUIRES_INITIAL_OP;
-import static org.lmdbjava.CursorIterable.State.REQUIRES_ITERATOR_OP;
-import static org.lmdbjava.CursorIterable.State.REQUIRES_NEXT_OP;
-import static org.lmdbjava.CursorIterable.State.TERMINATED;
+import static org.lmdbjava.CursorIterable.State.*;
 import static org.lmdbjava.GetOp.MDB_SET_RANGE;
 
 import java.util.Comparator;
@@ -101,7 +97,7 @@ public void remove() {
   }
 
   private void executeCursorOp(final CursorOp op) {
-    final boolean found;
+    boolean found;
     switch (op) {
       case FIRST:
         found = cursor.first();
@@ -119,7 +115,31 @@ private void executeCursorOp(final CursorOp op) {
         found = cursor.get(range.getStart(), MDB_SET_RANGE);
         break;
       case GET_START_KEY_BACKWARD:
-        found = cursor.get(range.getStart(), MDB_SET_RANGE) || cursor.last();
+        found = cursor.get(range.getStart(), MDB_SET_RANGE);
+        if (found) {
+          if (!range.getType().isDirectionForward()
+              && range.getType().isStartKeyRequired()
+              && range.getType().isStartKeyInclusive()) {
+            // We need to ensure we move to the last matching key if using DUPSORT, see issue 267
+            boolean loop = true;
+            while (loop) {
+              if (comparator.compare(cursor.key(), range.getStart()) <= 0) {
+                found = cursor.next();
+                if (!found) {
+                  // We got to the end so move last.
+                  found = cursor.last();
+                  loop = false;
+                }
+              } else {
+                // We have moved past so go back one.
+                found = cursor.prev();
+                loop = false;
+              }
+            }
+          }
+        } else {
+          found = cursor.last();
+        }
         break;
       default:
         throw new IllegalStateException("Unknown cursor operation");
diff --git a/src/main/java/org/lmdbjava/KeyRangeType.java b/src/main/java/org/lmdbjava/KeyRangeType.java
index ad67286d..0514cbf2 100644
--- a/src/main/java/org/lmdbjava/KeyRangeType.java
+++ b/src/main/java/org/lmdbjava/KeyRangeType.java
@@ -46,7 +46,7 @@ public enum KeyRangeType {
    *
    * <p>In our example, the returned keys would be 2, 4, 6 and 8.
    */
-  FORWARD_ALL(true, false, false),
+  FORWARD_ALL(true, false, false, false, false),
   /**
    * Start on the passed key (or the first key immediately after it) and iterate forward until no
    * keys remain.
@@ -56,7 +56,7 @@ public enum KeyRangeType {
    * <p>In our example and with a passed search key of 5, the returned keys would be 6 and 8. With a
    * passed key of 6, the returned keys would be 6 and 8.
    */
-  FORWARD_AT_LEAST(true, true, false),
+  FORWARD_AT_LEAST(true, true, true, false, false),
   /**
    * Start on the first key and iterate forward until a key equal to it (or the first key
    * immediately after it) is reached.
@@ -66,7 +66,7 @@ public enum KeyRangeType {
    * <p>In our example and with a passed search key of 5, the returned keys would be 2 and 4. With a
    * passed key of 6, the returned keys would be 2, 4 and 6.
    */
-  FORWARD_AT_MOST(true, false, true),
+  FORWARD_AT_MOST(true, false, false, true, true),
   /**
    * Iterate forward between the passed keys, matching on the first keys directly equal to the
    * passed key (or immediately following it in the case of the "start" key, or immediately
@@ -77,7 +77,7 @@ public enum KeyRangeType {
    * <p>In our example and with a passed search range of 3 - 7, the returned keys would be 4 and 6.
    * With a range of 2 - 6, the keys would be 2, 4 and 6.
    */
-  FORWARD_CLOSED(true, true, true),
+  FORWARD_CLOSED(true, true, true, true, true),
   /**
    * Iterate forward between the passed keys, matching on the first keys directly equal to the
    * passed key (or immediately following it in the case of the "start" key, or immediately
@@ -88,7 +88,7 @@ public enum KeyRangeType {
    * <p>In our example and with a passed search range of 3 - 8, the returned keys would be 4 and 6.
    * With a range of 2 - 6, the keys would be 2 and 4.
    */
-  FORWARD_CLOSED_OPEN(true, true, true),
+  FORWARD_CLOSED_OPEN(true, true, true, true, false),
   /**
    * Start after the passed key (but not equal to it) and iterate forward until no keys remain.
    *
@@ -97,7 +97,7 @@ public enum KeyRangeType {
    * <p>In our example and with a passed search key of 4, the returned keys would be 6 and 8. With a
    * passed key of 3, the returned keys would be 4, 6 and 8.
    */
-  FORWARD_GREATER_THAN(true, true, false),
+  FORWARD_GREATER_THAN(true, true, false, false, false),
   /**
    * Start on the first key and iterate forward until a key the passed key has been reached (but do
    * not return that key).
@@ -107,7 +107,7 @@ public enum KeyRangeType {
    * <p>In our example and with a passed search key of 5, the returned keys would be 2 and 4. With a
    * passed key of 8, the returned keys would be 2, 4 and 6.
    */
-  FORWARD_LESS_THAN(true, false, true),
+  FORWARD_LESS_THAN(true, false, false, true, false),
   /**
    * Iterate forward between the passed keys but not equal to either of them.
    *
@@ -116,7 +116,7 @@ public enum KeyRangeType {
    * <p>In our example and with a passed search range of 3 - 7, the returned keys would be 4 and 6.
    * With a range of 2 - 8, the key would be 4 and 6.
    */
-  FORWARD_OPEN(true, true, true),
+  FORWARD_OPEN(true, true, false, true, false),
   /**
    * Iterate forward between the passed keys. Do not return the "start" key, but do return the
    * "stop" key.
@@ -126,7 +126,7 @@ public enum KeyRangeType {
    * <p>In our example and with a passed search range of 3 - 8, the returned keys would be 4, 6 and
    * 8. With a range of 2 - 6, the keys would be 4 and 6.
    */
-  FORWARD_OPEN_CLOSED(true, true, true),
+  FORWARD_OPEN_CLOSED(true, true, false, true, true),
   /**
    * Start on the last key and iterate backward until no keys remain.
    *
@@ -134,7 +134,7 @@ public enum KeyRangeType {
    *
    * <p>In our example, the returned keys would be 8, 6, 4 and 2.
    */
-  BACKWARD_ALL(false, false, false),
+  BACKWARD_ALL(false, false, false, false, false),
   /**
    * Start on the passed key (or the first key immediately preceding it) and iterate backward until
    * no keys remain.
@@ -145,7 +145,7 @@ public enum KeyRangeType {
    * passed key of 6, the returned keys would be 6, 4 and 2. With a passed key of 9, the returned
    * keys would be 8, 6, 4 and 2.
    */
-  BACKWARD_AT_LEAST(false, true, false),
+  BACKWARD_AT_LEAST(false, true, true, false, false),
   /**
    * Start on the last key and iterate backward until a key equal to it (or the first key
    * immediately preceding it it) is reached.
@@ -155,7 +155,7 @@ public enum KeyRangeType {
    * <p>In our example and with a passed search key of 5, the returned keys would be 8 and 6. With a
    * passed key of 6, the returned keys would be 8 and 6.
    */
-  BACKWARD_AT_MOST(false, false, true),
+  BACKWARD_AT_MOST(false, false, false, true, true),
   /**
    * Iterate backward between the passed keys, matching on the first keys directly equal to the
    * passed key (or immediately preceding it in the case of the "start" key, or immediately
@@ -167,7 +167,7 @@ public enum KeyRangeType {
    * With a range of 6 - 2, the keys would be 6, 4 and 2. With a range of 9 - 3, the returned keys
    * would be 8, 6 and 4.
    */
-  BACKWARD_CLOSED(false, true, true),
+  BACKWARD_CLOSED(false, true, true, true, true),
   /**
    * Iterate backward between the passed keys, matching on the first keys directly equal to the
    * passed key (or immediately preceding it in the case of the "start" key, or immediately
@@ -179,7 +179,7 @@ public enum KeyRangeType {
    * 4. With a range of 7 - 2, the keys would be 6 and 4. With a range of 9 - 3, the keys would be
    * 8, 6 and 4.
    */
-  BACKWARD_CLOSED_OPEN(false, true, true),
+  BACKWARD_CLOSED_OPEN(false, true, true, true, false),
   /**
    * Start immediate prior to the passed key (but not equal to it) and iterate backward until no
    * keys remain.
@@ -190,7 +190,7 @@ public enum KeyRangeType {
    * passed key of 7, the returned keys would be 6, 4 and 2. With a passed key of 9, the returned
    * keys would be 8, 6, 4 and 2.
    */
-  BACKWARD_GREATER_THAN(false, true, false),
+  BACKWARD_GREATER_THAN(false, true, false, false, false),
   /**
    * Start on the last key and iterate backward until the last key greater than the passed "stop"
    * key is reached. Do not return the "stop" key.
@@ -200,7 +200,7 @@ public enum KeyRangeType {
    * <p>In our example and with a passed search key of 5, the returned keys would be 8 and 6. With a
    * passed key of 2, the returned keys would be 8, 6 and 4
    */
-  BACKWARD_LESS_THAN(false, false, true),
+  BACKWARD_LESS_THAN(false, false, false, true, false),
   /**
    * Iterate backward between the passed keys, but do not return the passed keys.
    *
@@ -210,7 +210,7 @@ public enum KeyRangeType {
    * With a range of 8 - 1, the keys would be 6, 4 and 2. With a range of 9 - 4, the keys would be 8
    * and 6.
    */
-  BACKWARD_OPEN(false, true, true),
+  BACKWARD_OPEN(false, true, false, true, false),
   /**
    * Iterate backward between the passed keys. Do not return the "start" key, but do return the
    * "stop" key.
@@ -221,19 +221,25 @@ public enum KeyRangeType {
    * 2. With a range of 8 - 4, the keys would be 6 and 4. With a range of 9 - 4, the keys would be
    * 8, 6 and 4.
    */
-  BACKWARD_OPEN_CLOSED(false, true, true);
+  BACKWARD_OPEN_CLOSED(false, true, false, true, true);
 
   private final boolean directionForward;
   private final boolean startKeyRequired;
+  private final boolean startKeyInclusive;
   private final boolean stopKeyRequired;
+  private final boolean stopKeyInclusive;
 
   KeyRangeType(
       final boolean directionForward,
       final boolean startKeyRequired,
-      final boolean stopKeyRequired) {
+      final boolean startKeyInclusive,
+      final boolean stopKeyRequired,
+      final boolean stopKeyInclusive) {
     this.directionForward = directionForward;
     this.startKeyRequired = startKeyRequired;
+    this.startKeyInclusive = startKeyInclusive;
     this.stopKeyRequired = stopKeyRequired;
+    this.stopKeyInclusive = stopKeyInclusive;
   }
 
   /**
@@ -254,6 +260,16 @@ public boolean isStartKeyRequired() {
     return startKeyRequired;
   }
 
+  /**
+   * Is the start key to be treated as inclusive in the range.
+   *
+   * @return true if start key is inclusive. False if not inclusive or no start key is required by
+   *     the range type.
+   */
+  public boolean isStartKeyInclusive() {
+    return startKeyInclusive;
+  }
+
   /**
    * Whether the iteration requires a "stop" key.
    *
@@ -263,6 +279,16 @@ public boolean isStopKeyRequired() {
     return stopKeyRequired;
   }
 
+  /**
+   * Is the stop key to be treated as inclusive in the range.
+   *
+   * @return true if stop key is inclusive. False if not inclusive or no stop key is required by the
+   *     range type.
+   */
+  public boolean isStopKeyInclusive() {
+    return stopKeyInclusive;
+  }
+
   /**
    * Determine the iterator action to take when iterator first begins.
    *
diff --git a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
index 82c0abce..d5638fe2 100644
--- a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
+++ b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
@@ -36,6 +36,7 @@
 
 import java.lang.reflect.Field;
 import java.nio.ByteBuffer;
+import java.nio.file.Path;
 import jnr.ffi.Pointer;
 import jnr.ffi.provider.MemoryManager;
 import org.junit.jupiter.api.Test;
@@ -51,17 +52,17 @@ public final class ByteBufferProxyTest {
   void buffersMustBeDirect() {
     assertThatThrownBy(
             () -> {
-              FileUtil.useTempDir(
-                  dir -> {
-                    try (Env<ByteBuffer> env = create().setMaxReaders(1).open(dir.toFile())) {
-                      final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
-                      final ByteBuffer key = allocate(100);
-                      key.putInt(1).flip();
-                      final ByteBuffer val = allocate(100);
-                      val.putInt(1).flip();
-                      db.put(key, val); // error
-                    }
-                  });
+              try (final TempDir tempDir = new TempDir()) {
+                final Path dir = tempDir.createTempDir();
+                try (final Env<ByteBuffer> env = create().setMaxReaders(1).open(dir.toFile())) {
+                  final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+                  final ByteBuffer key = allocate(100);
+                  key.putInt(1).flip();
+                  final ByteBuffer val = allocate(100);
+                  val.putInt(1).flip();
+                  db.put(key, val); // error
+                }
+              }
             })
         .isInstanceOf(BufferMustBeDirectException.class);
   }
diff --git a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
index bff6593e..dd33e885 100644
--- a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
@@ -16,162 +16,175 @@
 
 package org.lmdbjava;
 
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.CsvFileSource;
-import org.lmdbjava.ByteBufferProxy.AbstractByteBufferProxy;
-import org.lmdbjava.CursorIterable.KeyVal;
+import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
+import static java.nio.ByteBuffer.allocateDirect;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.lmdbjava.DbiFlags.*;
+import static org.lmdbjava.Env.create;
+import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
+import static org.lmdbjava.TestUtils.*;
 
 import java.io.*;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
-import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.Comparator;
 import java.util.EnumSet;
 import java.util.function.BiConsumer;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvFileSource;
+import org.lmdbjava.ByteBufferProxy.AbstractByteBufferProxy;
+import org.lmdbjava.CursorIterable.KeyVal;
 
-import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
-import static java.nio.ByteBuffer.allocateDirect;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.lmdbjava.DbiFlags.*;
-import static org.lmdbjava.Env.create;
-import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
-import static org.lmdbjava.TestUtils.*;
-
-/**
- * Test {@link CursorIterable}.
- */
+/** Test {@link CursorIterable}. */
 public final class CursorIterableRangeTest {
 
   @ParameterizedTest(name = "{index} => {0}: ({1}, {2})")
   @CsvFileSource(resources = "/CursorIterableRangeTest/testSignedComparator.csv")
-  void testSignedComparator(final String keyType, final String startKey, final String stopKey, final String expectedKV) {
-    testCSV(ByteBuffer::compareTo,
-            true,
-            createBasicDBPopulator(),
-            EnumSet.of(MDB_CREATE),
-            keyType,
-            startKey,
-            stopKey,
-            expectedKV);
+  void testSignedComparator(
+      final String keyType, final String startKey, final String stopKey, final String expectedKV) {
+    testCSV(
+        ByteBuffer::compareTo,
+        true,
+        createBasicDBPopulator(),
+        EnumSet.of(MDB_CREATE),
+        keyType,
+        startKey,
+        stopKey,
+        expectedKV);
   }
 
   @ParameterizedTest(name = "{index} => {0}: ({1}, {2})")
   @CsvFileSource(resources = "/CursorIterableRangeTest/testUnsignedComparator.csv")
-  void testUnsignedComparator(final String keyType, final String startKey, final String stopKey, final String expectedKV) {
-    testCSV(AbstractByteBufferProxy::compareBuff,
-            false,
-            createBasicDBPopulator(),
-            EnumSet.of(MDB_CREATE),
-            keyType,
-            startKey,
-            stopKey,
-            expectedKV);
+  void testUnsignedComparator(
+      final String keyType, final String startKey, final String stopKey, final String expectedKV) {
+    testCSV(
+        AbstractByteBufferProxy::compareBuff,
+        false,
+        createBasicDBPopulator(),
+        EnumSet.of(MDB_CREATE),
+        keyType,
+        startKey,
+        stopKey,
+        expectedKV);
   }
 
   @ParameterizedTest(name = "{index} => {0}: ({1}, {2})")
   @CsvFileSource(resources = "/CursorIterableRangeTest/testSignedComparatorDupsort.csv")
-  void testSignedComparatorDupsort(final String keyType, final String startKey, final String stopKey, final String expectedKV) {
-    testCSV(ByteBuffer::compareTo,
-            true,
-            createMultiDBPopulator(2),
-            EnumSet.of(MDB_CREATE, MDB_DUPSORT),
-            keyType,
-            startKey,
-            stopKey,
-            expectedKV);
+  void testSignedComparatorDupsort(
+      final String keyType, final String startKey, final String stopKey, final String expectedKV) {
+    testCSV(
+        ByteBuffer::compareTo,
+        true,
+        createMultiDBPopulator(2),
+        EnumSet.of(MDB_CREATE, MDB_DUPSORT),
+        keyType,
+        startKey,
+        stopKey,
+        expectedKV);
   }
 
   @ParameterizedTest(name = "{index} => {0}: ({1}, {2})")
   @CsvFileSource(resources = "/CursorIterableRangeTest/testUnsignedComparatorDupsort.csv")
-  void testUnsignedComparatorDupsort(final String keyType, final String startKey, final String stopKey, final String expectedKV) {
-    testCSV(AbstractByteBufferProxy::compareBuff,
-            false,
-            createMultiDBPopulator(2),
-            EnumSet.of(MDB_CREATE, MDB_DUPSORT),
-            keyType,
-            startKey,
-            stopKey,
-            expectedKV);
+  void testUnsignedComparatorDupsort(
+      final String keyType, final String startKey, final String stopKey, final String expectedKV) {
+    testCSV(
+        AbstractByteBufferProxy::compareBuff,
+        false,
+        createMultiDBPopulator(2),
+        EnumSet.of(MDB_CREATE, MDB_DUPSORT),
+        keyType,
+        startKey,
+        stopKey,
+        expectedKV);
   }
 
   @ParameterizedTest(name = "{index} => {0}: ({1}, {2})")
   @CsvFileSource(resources = "/CursorIterableRangeTest/testIntegerKey.csv")
-  void testIntegerKey(final String keyType, final String startKey, final String stopKey, final String expectedKV) {
-    testCSV(AbstractByteBufferProxy::compareBuff,
-            false,
-            createIntegerDBPopulator(),
-            EnumSet.of(MDB_CREATE, MDB_INTEGERKEY),
-            keyType,
-            startKey,
-            stopKey,
-            expectedKV,
-            Integer.BYTES,
-            ByteOrder.LITTLE_ENDIAN);
+  void testIntegerKey(
+      final String keyType, final String startKey, final String stopKey, final String expectedKV) {
+    testCSV(
+        AbstractByteBufferProxy::compareBuff,
+        false,
+        createIntegerDBPopulator(),
+        EnumSet.of(MDB_CREATE, MDB_INTEGERKEY),
+        keyType,
+        startKey,
+        stopKey,
+        expectedKV,
+        Integer.BYTES,
+        ByteOrder.LITTLE_ENDIAN);
   }
 
   @ParameterizedTest(name = "{index} => {0}: ({1}, {2})")
   @CsvFileSource(resources = "/CursorIterableRangeTest/testLongKey.csv")
-  void testLongKey(final String keyType, final String startKey, final String stopKey, final String expectedKV) {
-    testCSV(AbstractByteBufferProxy::compareBuff,
-            false,
-            createLongDBPopulator(),
-            EnumSet.of(MDB_CREATE, MDB_INTEGERKEY),
-            keyType,
-            startKey,
-            stopKey,
-            expectedKV,
-            Long.BYTES,
-            ByteOrder.LITTLE_ENDIAN);
+  void testLongKey(
+      final String keyType, final String startKey, final String stopKey, final String expectedKV) {
+    testCSV(
+        AbstractByteBufferProxy::compareBuff,
+        false,
+        createLongDBPopulator(),
+        EnumSet.of(MDB_CREATE, MDB_INTEGERKEY),
+        keyType,
+        startKey,
+        stopKey,
+        expectedKV,
+        Long.BYTES,
+        ByteOrder.LITTLE_ENDIAN);
   }
 
-
-  private void testCSV(final Comparator<ByteBuffer> comparator,
-                       final boolean nativeCb,
-                       final BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> dbPopulator,
-                       final EnumSet<DbiFlags> flags,
-                       final String keyType,
-                       final String startKey,
-                       final String stopKey,
-                       final String expectedKV) {
-    testCSV(comparator, nativeCb, dbPopulator, flags, keyType, startKey, stopKey, expectedKV, Integer.BYTES, ByteOrder.BIG_ENDIAN);
+  private void testCSV(
+      final Comparator<ByteBuffer> comparator,
+      final boolean nativeCb,
+      final BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> dbPopulator,
+      final EnumSet<DbiFlags> flags,
+      final String keyType,
+      final String startKey,
+      final String stopKey,
+      final String expectedKV) {
+    testCSV(
+        comparator,
+        nativeCb,
+        dbPopulator,
+        flags,
+        keyType,
+        startKey,
+        stopKey,
+        expectedKV,
+        Integer.BYTES,
+        ByteOrder.BIG_ENDIAN);
   }
 
-  private void testCSV(final Comparator<ByteBuffer> comparator,
-                       final boolean nativeCb,
-                       final BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> dbPopulator,
-                       final EnumSet<DbiFlags> flags,
-                       final String keyType,
-                       final String startKey,
-                       final String stopKey,
-                       final String expectedKV,
-                       final int keyLen,
-                       final ByteOrder byteOrder) {
-    FileUtil.useTempFile(file -> {
+  private void testCSV(
+      final Comparator<ByteBuffer> comparator,
+      final boolean nativeCb,
+      final BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> dbPopulator,
+      final EnumSet<DbiFlags> flags,
+      final String keyType,
+      final String startKey,
+      final String stopKey,
+      final String expectedKV,
+      final int keyLen,
+      final ByteOrder byteOrder) {
+    try (final TempDir tempDir = new TempDir()) {
+      final Path file = tempDir.createTempFile();
       try (final Env<ByteBuffer> env =
-                   create()
-                           .setMapSize(KIBIBYTES.toBytes(256))
-                           .setMaxReaders(1)
-                           .setMaxDbs(1)
-                           .open(file.toFile(), POSIX_MODE, MDB_NOSUBDIR)) {
-        final Dbi<ByteBuffer> dbi = env.openDbi(DB_1, comparator, nativeCb, flags.toArray(new DbiFlags[0]));
+          create()
+              .setMapSize(KIBIBYTES.toBytes(256))
+              .setMaxReaders(1)
+              .setMaxDbs(1)
+              .open(file.toFile(), POSIX_MODE, MDB_NOSUBDIR)) {
+        final Dbi<ByteBuffer> dbi =
+            env.openDbi(DB_1, comparator, nativeCb, flags.toArray(new DbiFlags[0]));
         dbPopulator.accept(env, dbi);
-
-//      final File tests = new File("src/test/resources/CursorIterableRangeTest/tests.csv");
-//      final File actual = tests.getParentFile().toPath().resolve(testName + ".actual").toFile();
-//      final File expected = tests.getParentFile().toPath().resolve(testName + ".expected").toFile();
-//      final String csv = readFile(tests);
-//      final String[] parts = csv.split("\n");
         try (final Writer writer = new StringWriter()) {
-//        for (final String part : parts) {
-//          final String[] params = part.split(",");
           final KeyRangeType keyRangeType = KeyRangeType.valueOf(keyType.trim());
           ByteBuffer start = parseKey(startKey, keyLen, byteOrder);
           ByteBuffer stop = parseKey(stopKey, keyLen, byteOrder);
 
           final KeyRange<ByteBuffer> keyRange = new KeyRange<>(keyRangeType, start, stop);
           try (Txn<ByteBuffer> txn = env.txnRead();
-               CursorIterable<ByteBuffer> c = dbi.iterate(txn, keyRange)) {
+              CursorIterable<ByteBuffer> c = dbi.iterate(txn, keyRange)) {
             for (final KeyVal<ByteBuffer> kv : c) {
               final long key = getLong(kv.key(), byteOrder);
               final long val = getLong(kv.val(), byteOrder);
@@ -186,19 +199,11 @@ private void testCSV(final Comparator<ByteBuffer> comparator,
         } catch (final IOException e) {
           throw new UncheckedIOException(e);
         }
-
-
-//      // Compare files.
-//      final String act = readFile(actual);
-//      final String exp = readFile(expected);
-//      assertThat(act).withFailMessage("Files are not equal").isEqualTo(exp);
       }
-    });
+    }
   }
 
-  private ByteBuffer parseKey(final String key,
-                              final int keyLen,
-                              final ByteOrder byteOrder) {
+  private ByteBuffer parseKey(final String key, final int keyLen, final ByteOrder byteOrder) {
     if (key != null) {
       if (ByteOrder.LITTLE_ENDIAN.equals(byteOrder)) {
         if (keyLen == Integer.BYTES) {
@@ -217,8 +222,7 @@ private ByteBuffer parseKey(final String key,
     return null;
   }
 
-  private long getLong(final ByteBuffer byteBuffer,
-                       final ByteOrder byteOrder) {
+  private long getLong(final ByteBuffer byteBuffer, final ByteOrder byteOrder) {
     byteBuffer.order(byteOrder);
     if (byteBuffer.remaining() == Integer.BYTES) {
       return byteBuffer.getInt();
@@ -227,92 +231,95 @@ private long getLong(final ByteBuffer byteBuffer,
     }
   }
 
-//
-//  @Test
-//  void testSignedComparator() throws IOException {
-//    test(ByteBuffer::compareTo, true, "testSignedComparator", 1, MDB_CREATE);
-//  }
-//
-//  @Test
-//  void testUnsignedComparator() throws IOException {
-//    test(AbstractByteBufferProxy::compareBuff, false, "testUnsignedComparator", 1, MDB_CREATE);
-//  }
-//
-//  @Test
-//  void testSignedComparatorDupsort() throws IOException {
-//    test(ByteBuffer::compareTo, true, "testSignedComparatorDupsort", 2, MDB_CREATE, MDB_DUPSORT);
-//  }
-//
-//  @Test
-//  void testUnsignedComparatorDupsort() throws IOException {
-//    test(AbstractByteBufferProxy::compareBuff, false, "testUnsignedComparatorDupsort", 2, MDB_CREATE, MDB_DUPSORT);
-//  }
-
-  private void test(final Comparator<ByteBuffer> comparator,
-                    final boolean nativeCb,
-                    final String testName,
-                    final BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> dbPopulator,
-                    final DbiFlags... flags) throws IOException {
-    final Path dbPath = Files.createTempFile("test", "db");
-    try (final Env<ByteBuffer> env =
-                 create()
-                         .setMapSize(KIBIBYTES.toBytes(256))
-                         .setMaxReaders(1)
-                         .setMaxDbs(1)
-                         .open(dbPath.toFile(), POSIX_MODE, MDB_NOSUBDIR)) {
-      final Dbi<ByteBuffer> dbi = env.openDbi(DB_1, comparator, nativeCb, flags);
-      dbPopulator.accept(env, dbi);
-
-      final File tests = new File("src/test/resources/CursorIterableRangeTest/tests.csv");
-      final File actual = tests.getParentFile().toPath().resolve(testName + ".actual").toFile();
-      final File expected = tests.getParentFile().toPath().resolve(testName + ".expected").toFile();
-      final String csv = readFile(tests);
-      final String[] parts = csv.split("\n");
-      try (final Writer writer = new FileWriter(actual)) {
-        for (final String part : parts) {
-          final String[] params = part.split(",");
-          final KeyRangeType keyRangeType = KeyRangeType.valueOf(params[0].trim());
-          ByteBuffer start = null;
-          ByteBuffer stop = null;
-          if (params.length > 1 && params[1].trim().length() > 0) {
-            start = bb(Integer.parseInt(params[1].trim()));
-          }
-          if (params.length > 2 && params[2].trim().length() > 0) {
-            stop = bb(Integer.parseInt(params[2].trim()));
-          }
-
-          for (int i = 0; i < 3; i++) {
-            if (params.length > i) {
-              writer.append(params[i].trim());
-            }
-            writer.append(",");
-          }
-
-          final KeyRange<ByteBuffer> keyRange = new KeyRange<>(keyRangeType, start, stop);
-          try (Txn<ByteBuffer> txn = env.txnRead();
-               CursorIterable<ByteBuffer> c = dbi.iterate(txn, keyRange)) {
-            for (final KeyVal<ByteBuffer> kv : c) {
-              final int key = kv.key().getInt();
-              final int val = kv.val().getInt();
-              writer.append("[");
-              writer.append(String.valueOf(key));
-              writer.append(" ");
-              writer.append(String.valueOf(val));
-              writer.append("]");
-            }
-          }
-          writer.append("\n");
-        }
-      }
-
-      // Compare files.
-      final String act = readFile(actual);
-      final String exp = readFile(expected);
-      assertThat(act).withFailMessage("Files are not equal").isEqualTo(exp);
-    } finally {
-      FileUtil.deleteFile(dbPath);
-    }
-  }
+  //
+  //  @Test
+  //  void testSignedComparator() throws IOException {
+  //    test(ByteBuffer::compareTo, true, "testSignedComparator", 1, MDB_CREATE);
+  //  }
+  //
+  //  @Test
+  //  void testUnsignedComparator() throws IOException {
+  //    test(AbstractByteBufferProxy::compareBuff, false, "testUnsignedComparator", 1, MDB_CREATE);
+  //  }
+  //
+  //  @Test
+  //  void testSignedComparatorDupsort() throws IOException {
+  //    test(ByteBuffer::compareTo, true, "testSignedComparatorDupsort", 2, MDB_CREATE,
+  // MDB_DUPSORT);
+  //  }
+  //
+  //  @Test
+  //  void testUnsignedComparatorDupsort() throws IOException {
+  //    test(AbstractByteBufferProxy::compareBuff, false, "testUnsignedComparatorDupsort", 2,
+  // MDB_CREATE, MDB_DUPSORT);
+  //  }
+  //
+  //  private void test(final Comparator<ByteBuffer> comparator,
+  //                    final boolean nativeCb,
+  //                    final String testName,
+  //                    final BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> dbPopulator,
+  //                    final DbiFlags... flags) throws IOException {
+  //    final Path dbPath = Files.createTempFile("test", "db");
+  //    try (final Env<ByteBuffer> env =
+  //                 create()
+  //                         .setMapSize(KIBIBYTES.toBytes(256))
+  //                         .setMaxReaders(1)
+  //                         .setMaxDbs(1)
+  //                         .open(dbPath.toFile(), POSIX_MODE, MDB_NOSUBDIR)) {
+  //      final Dbi<ByteBuffer> dbi = env.openDbi(DB_1, comparator, nativeCb, flags);
+  //      dbPopulator.accept(env, dbi);
+  //
+  //      final File tests = new File("src/test/resources/CursorIterableRangeTest/tests.csv");
+  //      final File actual = tests.getParentFile().toPath().resolve(testName + ".actual").toFile();
+  //      final File expected = tests.getParentFile().toPath().resolve(testName +
+  // ".expected").toFile();
+  //      final String csv = readFile(tests);
+  //      final String[] parts = csv.split("\n");
+  //      try (final Writer writer = new FileWriter(actual)) {
+  //        for (final String part : parts) {
+  //          final String[] params = part.split(",");
+  //          final KeyRangeType keyRangeType = KeyRangeType.valueOf(params[0].trim());
+  //          ByteBuffer start = null;
+  //          ByteBuffer stop = null;
+  //          if (params.length > 1 && params[1].trim().length() > 0) {
+  //            start = bb(Integer.parseInt(params[1].trim()));
+  //          }
+  //          if (params.length > 2 && params[2].trim().length() > 0) {
+  //            stop = bb(Integer.parseInt(params[2].trim()));
+  //          }
+  //
+  //          for (int i = 0; i < 3; i++) {
+  //            if (params.length > i) {
+  //              writer.append(params[i].trim());
+  //            }
+  //            writer.append(",");
+  //          }
+  //
+  //          final KeyRange<ByteBuffer> keyRange = new KeyRange<>(keyRangeType, start, stop);
+  //          try (Txn<ByteBuffer> txn = env.txnRead();
+  //               CursorIterable<ByteBuffer> c = dbi.iterate(txn, keyRange)) {
+  //            for (final KeyVal<ByteBuffer> kv : c) {
+  //              final int key = kv.key().getInt();
+  //              final int val = kv.val().getInt();
+  //              writer.append("[");
+  //              writer.append(String.valueOf(key));
+  //              writer.append(" ");
+  //              writer.append(String.valueOf(val));
+  //              writer.append("]");
+  //            }
+  //          }
+  //          writer.append("\n");
+  //        }
+  //      }
+  //
+  //      // Compare files.
+  //      final String act = readFile(actual);
+  //      final String exp = readFile(expected);
+  //      assertThat(act).withFailMessage("Files are not equal").isEqualTo(exp);
+  //    } finally {
+  //      FileUtil.deleteFile(dbPath);
+  //    }
+  //  }
 
   private BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> createBasicDBPopulator() {
     return (env, dbi) -> {
@@ -367,16 +374,15 @@ private BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> createLongDBPopulator() {
         c.put(bbLeLong(Long.MIN_VALUE), bb(1));
         c.put(bbLeLong(-1000), bb(2));
         c.put(bbLeLong(0), bb(3));
-        c.put(bbLeLong( 1000), bb(4));
+        c.put(bbLeLong(1000), bb(4));
         c.put(bbLeLong(Long.MAX_VALUE), bb(5));
         txn.commit();
       }
     };
   }
 
-  private void populateDatabase(final Env<ByteBuffer> env,
-                                final Dbi<ByteBuffer> dbi,
-                                final int copies) {
+  private void populateDatabase(
+      final Env<ByteBuffer> env, final Dbi<ByteBuffer> dbi, final int copies) {
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       final Cursor<ByteBuffer> c = dbi.openCursor(txn);
       for (int i = 0; i < copies; i++) {
diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index 9cceb437..5e515fee 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -48,7 +48,6 @@
 
 import com.google.common.primitives.UnsignedBytes;
 import java.nio.ByteBuffer;
-import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.Deque;
@@ -64,20 +63,20 @@
 /** Test {@link CursorIterable}. */
 public final class CursorIterableTest {
 
-  private Path file;
+  private TempDir tempDir;
   private Dbi<ByteBuffer> db;
   private Env<ByteBuffer> env;
   private Deque<Integer> list;
 
   @BeforeEach
   void beforeEach() {
-    file = FileUtil.createTempFile();
+    tempDir = new TempDir();
     env =
         create()
             .setMapSize(KIBIBYTES.toBytes(256))
             .setMaxReaders(1)
             .setMaxDbs(1)
-            .open(file.toFile(), POSIX_MODE, MDB_NOSUBDIR);
+            .open(tempDir.createTempFile().toFile(), POSIX_MODE, MDB_NOSUBDIR);
     db = env.openDbi(DB_1, MDB_CREATE);
     populateDatabase(db);
   }
@@ -98,7 +97,7 @@ private void populateDatabase(final Dbi<ByteBuffer> dbi) {
   @AfterEach
   void afterEach() {
     env.close();
-    FileUtil.deleteFile(file);
+    tempDir.cleanup();
   }
 
   @Test
diff --git a/src/test/java/org/lmdbjava/CursorParamTest.java b/src/test/java/org/lmdbjava/CursorParamTest.java
index 1a3604be..7f0bad8a 100644
--- a/src/test/java/org/lmdbjava/CursorParamTest.java
+++ b/src/test/java/org/lmdbjava/CursorParamTest.java
@@ -58,7 +58,8 @@ public final class CursorParamTest {
 
   static Stream<Arguments> data() {
     return Stream.of(
-        Arguments.argumentSet("ByteBufferRunner(PROXY_OPTIMAL)", new ByteBufferRunner(PROXY_OPTIMAL)),
+        Arguments.argumentSet(
+            "ByteBufferRunner(PROXY_OPTIMAL)", new ByteBufferRunner(PROXY_OPTIMAL)),
         Arguments.argumentSet("ByteBufferRunner(PROXY_SAFE)", new ByteBufferRunner(PROXY_SAFE)),
         Arguments.argumentSet("ByteArrayRunner(PROXY_BA)", new ByteArrayRunner(PROXY_BA)),
         Arguments.argumentSet("DirectBufferRunner", new DirectBufferRunner()),
diff --git a/src/test/java/org/lmdbjava/CursorTest.java b/src/test/java/org/lmdbjava/CursorTest.java
index f44a9a44..530b2e80 100644
--- a/src/test/java/org/lmdbjava/CursorTest.java
+++ b/src/test/java/org/lmdbjava/CursorTest.java
@@ -54,12 +54,13 @@
 /** Test {@link Cursor}. */
 public final class CursorTest {
 
-  private Path file;
   private Env<ByteBuffer> env;
+  private TempDir tempDir;
 
   @BeforeEach
   void beforeEach() {
-    file = FileUtil.createTempFile();
+    tempDir = new TempDir();
+    Path file = tempDir.createTempFile();
     env =
         create(PROXY_OPTIMAL)
             .setMapSize(MEBIBYTES.toBytes(1))
@@ -71,7 +72,7 @@ void beforeEach() {
   @AfterEach
   void afterEach() {
     env.close();
-    FileUtil.deleteFile(file);
+    tempDir.cleanup();
   }
 
   @Test
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index cb106550..2c4a90b7 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -62,21 +62,21 @@
 /** Test {@link Dbi}. */
 public final class DbiTest {
 
-  private Path file;
+  private TempDir tempDir;
   private Env<ByteBuffer> env;
-  private Path fileBa;
   private Env<byte[]> envBa;
 
   @BeforeEach
   void beforeEach() {
-    file = FileUtil.createTempFile();
+    tempDir = new TempDir();
+    final Path file = tempDir.createTempFile();
     env =
         create()
             .setMapSize(MEBIBYTES.toBytes(64))
             .setMaxReaders(2)
             .setMaxDbs(2)
             .open(file.toFile(), MDB_NOSUBDIR);
-    fileBa = FileUtil.createTempFile();
+    final Path fileBa = tempDir.createTempFile();
     envBa =
         create(PROXY_BA)
             .setMapSize(MEBIBYTES.toBytes(64))
@@ -89,8 +89,7 @@ void beforeEach() {
   void afterEach() {
     env.close();
     envBa.close();
-    FileUtil.deleteFile(file);
-    FileUtil.deleteFile(fileBa);
+    tempDir.cleanup();
   }
 
   @Test
@@ -362,26 +361,24 @@ void putCommitGet() {
 
   @Test
   void putCommitGetByteArray() {
-    FileUtil.useTempFile(
-        file -> {
-          try (Env<byte[]> envBa =
-              create(PROXY_BA)
-                  .setMapSize(MEBIBYTES.toBytes(64))
-                  .setMaxReaders(1)
-                  .setMaxDbs(2)
-                  .open(file.toFile(), MDB_NOSUBDIR)) {
-            final Dbi<byte[]> db = envBa.openDbi(DB_1, MDB_CREATE);
-            try (Txn<byte[]> txn = envBa.txnWrite()) {
-              db.put(txn, ba(5), ba(5));
-              txn.commit();
-            }
-            try (Txn<byte[]> txn = envBa.txnWrite()) {
-              final byte[] found = db.get(txn, ba(5));
-              assertThat(found).isNotNull();
-              assertThat(fromBa(txn.val())).isEqualTo(5);
-            }
-          }
-        });
+    final Path file = tempDir.createTempFile();
+    try (Env<byte[]> envBa =
+        create(PROXY_BA)
+            .setMapSize(MEBIBYTES.toBytes(64))
+            .setMaxReaders(1)
+            .setMaxDbs(2)
+            .open(file.toFile(), MDB_NOSUBDIR)) {
+      final Dbi<byte[]> db = envBa.openDbi(DB_1, MDB_CREATE);
+      try (Txn<byte[]> txn = envBa.txnWrite()) {
+        db.put(txn, ba(5), ba(5));
+        txn.commit();
+      }
+      try (Txn<byte[]> txn = envBa.txnWrite()) {
+        final byte[] found = db.get(txn, ba(5));
+        assertThat(found).isNotNull();
+        assertThat(fromBa(txn.val())).isEqualTo(5);
+      }
+    }
   }
 
   @Test
diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index 904159bb..d66aa3a3 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -37,43 +37,49 @@
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.Random;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.lmdbjava.Env.AlreadyClosedException;
-import org.lmdbjava.Env.AlreadyOpenException;
-import org.lmdbjava.Env.Builder;
-import org.lmdbjava.Env.InvalidCopyDestination;
-import org.lmdbjava.Env.MapFullException;
+import org.lmdbjava.Env.*;
 import org.lmdbjava.Txn.BadReaderLockException;
 
 /** Test {@link Env}. */
 public final class EnvTest {
 
+  private TempDir tempDir;
+
+  @BeforeEach
+  void beforeEach() {
+    tempDir = new TempDir();
+  }
+
+  @AfterEach
+  void afterEach() {
+    tempDir.cleanup();
+  }
+
   @Test
   void byteUnit() {
-    FileUtil.useTempFile(
-        file -> {
-          try (Env<ByteBuffer> env =
-              create()
-                  .setMaxReaders(1)
-                  .setMapSize(MEBIBYTES.toBytes(1))
-                  .open(file.toFile(), MDB_NOSUBDIR)) {
-            final EnvInfo info = env.info();
-            assertThat(info.mapSize).isEqualTo(MEBIBYTES.toBytes(1));
-          }
-        });
+    final Path file = tempDir.createTempFile();
+    try (Env<ByteBuffer> env =
+        create()
+            .setMaxReaders(1)
+            .setMapSize(MEBIBYTES.toBytes(1))
+            .open(file.toFile(), MDB_NOSUBDIR)) {
+      final EnvInfo info = env.info();
+      assertThat(info.mapSize).isEqualTo(MEBIBYTES.toBytes(1));
+    }
   }
 
   @Test
   void cannotChangeMapSizeAfterOpen() {
     assertThatThrownBy(
             () -> {
-              FileUtil.useTempFile(
-                  file -> {
-                    final Builder<ByteBuffer> builder = create().setMaxReaders(1);
-                    try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
-                      builder.setMapSize(1);
-                    }
-                  });
+              final Path file = tempDir.createTempFile();
+              final Builder<ByteBuffer> builder = create().setMaxReaders(1);
+              try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
+                builder.setMapSize(1);
+              }
             })
         .isInstanceOf(AlreadyOpenException.class);
   }
@@ -82,13 +88,11 @@ void cannotChangeMapSizeAfterOpen() {
   void cannotChangeMaxDbsAfterOpen() {
     assertThatThrownBy(
             () -> {
-              FileUtil.useTempFile(
-                  file -> {
-                    final Builder<ByteBuffer> builder = create().setMaxReaders(1);
-                    try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
-                      builder.setMaxDbs(1);
-                    }
-                  });
+              final Path file = tempDir.createTempFile();
+              final Builder<ByteBuffer> builder = create().setMaxReaders(1);
+              try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
+                builder.setMaxDbs(1);
+              }
             })
         .isInstanceOf(AlreadyOpenException.class);
   }
@@ -97,13 +101,11 @@ void cannotChangeMaxDbsAfterOpen() {
   void cannotChangeMaxReadersAfterOpen() {
     assertThatThrownBy(
             () -> {
-              FileUtil.useTempFile(
-                  file -> {
-                    final Builder<ByteBuffer> builder = create().setMaxReaders(1);
-                    try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
-                      builder.setMaxReaders(1);
-                    }
-                  });
+              final Path file = tempDir.createTempFile();
+              final Builder<ByteBuffer> builder = create().setMaxReaders(1);
+              try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
+                builder.setMaxReaders(1);
+              }
             })
         .isInstanceOf(AlreadyOpenException.class);
   }
@@ -112,13 +114,11 @@ void cannotChangeMaxReadersAfterOpen() {
   void cannotInfoOnceClosed() {
     assertThatThrownBy(
             () -> {
-              FileUtil.useTempFile(
-                  file -> {
-                    final Env<ByteBuffer> env =
-                        create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
-                    env.close();
-                    env.info();
-                  });
+              final Path file = tempDir.createTempFile();
+              final Env<ByteBuffer> env =
+                  create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
+              env.close();
+              env.info();
             })
         .isInstanceOf(AlreadyClosedException.class);
   }
@@ -127,12 +127,10 @@ void cannotInfoOnceClosed() {
   void cannotOpenTwice() {
     assertThatThrownBy(
             () -> {
-              FileUtil.useTempFile(
-                  file -> {
-                    final Builder<ByteBuffer> builder = create().setMaxReaders(1);
-                    builder.open(file.toFile(), MDB_NOSUBDIR).close();
-                    builder.open(file.toFile(), MDB_NOSUBDIR);
-                  });
+              final Path file = tempDir.createTempFile();
+              final Builder<ByteBuffer> builder = create().setMaxReaders(1);
+              builder.open(file.toFile(), MDB_NOSUBDIR).close();
+              builder.open(file.toFile(), MDB_NOSUBDIR);
             })
         .isInstanceOf(AlreadyOpenException.class);
   }
@@ -153,13 +151,11 @@ void cannotOverflowMapSize() {
   void cannotStatOnceClosed() {
     assertThatThrownBy(
             () -> {
-              FileUtil.useTempFile(
-                  file -> {
-                    final Env<ByteBuffer> env =
-                        create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
-                    env.close();
-                    env.stat();
-                  });
+              final Path file = tempDir.createTempFile();
+              final Env<ByteBuffer> env =
+                  create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
+              env.close();
+              env.stat();
             })
         .isInstanceOf(AlreadyClosedException.class);
   }
@@ -168,48 +164,38 @@ void cannotStatOnceClosed() {
   void cannotSyncOnceClosed() {
     assertThatThrownBy(
             () -> {
-              FileUtil.useTempFile(
-                  file -> {
-                    final Env<ByteBuffer> env =
-                        create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
-                    env.close();
-                    env.sync(false);
-                  });
+              final Path file = tempDir.createTempFile();
+              final Env<ByteBuffer> env =
+                  create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
+              env.close();
+              env.sync(false);
             })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void copyDirectoryBased() {
-    FileUtil.useTempDir(
-        dest -> {
-          assertThat(Files.exists(dest)).isTrue();
-          assertThat(Files.isDirectory(dest)).isTrue();
-          assertThat(FileUtil.count(dest)).isEqualTo(0);
-          FileUtil.useTempDir(
-              src -> {
-                try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src.toFile())) {
-                  env.copy(dest.toFile(), MDB_CP_COMPACT);
-                  assertThat(FileUtil.count(dest)).isEqualTo(1);
-                }
-              });
-        });
+    final Path dest = tempDir.createTempDir();
+    assertThat(Files.exists(dest)).isTrue();
+    assertThat(Files.isDirectory(dest)).isTrue();
+    assertThat(FileUtil.count(dest)).isEqualTo(0);
+    final Path src = tempDir.createTempDir();
+    try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src.toFile())) {
+      env.copy(dest.toFile(), MDB_CP_COMPACT);
+      assertThat(FileUtil.count(dest)).isEqualTo(1);
+    }
   }
 
   @Test
   void copyDirectoryRejectsFileDestination() {
     assertThatThrownBy(
             () -> {
-              FileUtil.useTempDir(
-                  dest -> {
-                    FileUtil.deleteDir(dest);
-                    FileUtil.useTempDir(
-                        src -> {
-                          try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src.toFile())) {
-                            env.copy(dest.toFile(), MDB_CP_COMPACT);
-                          }
-                        });
-                  });
+              final Path dest = tempDir.createTempDir();
+              FileUtil.deleteDir(dest);
+              final Path src = tempDir.createTempDir();
+              try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src.toFile())) {
+                env.copy(dest.toFile(), MDB_CP_COMPACT);
+              }
             })
         .isInstanceOf(InvalidCopyDestination.class);
   }
@@ -218,21 +204,16 @@ void copyDirectoryRejectsFileDestination() {
   void copyDirectoryRejectsMissingDestination() {
     assertThatThrownBy(
             () -> {
-              FileUtil.useTempDir(
-                  dest -> {
-                    try {
-                      Files.delete(dest);
-                      FileUtil.useTempDir(
-                          src -> {
-                            try (Env<ByteBuffer> env =
-                                create().setMaxReaders(1).open(src.toFile())) {
-                              env.copy(dest.toFile(), MDB_CP_COMPACT);
-                            }
-                          });
-                    } catch (final IOException e) {
-                      throw new UncheckedIOException(e);
-                    }
-                  });
+              final Path dest = tempDir.createTempDir();
+              try {
+                Files.delete(dest);
+                final Path src = tempDir.createTempDir();
+                try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src.toFile())) {
+                  env.copy(dest.toFile(), MDB_CP_COMPACT);
+                }
+              } catch (final IOException e) {
+                throw new UncheckedIOException(e);
+              }
             })
         .isInstanceOf(InvalidCopyDestination.class);
   }
@@ -241,260 +222,227 @@ void copyDirectoryRejectsMissingDestination() {
   void copyDirectoryRejectsNonEmptyDestination() {
     assertThatThrownBy(
             () -> {
-              FileUtil.useTempDir(
-                  dest -> {
-                    try {
-                      final Path subDir = dest.resolve("hello");
-                      Files.createDirectory(subDir);
-                      assertThat(Files.isDirectory(subDir)).isTrue();
-                      FileUtil.useTempDir(
-                          src -> {
-                            try (Env<ByteBuffer> env =
-                                create().setMaxReaders(1).open(src.toFile())) {
-                              env.copy(dest.toFile(), MDB_CP_COMPACT);
-                            }
-                          });
-                    } catch (final IOException e) {
-                      throw new UncheckedIOException(e);
-                    }
-                  });
+              final Path dest = tempDir.createTempDir();
+              try {
+                final Path subDir = dest.resolve("hello");
+                Files.createDirectory(subDir);
+                assertThat(Files.isDirectory(subDir)).isTrue();
+                final Path src = tempDir.createTempDir();
+                try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src.toFile())) {
+                  env.copy(dest.toFile(), MDB_CP_COMPACT);
+                }
+              } catch (final IOException e) {
+                throw new UncheckedIOException(e);
+              }
             })
         .isInstanceOf(InvalidCopyDestination.class);
   }
 
   @Test
   void copyFileBased() {
-    FileUtil.useTempFile(
-        dest -> {
-          FileUtil.deleteFile(dest);
-          assertThat(Files.exists(dest)).isFalse();
-          FileUtil.useTempFile(
-              src -> {
-                try (Env<ByteBuffer> env =
-                    create().setMaxReaders(1).open(src.toFile(), MDB_NOSUBDIR)) {
-                  env.copy(dest.toFile(), MDB_CP_COMPACT);
-                }
-                assertThat(FileUtil.size(dest)).isGreaterThan(0L);
-              });
-        });
+    final Path dest = tempDir.createTempFile();
+    assertThat(Files.exists(dest)).isFalse();
+    final Path src = tempDir.createTempFile();
+    try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src.toFile(), MDB_NOSUBDIR)) {
+      env.copy(dest.toFile(), MDB_CP_COMPACT);
+    }
+    assertThat(FileUtil.size(dest)).isGreaterThan(0L);
   }
 
   @Test
   void copyFileRejectsExistingDestination() {
     assertThatThrownBy(
             () -> {
-              FileUtil.useTempFile(
-                  dest -> {
-                    assertThat(Files.exists(dest)).isTrue();
-                    FileUtil.useTempFile(
-                        src -> {
-                          try (Env<ByteBuffer> env =
-                              create().setMaxReaders(1).open(src.toFile(), MDB_NOSUBDIR)) {
-                            env.copy(dest.toFile(), MDB_CP_COMPACT);
-                          }
-                        });
-                  });
+              final Path dest = tempDir.createTempFile();
+              Files.createFile(dest);
+              assertThat(Files.exists(dest)).isTrue();
+              final Path src = tempDir.createTempFile();
+              try (Env<ByteBuffer> env =
+                  create().setMaxReaders(1).open(src.toFile(), MDB_NOSUBDIR)) {
+                env.copy(dest.toFile(), MDB_CP_COMPACT);
+              }
             })
         .isInstanceOf(InvalidCopyDestination.class);
   }
 
   @Test
   void createAsDirectory() {
-    FileUtil.useTempDir(
-        dest -> {
-          final Env<ByteBuffer> env = create().setMaxReaders(1).open(dest.toFile());
-          assertThat(Files.isDirectory(dest)).isTrue();
-          env.sync(false);
-          env.close();
-          assertThat(env.isClosed()).isTrue();
-          env.close(); // safe to repeat
-        });
+    final Path dest = tempDir.createTempDir();
+    final Env<ByteBuffer> env = create().setMaxReaders(1).open(dest.toFile());
+    assertThat(Files.isDirectory(dest)).isTrue();
+    env.sync(false);
+    env.close();
+    assertThat(env.isClosed()).isTrue();
+    env.close(); // safe to repeat
   }
 
   @Test
   void createAsFile() {
-    FileUtil.useTempFile(
-        file -> {
-          try (Env<ByteBuffer> env =
-              create()
-                  .setMapSize(MEBIBYTES.toBytes(1))
-                  .setMaxDbs(1)
-                  .setMaxReaders(1)
-                  .open(file.toFile(), MDB_NOSUBDIR)) {
-            env.sync(true);
-            assertThat(Files.isRegularFile(file)).isTrue();
-          }
-        });
+    final Path file = tempDir.createTempFile();
+    try (Env<ByteBuffer> env =
+        create()
+            .setMapSize(MEBIBYTES.toBytes(1))
+            .setMaxDbs(1)
+            .setMaxReaders(1)
+            .open(file.toFile(), MDB_NOSUBDIR)) {
+      env.sync(true);
+      assertThat(Files.isRegularFile(file)).isTrue();
+    }
   }
 
   @Test
   void detectTransactionThreadViolation() {
     assertThatThrownBy(
             () -> {
-              FileUtil.useTempFile(
-                  file -> {
-                    try (Env<ByteBuffer> env =
-                        create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR)) {
-                      env.txnRead();
-                      env.txnRead();
-                    }
-                  });
+              final Path file = tempDir.createTempFile();
+              try (Env<ByteBuffer> env =
+                  create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR)) {
+                env.txnRead();
+                env.txnRead();
+              }
             })
         .isInstanceOf(BadReaderLockException.class);
   }
 
   @Test
   void info() {
-    FileUtil.useTempFile(
-        file -> {
-          try (Env<ByteBuffer> env =
-              create().setMaxReaders(4).setMapSize(123_456).open(file.toFile(), MDB_NOSUBDIR)) {
-            final EnvInfo info = env.info();
-            assertThat(info).isNotNull();
-            assertThat(info.lastPageNumber).isEqualTo(1L);
-            assertThat(info.lastTransactionId).isEqualTo(0L);
-            assertThat(info.mapAddress).isEqualTo(0L);
-            assertThat(info.mapSize).isEqualTo(123_456L);
-            assertThat(info.maxReaders).isEqualTo(4);
-            assertThat(info.numReaders).isEqualTo(0);
-            assertThat(info.toString()).contains("maxReaders=");
-            assertThat(env.getMaxKeySize()).isEqualTo(511);
-          }
-        });
+    final Path file = tempDir.createTempFile();
+    try (Env<ByteBuffer> env =
+        create().setMaxReaders(4).setMapSize(123_456).open(file.toFile(), MDB_NOSUBDIR)) {
+      final EnvInfo info = env.info();
+      assertThat(info).isNotNull();
+      assertThat(info.lastPageNumber).isEqualTo(1L);
+      assertThat(info.lastTransactionId).isEqualTo(0L);
+      assertThat(info.mapAddress).isEqualTo(0L);
+      assertThat(info.mapSize).isEqualTo(123_456L);
+      assertThat(info.maxReaders).isEqualTo(4);
+      assertThat(info.numReaders).isEqualTo(0);
+      assertThat(info.toString()).contains("maxReaders=");
+      assertThat(env.getMaxKeySize()).isEqualTo(511);
+    }
   }
 
   @Test
   void mapFull() {
     assertThatThrownBy(
             () -> {
-              FileUtil.useTempDir(
-                  dir -> {
-                    final byte[] k = new byte[500];
-                    final ByteBuffer key = allocateDirect(500);
-                    final ByteBuffer val = allocateDirect(1_024);
-                    final Random rnd = new Random();
-                    try (Env<ByteBuffer> env =
-                        create()
-                            .setMaxReaders(1)
-                            .setMapSize(MEBIBYTES.toBytes(8))
-                            .setMaxDbs(1)
-                            .open(dir.toFile())) {
-                      final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
-                      for (; ; ) {
-                        rnd.nextBytes(k);
-                        key.clear();
-                        key.put(k).flip();
-                        val.clear();
-                        db.put(key, val);
-                      }
-                    }
-                  });
+              final Path dir = tempDir.createTempDir();
+              final byte[] k = new byte[500];
+              final ByteBuffer key = allocateDirect(500);
+              final ByteBuffer val = allocateDirect(1_024);
+              final Random rnd = new Random();
+              try (Env<ByteBuffer> env =
+                  create()
+                      .setMaxReaders(1)
+                      .setMapSize(MEBIBYTES.toBytes(8))
+                      .setMaxDbs(1)
+                      .open(dir.toFile())) {
+                final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+                for (; ; ) {
+                  rnd.nextBytes(k);
+                  key.clear();
+                  key.put(k).flip();
+                  val.clear();
+                  db.put(key, val);
+                }
+              }
             })
         .isInstanceOf(MapFullException.class);
   }
 
   @Test
   void readOnlySupported() {
-    FileUtil.useTempDir(
-        dir -> {
-          try (Env<ByteBuffer> rwEnv = create().setMaxReaders(1).open(dir.toFile())) {
-            final Dbi<ByteBuffer> rwDb = rwEnv.openDbi(DB_1, MDB_CREATE);
-            rwDb.put(bb(1), bb(42));
-          }
-          try (Env<ByteBuffer> roEnv =
-              create().setMaxReaders(1).open(dir.toFile(), MDB_RDONLY_ENV)) {
-            final Dbi<ByteBuffer> roDb = roEnv.openDbi(DB_1);
-            try (Txn<ByteBuffer> roTxn = roEnv.txnRead()) {
-              assertThat(roDb.get(roTxn, bb(1))).isNotNull();
-            }
-          }
-        });
+    final Path dir = tempDir.createTempDir();
+    try (Env<ByteBuffer> rwEnv = create().setMaxReaders(1).open(dir.toFile())) {
+      final Dbi<ByteBuffer> rwDb = rwEnv.openDbi(DB_1, MDB_CREATE);
+      rwDb.put(bb(1), bb(42));
+    }
+    try (Env<ByteBuffer> roEnv = create().setMaxReaders(1).open(dir.toFile(), MDB_RDONLY_ENV)) {
+      final Dbi<ByteBuffer> roDb = roEnv.openDbi(DB_1);
+      try (Txn<ByteBuffer> roTxn = roEnv.txnRead()) {
+        assertThat(roDb.get(roTxn, bb(1))).isNotNull();
+      }
+    }
   }
 
   @Test
   void setMapSize() {
-    FileUtil.useTempDir(
-        dir -> {
-          final byte[] k = new byte[500];
-          final ByteBuffer key = allocateDirect(500);
-          final ByteBuffer val = allocateDirect(1_024);
-          final Random rnd = new Random();
-          try (Env<ByteBuffer> env =
-              create()
-                  .setMaxReaders(1)
-                  .setMapSize(KIBIBYTES.toBytes(256))
-                  .setMaxDbs(1)
-                  .open(dir.toFile())) {
-            final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
-
-            db.put(bb(1), bb(42));
-            boolean mapFullExThrown = false;
-            try {
-              for (int i = 0; i < 70; i++) {
-                rnd.nextBytes(k);
-                key.clear();
-                key.put(k).flip();
-                val.clear();
-                db.put(key, val);
-              }
-            } catch (final MapFullException mfE) {
-              mapFullExThrown = true;
-            }
-            assertThat(mapFullExThrown).isTrue();
-
-            env.setMapSize(KIBIBYTES.toBytes(1024));
-
-            try (Txn<ByteBuffer> roTxn = env.txnRead()) {
-              final ByteBuffer byteBuffer = db.get(roTxn, bb(1));
-              assertThat(byteBuffer).isNotNull();
-              assertThat(byteBuffer.getInt()).isEqualTo(42);
-            }
-
-            mapFullExThrown = false;
-            try {
-              for (int i = 0; i < 70; i++) {
-                rnd.nextBytes(k);
-                key.clear();
-                key.put(k).flip();
-                val.clear();
-                db.put(key, val);
-              }
-            } catch (final MapFullException mfE) {
-              mapFullExThrown = true;
-            }
-            assertThat(mapFullExThrown).isFalse();
-          }
-        });
+    final Path dir = tempDir.createTempDir();
+    final byte[] k = new byte[500];
+    final ByteBuffer key = allocateDirect(500);
+    final ByteBuffer val = allocateDirect(1_024);
+    final Random rnd = new Random();
+    try (Env<ByteBuffer> env =
+        create()
+            .setMaxReaders(1)
+            .setMapSize(KIBIBYTES.toBytes(256))
+            .setMaxDbs(1)
+            .open(dir.toFile())) {
+      final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+
+      db.put(bb(1), bb(42));
+      boolean mapFullExThrown = false;
+      try {
+        for (int i = 0; i < 70; i++) {
+          rnd.nextBytes(k);
+          key.clear();
+          key.put(k).flip();
+          val.clear();
+          db.put(key, val);
+        }
+      } catch (final MapFullException mfE) {
+        mapFullExThrown = true;
+      }
+      assertThat(mapFullExThrown).isTrue();
+
+      env.setMapSize(KIBIBYTES.toBytes(1024));
+
+      try (Txn<ByteBuffer> roTxn = env.txnRead()) {
+        final ByteBuffer byteBuffer = db.get(roTxn, bb(1));
+        assertThat(byteBuffer).isNotNull();
+        assertThat(byteBuffer.getInt()).isEqualTo(42);
+      }
+
+      mapFullExThrown = false;
+      try {
+        for (int i = 0; i < 70; i++) {
+          rnd.nextBytes(k);
+          key.clear();
+          key.put(k).flip();
+          val.clear();
+          db.put(key, val);
+        }
+      } catch (final MapFullException mfE) {
+        mapFullExThrown = true;
+      }
+      assertThat(mapFullExThrown).isFalse();
+    }
   }
 
   @Test
   void stats() {
-    FileUtil.useTempFile(
-        file -> {
-          try (Env<ByteBuffer> env = create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR)) {
-            final Stat stat = env.stat();
-            assertThat(stat).isNotNull();
-            assertThat(stat.branchPages).isEqualTo(0L);
-            assertThat(stat.depth).isEqualTo(0);
-            assertThat(stat.entries).isEqualTo(0L);
-            assertThat(stat.leafPages).isEqualTo(0L);
-            assertThat(stat.overflowPages).isEqualTo(0L);
-            assertThat(stat.pageSize % 4_096).isEqualTo(0);
-            assertThat(stat.toString()).contains("pageSize=");
-          }
-        });
+    final Path file = tempDir.createTempFile();
+    try (Env<ByteBuffer> env = create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR)) {
+      final Stat stat = env.stat();
+      assertThat(stat).isNotNull();
+      assertThat(stat.branchPages).isEqualTo(0L);
+      assertThat(stat.depth).isEqualTo(0);
+      assertThat(stat.entries).isEqualTo(0L);
+      assertThat(stat.leafPages).isEqualTo(0L);
+      assertThat(stat.overflowPages).isEqualTo(0L);
+      assertThat(stat.pageSize % 4_096).isEqualTo(0);
+      assertThat(stat.toString()).contains("pageSize=");
+    }
   }
 
   @Test
   void testDefaultOpen() {
-    FileUtil.useTempDir(
-        dir -> {
-          try (Env<ByteBuffer> env = open(dir.toFile(), 10)) {
-            final EnvInfo info = env.info();
-            assertThat(info.maxReaders).isEqualTo(MAX_READERS_DEFAULT);
-            final Dbi<ByteBuffer> db = env.openDbi("test", MDB_CREATE);
-            db.put(allocateDirect(1), allocateDirect(1));
-          }
-        });
+    final Path dir = tempDir.createTempDir();
+    try (Env<ByteBuffer> env = open(dir.toFile(), 10)) {
+      final EnvInfo info = env.info();
+      assertThat(info.maxReaders).isEqualTo(MAX_READERS_DEFAULT);
+      final Dbi<ByteBuffer> db = env.openDbi("test", MDB_CREATE);
+      db.put(allocateDirect(1), allocateDirect(1));
+    }
   }
 }
diff --git a/src/test/java/org/lmdbjava/FileUtil.java b/src/test/java/org/lmdbjava/FileUtil.java
index 2343c670..cc7ed635 100644
--- a/src/test/java/org/lmdbjava/FileUtil.java
+++ b/src/test/java/org/lmdbjava/FileUtil.java
@@ -25,53 +25,12 @@
 import java.nio.file.Path;
 import java.nio.file.attribute.BasicFileAttributes;
 import java.util.EnumSet;
-import java.util.function.Consumer;
 import java.util.stream.Stream;
 
 final class FileUtil {
 
   private FileUtil() {}
 
-  static Path createTempDir() {
-    try {
-      return Files.createTempDirectory("lmdbjava");
-    } catch (final IOException e) {
-      throw new UncheckedIOException(e);
-    }
-  }
-
-  static Path createTempFile() {
-    try {
-      return Files.createTempFile("lmdbjava", "db");
-    } catch (final IOException e) {
-      throw new UncheckedIOException(e);
-    }
-  }
-
-  static void useTempDir(final Consumer<Path> consumer) {
-    Path path = null;
-    try {
-      path = createTempDir();
-      consumer.accept(path);
-    } finally {
-      if (path != null) {
-        deleteDir(path);
-      }
-    }
-  }
-
-  static void useTempFile(final Consumer<Path> consumer) {
-    Path path = null;
-    try {
-      path = createTempFile();
-      consumer.accept(path);
-    } finally {
-      if (path != null) {
-        deleteIfExists(path);
-      }
-    }
-  }
-
   public static long size(final Path path) {
     try {
       return Files.size(path);
diff --git a/src/test/java/org/lmdbjava/GarbageCollectionTest.java b/src/test/java/org/lmdbjava/GarbageCollectionTest.java
index f0aa64e4..36273559 100644
--- a/src/test/java/org/lmdbjava/GarbageCollectionTest.java
+++ b/src/test/java/org/lmdbjava/GarbageCollectionTest.java
@@ -23,6 +23,7 @@
 import static org.lmdbjava.Env.create;
 
 import java.nio.ByteBuffer;
+import java.nio.file.Path;
 import org.junit.jupiter.api.Test;
 import org.mockito.MockedStatic;
 import org.mockito.Mockito;
@@ -35,61 +36,61 @@ public class GarbageCollectionTest {
 
   @Test
   void buffersNotGarbageCollectedTest() {
-    FileUtil.useTempDir(
-        dir -> {
-          try (Env<ByteBuffer> env =
-              create().setMapSize(2_085_760_999).setMaxDbs(1).open(dir.toFile())) {
-            final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
+    try (final TempDir tempDir = new TempDir()) {
+      final Path dir = tempDir.createTempDir();
+      try (Env<ByteBuffer> env =
+          create().setMapSize(2_085_760_999).setMaxDbs(1).open(dir.toFile())) {
+        final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
 
-            try (Txn<ByteBuffer> txn = env.txnWrite()) {
-              for (int i = 0; i < 5_000; i++) {
-                putBuffer(db, txn, i);
-              }
-              txn.commit();
-            }
+        try (Txn<ByteBuffer> txn = env.txnWrite()) {
+          for (int i = 0; i < 5_000; i++) {
+            putBuffer(db, txn, i);
+          }
+          txn.commit();
+        }
 
-            // Call GC before writing to LMDB and after last reference to buffer by
-            // changing the behavior of mask
-            try (MockedStatic<MaskedFlag> mockedStatic = Mockito.mockStatic(MaskedFlag.class)) {
-              mockedStatic
-                  .when(MaskedFlag::mask)
-                  .thenAnswer(
-                      invocationOnMock -> {
-                        System.gc();
-                        return 0;
-                      });
-              final int gcRecordWrites = Integer.getInteger("gcRecordWrites", 50);
-              try (Txn<ByteBuffer> txn = env.txnWrite()) {
-                for (int i = 0; i < gcRecordWrites; i++) {
-                  putBuffer(db, txn, i);
-                }
-                txn.commit();
-              }
+        // Call GC before writing to LMDB and after last reference to buffer by
+        // changing the behavior of mask
+        try (MockedStatic<MaskedFlag> mockedStatic = Mockito.mockStatic(MaskedFlag.class)) {
+          mockedStatic
+              .when(MaskedFlag::mask)
+              .thenAnswer(
+                  invocationOnMock -> {
+                    System.gc();
+                    return 0;
+                  });
+          final int gcRecordWrites = Integer.getInteger("gcRecordWrites", 50);
+          try (Txn<ByteBuffer> txn = env.txnWrite()) {
+            for (int i = 0; i < gcRecordWrites; i++) {
+              putBuffer(db, txn, i);
             }
+            txn.commit();
+          }
+        }
 
-            // Find corrupt keys
-            try (Txn<ByteBuffer> txn = env.txnRead()) {
-              try (Cursor<ByteBuffer> c = db.openCursor(txn)) {
-                if (c.first()) {
-                  do {
-                    final byte[] rkey = new byte[c.key().remaining()];
-                    c.key().get(rkey);
-                    final byte[] rval = new byte[c.val().remaining()];
-                    c.val().get(rval);
-                    final String skey = new String(rkey, UTF_8);
-                    final String sval = new String(rval, UTF_8);
-                    if (!skey.startsWith("Uncorruptedkey")) {
-                      fail("Found corrupt key " + skey);
-                    }
-                    if (!sval.startsWith("Uncorruptedval")) {
-                      fail("Found corrupt val " + sval);
-                    }
-                  } while (c.next());
+        // Find corrupt keys
+        try (Txn<ByteBuffer> txn = env.txnRead()) {
+          try (Cursor<ByteBuffer> c = db.openCursor(txn)) {
+            if (c.first()) {
+              do {
+                final byte[] rkey = new byte[c.key().remaining()];
+                c.key().get(rkey);
+                final byte[] rval = new byte[c.val().remaining()];
+                c.val().get(rval);
+                final String skey = new String(rkey, UTF_8);
+                final String sval = new String(rval, UTF_8);
+                if (!skey.startsWith("Uncorruptedkey")) {
+                  fail("Found corrupt key " + skey);
+                }
+                if (!sval.startsWith("Uncorruptedval")) {
+                  fail("Found corrupt val " + sval);
                 }
-              }
+              } while (c.next());
             }
           }
-        });
+        }
+      }
+    }
   }
 
   private void putBuffer(final Dbi<ByteBuffer> db, final Txn<ByteBuffer> txn, final int i) {
diff --git a/src/test/java/org/lmdbjava/TempDir.java b/src/test/java/org/lmdbjava/TempDir.java
new file mode 100644
index 00000000..7d2977b9
--- /dev/null
+++ b/src/test/java/org/lmdbjava/TempDir.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.UUID;
+
+public class TempDir implements AutoCloseable {
+  private final Path root;
+
+  public TempDir() {
+    try {
+      root = Files.createTempDirectory("lmdb");
+    } catch (final IOException e) {
+      throw new UncheckedIOException(e);
+    }
+  }
+
+  public Path createTempFile() {
+    return root.resolve(UUID.randomUUID().toString());
+  }
+
+  public Path createTempDir() {
+    try {
+      final Path dir = root.resolve(UUID.randomUUID().toString());
+      Files.createDirectory(dir);
+      return dir;
+    } catch (final IOException e) {
+      throw new UncheckedIOException(e);
+    }
+  }
+
+  public void cleanup() {
+    FileUtil.deleteDir(root);
+  }
+
+  @Override
+  public void close() {
+    cleanup();
+  }
+}
diff --git a/src/test/java/org/lmdbjava/TestUtils.java b/src/test/java/org/lmdbjava/TestUtils.java
index 4c5e46ee..23606862 100644
--- a/src/test/java/org/lmdbjava/TestUtils.java
+++ b/src/test/java/org/lmdbjava/TestUtils.java
@@ -56,6 +56,15 @@ static ByteBuffer bb(final long value) {
     return bb;
   }
 
+  static byte[] getBytes(final ByteBuffer byteBuffer) {
+    if (byteBuffer == null) {
+      return null;
+    }
+    final byte[] bytes = new byte[byteBuffer.remaining()];
+    byteBuffer.duplicate().get(bytes);
+    return bytes;
+  }
+
   static void invokePrivateConstructor(final Class<?> clazz) {
     try {
       final Constructor<?> c = clazz.getDeclaredConstructor();
diff --git a/src/test/java/org/lmdbjava/TutorialTest.java b/src/test/java/org/lmdbjava/TutorialTest.java
index 1b42b327..8376fbe7 100644
--- a/src/test/java/org/lmdbjava/TutorialTest.java
+++ b/src/test/java/org/lmdbjava/TutorialTest.java
@@ -27,9 +27,7 @@
 import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
 import static org.lmdbjava.Env.create;
 import static org.lmdbjava.GetOp.MDB_SET;
-import static org.lmdbjava.SeekOp.MDB_FIRST;
-import static org.lmdbjava.SeekOp.MDB_LAST;
-import static org.lmdbjava.SeekOp.MDB_PREV;
+import static org.lmdbjava.SeekOp.*;
 
 import java.nio.ByteBuffer;
 import java.nio.file.Path;
@@ -37,6 +35,8 @@
 import org.agrona.DirectBuffer;
 import org.agrona.MutableDirectBuffer;
 import org.agrona.concurrent.UnsafeBuffer;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.lmdbjava.CursorIterable.KeyVal;
 
@@ -57,147 +57,155 @@ public final class TutorialTest {
 
   private static final String DB_NAME = "my DB";
 
+  private TempDir tempDir;
+
+  @BeforeEach
+  void beforeEach() {
+    tempDir = new TempDir();
+  }
+
+  @AfterEach
+  void afterEach() {
+    tempDir.cleanup();
+  }
+
   /** In this first tutorial we will use LmdbJava with some basic defaults. */
   @Test
   void tutorial1() {
     // We need a storage directory first.
     // The path cannot be on a remote file system.
-    FileUtil.useTempDir(
-        dir -> {
-
-          // We always need an Env. An Env owns a physical on-disk storage file. One
-          // Env can store many different databases (ie sorted maps).
-          final Env<ByteBuffer> env =
-              create()
-                  // LMDB also needs to know how large our DB might be. Over-estimating is OK.
-                  .setMapSize(10_485_760)
-                  // LMDB also needs to know how many DBs (Dbi) we want to store in this Env.
-                  .setMaxDbs(1)
-                  // Now let's open the Env. The same path can be concurrently opened and
-                  // used in different processes, but do not open the same path twice in
-                  // the same process at the same time.
-                  .open(dir.toFile());
-
-          // We need a Dbi for each DB. A Dbi roughly equates to a sorted map. The
-          // MDB_CREATE flag causes the DB to be created if it doesn't already exist.
-          final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
-
-          // We want to store some data, so we will need a direct ByteBuffer.
-          // Note that LMDB keys cannot exceed maxKeySize bytes (511 bytes by default).
-          // Values can be larger.
-          final ByteBuffer key = allocateDirect(env.getMaxKeySize());
-          final ByteBuffer val = allocateDirect(700);
-          key.put("greeting".getBytes(UTF_8)).flip();
-          val.put("Hello world".getBytes(UTF_8)).flip();
-          final int valSize = val.remaining();
-
-          // Now store it. Dbi.put() internally begins and commits a transaction (Txn).
-          db.put(key, val);
-
-          // To fetch any data from LMDB we need a Txn. A Txn is very important in
-          // LmdbJava because it offers ACID characteristics and internally holds a
-          // read-only key buffer and read-only value buffer. These read-only buffers
-          // are always the same two Java objects, but point to different LMDB-managed
-          // memory as we use Dbi (and Cursor) methods. These read-only buffers remain
-          // valid only until the Txn is released or the next Dbi or Cursor call. If
-          // you need data afterwards, you should copy the bytes to your own buffer.
-          try (Txn<ByteBuffer> txn = env.txnRead()) {
-            final ByteBuffer found = db.get(txn, key);
-            assertThat(found).isNotNull();
-
-            // The fetchedVal is read-only and points to LMDB memory
-            final ByteBuffer fetchedVal = txn.val();
-            assertThat(fetchedVal.remaining()).isEqualTo(valSize);
-
-            // Let's double-check the fetched value is correct
-            assertThat(UTF_8.decode(fetchedVal).toString()).isEqualTo("Hello world");
-          }
-
-          // We can also delete. The simplest way is to let Dbi allocate a new Txn...
-          db.delete(key);
-
-          // Now if we try to fetch the deleted row, it won't be present
-          try (Txn<ByteBuffer> txn = env.txnRead()) {
-            assertThat(db.get(txn, key)).isNull();
-          }
-
-          env.close();
-        });
+    final Path dir = tempDir.createTempDir();
+
+    // We always need an Env. An Env owns a physical on-disk storage file. One
+    // Env can store many different databases (ie sorted maps).
+    final Env<ByteBuffer> env =
+        create()
+            // LMDB also needs to know how large our DB might be. Over-estimating is OK.
+            .setMapSize(10_485_760)
+            // LMDB also needs to know how many DBs (Dbi) we want to store in this Env.
+            .setMaxDbs(1)
+            // Now let's open the Env. The same path can be concurrently opened and
+            // used in different processes, but do not open the same path twice in
+            // the same process at the same time.
+            .open(dir.toFile());
+
+    // We need a Dbi for each DB. A Dbi roughly equates to a sorted map. The
+    // MDB_CREATE flag causes the DB to be created if it doesn't already exist.
+    final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
+
+    // We want to store some data, so we will need a direct ByteBuffer.
+    // Note that LMDB keys cannot exceed maxKeySize bytes (511 bytes by default).
+    // Values can be larger.
+    final ByteBuffer key = allocateDirect(env.getMaxKeySize());
+    final ByteBuffer val = allocateDirect(700);
+    key.put("greeting".getBytes(UTF_8)).flip();
+    val.put("Hello world".getBytes(UTF_8)).flip();
+    final int valSize = val.remaining();
+
+    // Now store it. Dbi.put() internally begins and commits a transaction (Txn).
+    db.put(key, val);
+
+    // To fetch any data from LMDB we need a Txn. A Txn is very important in
+    // LmdbJava because it offers ACID characteristics and internally holds a
+    // read-only key buffer and read-only value buffer. These read-only buffers
+    // are always the same two Java objects, but point to different LMDB-managed
+    // memory as we use Dbi (and Cursor) methods. These read-only buffers remain
+    // valid only until the Txn is released or the next Dbi or Cursor call. If
+    // you need data afterwards, you should copy the bytes to your own buffer.
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      final ByteBuffer found = db.get(txn, key);
+      assertThat(found).isNotNull();
+
+      // The fetchedVal is read-only and points to LMDB memory
+      final ByteBuffer fetchedVal = txn.val();
+      assertThat(fetchedVal.remaining()).isEqualTo(valSize);
+
+      // Let's double-check the fetched value is correct
+      assertThat(UTF_8.decode(fetchedVal).toString()).isEqualTo("Hello world");
+    }
+
+    // We can also delete. The simplest way is to let Dbi allocate a new Txn...
+    db.delete(key);
+
+    // Now if we try to fetch the deleted row, it won't be present
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      assertThat(db.get(txn, key)).isNull();
+    }
+
+    env.close();
   }
 
   /** In this second tutorial we'll learn more about LMDB's ACID Txns. */
   @Test
   void tutorial2() {
-    FileUtil.useTempDir(
-        dir -> {
-          try {
-            final Env<ByteBuffer> env = createSimpleEnv(dir);
-            final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
-            final ByteBuffer key = allocateDirect(env.getMaxKeySize());
-            final ByteBuffer val = allocateDirect(700);
-
-            // Let's write and commit "key1" via a Txn. A Txn can include multiple Dbis.
-            // Note write Txns block other write Txns, due to writes being serialized.
-            // It's therefore important to avoid unnecessarily long-lived write Txns.
+    final Path dir = tempDir.createTempDir();
+    try {
+      final Env<ByteBuffer> env = createSimpleEnv(dir);
+      final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
+      final ByteBuffer key = allocateDirect(env.getMaxKeySize());
+      final ByteBuffer val = allocateDirect(700);
+
+      // Let's write and commit "key1" via a Txn. A Txn can include multiple Dbis.
+      // Note write Txns block other write Txns, due to writes being serialized.
+      // It's therefore important to avoid unnecessarily long-lived write Txns.
+      try (Txn<ByteBuffer> txn = env.txnWrite()) {
+        key.put("key1".getBytes(UTF_8)).flip();
+        val.put("lmdb".getBytes(UTF_8)).flip();
+        db.put(txn, key, val);
+
+        // We can read data too, even though this is a write Txn.
+        final ByteBuffer found = db.get(txn, key);
+        assertThat(found).isNotNull();
+
+        // An explicit commit is required, otherwise Txn.close() rolls it back.
+        txn.commit();
+      }
+
+      // Open a read-only Txn. It only sees data that existed at Txn creation time.
+      final Txn<ByteBuffer> rtx = env.txnRead();
+
+      // Our read Txn can fetch key1 without problem, as it existed at Txn creation.
+      ByteBuffer found = db.get(rtx, key);
+      assertThat(found).isNotNull();
+
+      // Note that our main test thread holds the Txn. Only one Txn per thread is
+      // typically permitted (the exception is a read-only Env with MDB_NOTLS).
+      //
+      // Let's write out a "key2" via a new write Txn in a different thread.
+      final ExecutorService es = newCachedThreadPool();
+      es.execute(
+          () -> {
             try (Txn<ByteBuffer> txn = env.txnWrite()) {
-              key.put("key1".getBytes(UTF_8)).flip();
-              val.put("lmdb".getBytes(UTF_8)).flip();
+              key.clear();
+              key.put("key2".getBytes(UTF_8)).flip();
               db.put(txn, key, val);
-
-              // We can read data too, even though this is a write Txn.
-              final ByteBuffer found = db.get(txn, key);
-              assertThat(found).isNotNull();
-
-              // An explicit commit is required, otherwise Txn.close() rolls it back.
               txn.commit();
             }
-
-            // Open a read-only Txn. It only sees data that existed at Txn creation time.
-            final Txn<ByteBuffer> rtx = env.txnRead();
-
-            // Our read Txn can fetch key1 without problem, as it existed at Txn creation.
-            ByteBuffer found = db.get(rtx, key);
-            assertThat(found).isNotNull();
-
-            // Note that our main test thread holds the Txn. Only one Txn per thread is
-            // typically permitted (the exception is a read-only Env with MDB_NOTLS).
-            //
-            // Let's write out a "key2" via a new write Txn in a different thread.
-            final ExecutorService es = newCachedThreadPool();
-            es.execute(
-                () -> {
-                  try (Txn<ByteBuffer> txn = env.txnWrite()) {
-                    key.clear();
-                    key.put("key2".getBytes(UTF_8)).flip();
-                    db.put(txn, key, val);
-                    txn.commit();
-                  }
-                });
-            es.shutdown();
-            es.awaitTermination(10, SECONDS);
-
-            // Even though key2 has been committed, our read Txn still can't see it.
-            found = db.get(rtx, key);
-            assertThat(found).isNull();
-
-            // To see key2, we could create a new Txn. But a reset/renew is much faster.
-            // Reset/renew is also important to avoid long-lived read Txns, as these
-            // prevent the re-use of free pages by write Txns (ie the DB will grow).
-            rtx.reset();
-            // ... potentially long operation here ...
-            rtx.renew();
-            found = db.get(rtx, key);
-            assertThat(found).isNotNull();
-
-            // Don't forget to close the read Txn now we're completely finished. We could
-            // have avoided this if we used a try-with-resources block, but we wanted to
-            // play around with multiple concurrent Txns to demonstrate the "I" in ACID.
-            rtx.close();
-            env.close();
-          } catch (final InterruptedException e) {
-            throw new RuntimeException(e);
-          }
-        });
+          });
+      es.shutdown();
+      es.awaitTermination(10, SECONDS);
+
+      // Even though key2 has been committed, our read Txn still can't see it.
+      found = db.get(rtx, key);
+      assertThat(found).isNull();
+
+      // To see key2, we could create a new Txn. But a reset/renew is much faster.
+      // Reset/renew is also important to avoid long-lived read Txns, as these
+      // prevent the re-use of free pages by write Txns (ie the DB will grow).
+      rtx.reset();
+      // ... potentially long operation here ...
+      rtx.renew();
+      found = db.get(rtx, key);
+      assertThat(found).isNotNull();
+
+      // Don't forget to close the read Txn now we're completely finished. We could
+      // have avoided this if we used a try-with-resources block, but we wanted to
+      // play around with multiple concurrent Txns to demonstrate the "I" in ACID.
+      rtx.close();
+      env.close();
+    } catch (final InterruptedException e) {
+      throw new RuntimeException(e);
+    }
   }
 
   /**
@@ -207,73 +215,71 @@ void tutorial2() {
    */
   @Test
   void tutorial3() {
-    FileUtil.useTempDir(
-        dir -> {
-          final Env<ByteBuffer> env = createSimpleEnv(dir);
-          final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
-          final ByteBuffer key = allocateDirect(env.getMaxKeySize());
-          final ByteBuffer val = allocateDirect(700);
-
-          try (Txn<ByteBuffer> txn = env.txnWrite()) {
-            // A cursor always belongs to a particular Dbi.
-            final Cursor<ByteBuffer> c = db.openCursor(txn);
-
-            // We can put via a Cursor. Note we're adding keys in a strange order,
-            // as we want to show you that LMDB returns them in sorted order.
-            key.put("zzz".getBytes(UTF_8)).flip();
-            val.put("lmdb".getBytes(UTF_8)).flip();
-            c.put(key, val);
-            key.clear();
-            key.put("aaa".getBytes(UTF_8)).flip();
-            c.put(key, val);
-            key.clear();
-            key.put("ccc".getBytes(UTF_8)).flip();
-            c.put(key, val);
-
-            // We can read from the Cursor by key.
-            c.get(key, MDB_SET);
-            assertThat(UTF_8.decode(c.key()).toString()).isEqualTo("ccc");
-
-            // Let's see that LMDB provides the keys in appropriate order....
-            c.seek(MDB_FIRST);
-            assertThat(UTF_8.decode(c.key()).toString()).isEqualTo("aaa");
-
-            c.seek(MDB_LAST);
-            assertThat(UTF_8.decode(c.key()).toString()).isEqualTo("zzz");
-
-            c.seek(MDB_PREV);
-            assertThat(UTF_8.decode(c.key()).toString()).isEqualTo("ccc");
-
-            // Cursors can also delete the current key.
-            c.delete();
-
-            c.close();
-            txn.commit();
-          }
-
-          // A read-only Cursor can survive its original Txn being closed. This is
-          // useful if you want to close the original Txn (eg maybe you created the
-          // Cursor during the constructor of a singleton with a throw-away Txn). Of
-          // course, you cannot use the Cursor if its Txn is closed or currently reset.
-          final Txn<ByteBuffer> tx1 = env.txnRead();
-          final Cursor<ByteBuffer> c = db.openCursor(tx1);
-          tx1.close();
-
-          // The Cursor becomes usable again by "renewing" it with an active read Txn.
-          final Txn<ByteBuffer> tx2 = env.txnRead();
-          c.renew(tx2);
-          c.seek(MDB_FIRST);
-
-          // As usual with read Txns, we can reset and renew them. The Cursor does
-          // not need any special handling if we do this.
-          tx2.reset();
-          // ... potentially long operation here ...
-          tx2.renew();
-          c.seek(MDB_LAST);
-
-          tx2.close();
-          env.close();
-        });
+    final Path dir = tempDir.createTempDir();
+    final Env<ByteBuffer> env = createSimpleEnv(dir);
+    final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
+    final ByteBuffer key = allocateDirect(env.getMaxKeySize());
+    final ByteBuffer val = allocateDirect(700);
+
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      // A cursor always belongs to a particular Dbi.
+      final Cursor<ByteBuffer> c = db.openCursor(txn);
+
+      // We can put via a Cursor. Note we're adding keys in a strange order,
+      // as we want to show you that LMDB returns them in sorted order.
+      key.put("zzz".getBytes(UTF_8)).flip();
+      val.put("lmdb".getBytes(UTF_8)).flip();
+      c.put(key, val);
+      key.clear();
+      key.put("aaa".getBytes(UTF_8)).flip();
+      c.put(key, val);
+      key.clear();
+      key.put("ccc".getBytes(UTF_8)).flip();
+      c.put(key, val);
+
+      // We can read from the Cursor by key.
+      c.get(key, MDB_SET);
+      assertThat(UTF_8.decode(c.key()).toString()).isEqualTo("ccc");
+
+      // Let's see that LMDB provides the keys in appropriate order....
+      c.seek(MDB_FIRST);
+      assertThat(UTF_8.decode(c.key()).toString()).isEqualTo("aaa");
+
+      c.seek(MDB_LAST);
+      assertThat(UTF_8.decode(c.key()).toString()).isEqualTo("zzz");
+
+      c.seek(MDB_PREV);
+      assertThat(UTF_8.decode(c.key()).toString()).isEqualTo("ccc");
+
+      // Cursors can also delete the current key.
+      c.delete();
+
+      c.close();
+      txn.commit();
+    }
+
+    // A read-only Cursor can survive its original Txn being closed. This is
+    // useful if you want to close the original Txn (eg maybe you created the
+    // Cursor during the constructor of a singleton with a throw-away Txn). Of
+    // course, you cannot use the Cursor if its Txn is closed or currently reset.
+    final Txn<ByteBuffer> tx1 = env.txnRead();
+    final Cursor<ByteBuffer> c = db.openCursor(tx1);
+    tx1.close();
+
+    // The Cursor becomes usable again by "renewing" it with an active read Txn.
+    final Txn<ByteBuffer> tx2 = env.txnRead();
+    c.renew(tx2);
+    c.seek(MDB_FIRST);
+
+    // As usual with read Txns, we can reset and renew them. The Cursor does
+    // not need any special handling if we do this.
+    tx2.reset();
+    // ... potentially long operation here ...
+    tx2.renew();
+    c.seek(MDB_LAST);
+
+    tx2.close();
+    env.close();
   }
 
   /**
@@ -282,109 +288,105 @@ void tutorial3() {
    */
   @Test
   void tutorial4() {
-    FileUtil.useTempDir(
-        dir -> {
-          final Env<ByteBuffer> env = createSimpleEnv(dir);
-          final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
-
-          try (Txn<ByteBuffer> txn = env.txnWrite()) {
-            final ByteBuffer key = allocateDirect(env.getMaxKeySize());
-            final ByteBuffer val = allocateDirect(700);
-
-            // Insert some data. Note that ByteBuffer order defaults to Big Endian.
-            // LMDB does not persist the byte order, but it's critical to sort keys.
-            // If your numeric keys don't sort as expected, review buffer byte order.
-            val.putInt(100);
-            key.putInt(1);
-            db.put(txn, key, val);
-            key.clear();
-            key.putInt(2);
-            db.put(txn, key, val);
-            key.clear();
-
-            // Each iterable uses a cursor and must be closed when finished. Iterate
-            // forward in terms of key ordering starting with the first key.
-            try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-              for (final KeyVal<ByteBuffer> kv : ci) {
-                assertThat(kv.key()).isNotNull();
-                assertThat(kv.val()).isNotNull();
-              }
-            }
-
-            // Iterate backward in terms of key ordering starting with the last key.
-            try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.allBackward())) {
-              for (final KeyVal<ByteBuffer> kv : ci) {
-                assertThat(kv.key()).isNotNull();
-                assertThat(kv.val()).isNotNull();
-              }
-            }
-
-            // There are many ways to control the desired key range via KeyRange, such
-            // as arbitrary start and stop values, direction etc. We've adopted Guava's
-            // terminology for our range classes (see KeyRangeType for further details).
-            key.putInt(1);
-            final KeyRange<ByteBuffer> range = KeyRange.atLeastBackward(key);
-            try (CursorIterable<ByteBuffer> ci = db.iterate(txn, range)) {
-              for (final KeyVal<ByteBuffer> kv : ci) {
-                assertThat(kv.key()).isNotNull();
-                assertThat(kv.val()).isNotNull();
-              }
-            }
-          }
-
-          env.close();
-        });
+    final Path dir = tempDir.createTempDir();
+    final Env<ByteBuffer> env = createSimpleEnv(dir);
+    final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
+
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      final ByteBuffer key = allocateDirect(env.getMaxKeySize());
+      final ByteBuffer val = allocateDirect(700);
+
+      // Insert some data. Note that ByteBuffer order defaults to Big Endian.
+      // LMDB does not persist the byte order, but it's critical to sort keys.
+      // If your numeric keys don't sort as expected, review buffer byte order.
+      val.putInt(100);
+      key.putInt(1);
+      db.put(txn, key, val);
+      key.clear();
+      key.putInt(2);
+      db.put(txn, key, val);
+      key.clear();
+
+      // Each iterable uses a cursor and must be closed when finished. Iterate
+      // forward in terms of key ordering starting with the first key.
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+        for (final KeyVal<ByteBuffer> kv : ci) {
+          assertThat(kv.key()).isNotNull();
+          assertThat(kv.val()).isNotNull();
+        }
+      }
+
+      // Iterate backward in terms of key ordering starting with the last key.
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.allBackward())) {
+        for (final KeyVal<ByteBuffer> kv : ci) {
+          assertThat(kv.key()).isNotNull();
+          assertThat(kv.val()).isNotNull();
+        }
+      }
+
+      // There are many ways to control the desired key range via KeyRange, such
+      // as arbitrary start and stop values, direction etc. We've adopted Guava's
+      // terminology for our range classes (see KeyRangeType for further details).
+      key.putInt(1);
+      final KeyRange<ByteBuffer> range = KeyRange.atLeastBackward(key);
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, range)) {
+        for (final KeyVal<ByteBuffer> kv : ci) {
+          assertThat(kv.key()).isNotNull();
+          assertThat(kv.val()).isNotNull();
+        }
+      }
+    }
+
+    env.close();
   }
 
   /** In this fifth tutorial we'll explore multiple values sharing a single key. */
   @Test
   void tutorial5() {
-    FileUtil.useTempDir(
-        dir -> {
-          final Env<ByteBuffer> env = createSimpleEnv(dir);
-
-          // This time we're going to tell the Dbi it can store > 1 value per key.
-          // There are other flags available if we're storing integers etc.
-          final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE, MDB_DUPSORT);
-
-          // Duplicate support requires both keys and values to be <= max key size.
-          final ByteBuffer key = allocateDirect(env.getMaxKeySize());
-          final ByteBuffer val = allocateDirect(env.getMaxKeySize());
-
-          try (Txn<ByteBuffer> txn = env.txnWrite()) {
-            final Cursor<ByteBuffer> c = db.openCursor(txn);
-
-            // Store one key, but many values, and in non-natural order.
-            key.put("key".getBytes(UTF_8)).flip();
-            val.put("xxx".getBytes(UTF_8)).flip();
-            c.put(key, val);
-            val.clear();
-            val.put("kkk".getBytes(UTF_8)).flip();
-            c.put(key, val);
-            val.clear();
-            val.put("lll".getBytes(UTF_8)).flip();
-            c.put(key, val);
-
-            // Cursor can tell us how many values the current key has.
-            final long count = c.count();
-            assertThat(count).isEqualTo(3L);
-
-            // Let's position the Cursor. Note sorting still works.
-            c.seek(MDB_FIRST);
-            assertThat(UTF_8.decode(c.val()).toString()).isEqualTo("kkk");
-
-            c.seek(MDB_LAST);
-            assertThat(UTF_8.decode(c.val()).toString()).isEqualTo("xxx");
-
-            c.seek(MDB_PREV);
-            assertThat(UTF_8.decode(c.val()).toString()).isEqualTo("lll");
-
-            c.close();
-            txn.commit();
-          }
-
-          env.close();
-        });
+    final Path dir = tempDir.createTempDir();
+    final Env<ByteBuffer> env = createSimpleEnv(dir);
+
+    // This time we're going to tell the Dbi it can store > 1 value per key.
+    // There are other flags available if we're storing integers etc.
+    final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE, MDB_DUPSORT);
+
+    // Duplicate support requires both keys and values to be <= max key size.
+    final ByteBuffer key = allocateDirect(env.getMaxKeySize());
+    final ByteBuffer val = allocateDirect(env.getMaxKeySize());
+
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      final Cursor<ByteBuffer> c = db.openCursor(txn);
+
+      // Store one key, but many values, and in non-natural order.
+      key.put("key".getBytes(UTF_8)).flip();
+      val.put("xxx".getBytes(UTF_8)).flip();
+      c.put(key, val);
+      val.clear();
+      val.put("kkk".getBytes(UTF_8)).flip();
+      c.put(key, val);
+      val.clear();
+      val.put("lll".getBytes(UTF_8)).flip();
+      c.put(key, val);
+
+      // Cursor can tell us how many values the current key has.
+      final long count = c.count();
+      assertThat(count).isEqualTo(3L);
+
+      // Let's position the Cursor. Note sorting still works.
+      c.seek(MDB_FIRST);
+      assertThat(UTF_8.decode(c.val()).toString()).isEqualTo("kkk");
+
+      c.seek(MDB_LAST);
+      assertThat(UTF_8.decode(c.val()).toString()).isEqualTo("xxx");
+
+      c.seek(MDB_PREV);
+      assertThat(UTF_8.decode(c.val()).toString()).isEqualTo("lll");
+
+      c.close();
+      txn.commit();
+    }
+
+    env.close();
   }
 
   /**
@@ -393,85 +395,79 @@ void tutorial5() {
    */
   @Test
   void tutorial6() {
-    FileUtil.useTempDir(
-        dir -> {
-          // Note we need to specify the Verifier's DBI_COUNT for the Env.
-          final Env<ByteBuffer> env =
-              create(PROXY_OPTIMAL)
-                  .setMapSize(10_485_760)
-                  .setMaxDbs(Verifier.DBI_COUNT)
-                  .open(dir.toFile());
-
-          // Create a Verifier (it's a Callable<Long> for those needing full control).
-          final Verifier v = new Verifier(env);
-
-          // We now run the verifier for 3 seconds; it raises an exception on failure.
-          // The method returns the number of entries it successfully verified.
-          v.runFor(3, SECONDS);
-
-          env.close();
-        });
+    final Path dir = tempDir.createTempDir();
+    // Note we need to specify the Verifier's DBI_COUNT for the Env.
+    final Env<ByteBuffer> env =
+        create(PROXY_OPTIMAL)
+            .setMapSize(10_485_760)
+            .setMaxDbs(Verifier.DBI_COUNT)
+            .open(dir.toFile());
+
+    // Create a Verifier (it's a Callable<Long> for those needing full control).
+    final Verifier v = new Verifier(env);
+
+    // We now run the verifier for 3 seconds; it raises an exception on failure.
+    // The method returns the number of entries it successfully verified.
+    v.runFor(3, SECONDS);
+
+    env.close();
   }
 
   /** In this final tutorial we'll look at using Agrona's DirectBuffer. */
   @Test
   void tutorial7() {
-    FileUtil.useTempDir(
-        dir -> {
-          // The critical difference is we pass the PROXY_DB field to Env.create().
-          // There's also a PROXY_SAFE if you want to stop ByteBuffer's Unsafe use.
-          // Aside from that and a different type argument, it's the same as usual...
-          final Env<DirectBuffer> env =
-              create(PROXY_DB).setMapSize(10_485_760).setMaxDbs(1).open(dir.toFile());
-
-          final Dbi<DirectBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
-
-          final ByteBuffer keyBb = allocateDirect(env.getMaxKeySize());
-          final MutableDirectBuffer key = new UnsafeBuffer(keyBb);
-          final MutableDirectBuffer val = new UnsafeBuffer(allocateDirect(700));
-
-          try (Txn<DirectBuffer> txn = env.txnWrite()) {
-            try (Cursor<DirectBuffer> c = db.openCursor(txn)) {
-              // Agrona is faster than ByteBuffer and its methods are nicer...
-              val.putStringWithoutLengthUtf8(0, "The Value");
-              key.putStringWithoutLengthUtf8(0, "yyy");
-              c.put(key, val);
-
-              key.putStringWithoutLengthUtf8(0, "ggg");
-              c.put(key, val);
-
-              c.seek(MDB_FIRST);
-              assertThat(c.key().getStringWithoutLengthUtf8(0, env.getMaxKeySize()))
-                  .startsWith("ggg");
-
-              c.seek(MDB_LAST);
-              assertThat(c.key().getStringWithoutLengthUtf8(0, env.getMaxKeySize()))
-                  .startsWith("yyy");
-
-              // DirectBuffer has no position concept. Often you don't want to store
-              // the unnecessary bytes of a varying-size buffer. Let's have a look...
-              final int keyLen = key.putStringWithoutLengthUtf8(0, "12characters");
-              assertThat(keyLen).isEqualTo(12);
-              assertThat(key.capacity()).isEqualTo(env.getMaxKeySize());
-
-              // To only store the 12 characters, we simply call wrap:
-              key.wrap(key, 0, keyLen);
-              assertThat(key.capacity()).isEqualTo(keyLen);
-              c.put(key, val);
-              c.seek(MDB_FIRST);
-              assertThat(c.key().capacity()).isEqualTo(keyLen);
-              assertThat(c.key().getStringWithoutLengthUtf8(0, c.key().capacity()))
-                  .isEqualTo("12characters");
-
-              // To store bigger values again, just wrap the original buffer.
-              key.wrap(keyBb);
-              assertThat(key.capacity()).isEqualTo(env.getMaxKeySize());
-            }
-            txn.commit();
-          }
-
-          env.close();
-        });
+    final Path dir = tempDir.createTempDir();
+    // The critical difference is we pass the PROXY_DB field to Env.create().
+    // There's also a PROXY_SAFE if you want to stop ByteBuffer's Unsafe use.
+    // Aside from that and a different type argument, it's the same as usual...
+    final Env<DirectBuffer> env =
+        create(PROXY_DB).setMapSize(10_485_760).setMaxDbs(1).open(dir.toFile());
+
+    final Dbi<DirectBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
+
+    final ByteBuffer keyBb = allocateDirect(env.getMaxKeySize());
+    final MutableDirectBuffer key = new UnsafeBuffer(keyBb);
+    final MutableDirectBuffer val = new UnsafeBuffer(allocateDirect(700));
+
+    try (Txn<DirectBuffer> txn = env.txnWrite()) {
+      try (Cursor<DirectBuffer> c = db.openCursor(txn)) {
+        // Agrona is faster than ByteBuffer and its methods are nicer...
+        val.putStringWithoutLengthUtf8(0, "The Value");
+        key.putStringWithoutLengthUtf8(0, "yyy");
+        c.put(key, val);
+
+        key.putStringWithoutLengthUtf8(0, "ggg");
+        c.put(key, val);
+
+        c.seek(MDB_FIRST);
+        assertThat(c.key().getStringWithoutLengthUtf8(0, env.getMaxKeySize())).startsWith("ggg");
+
+        c.seek(MDB_LAST);
+        assertThat(c.key().getStringWithoutLengthUtf8(0, env.getMaxKeySize())).startsWith("yyy");
+
+        // DirectBuffer has no position concept. Often you don't want to store
+        // the unnecessary bytes of a varying-size buffer. Let's have a look...
+        final int keyLen = key.putStringWithoutLengthUtf8(0, "12characters");
+        assertThat(keyLen).isEqualTo(12);
+        assertThat(key.capacity()).isEqualTo(env.getMaxKeySize());
+
+        // To only store the 12 characters, we simply call wrap:
+        key.wrap(key, 0, keyLen);
+        assertThat(key.capacity()).isEqualTo(keyLen);
+        c.put(key, val);
+        c.seek(MDB_FIRST);
+        assertThat(c.key().capacity()).isEqualTo(keyLen);
+        assertThat(c.key().getStringWithoutLengthUtf8(0, c.key().capacity()))
+            .isEqualTo("12characters");
+
+        // To store bigger values again, just wrap the original buffer.
+        key.wrap(keyBb);
+        assertThat(key.capacity()).isEqualTo(env.getMaxKeySize());
+      }
+      txn.commit();
+    }
+
+    env.close();
   }
 
   // You've finished! There are lots of other neat things we could show you (eg
diff --git a/src/test/java/org/lmdbjava/TxnTest.java b/src/test/java/org/lmdbjava/TxnTest.java
index b2f04ff6..ebb06137 100644
--- a/src/test/java/org/lmdbjava/TxnTest.java
+++ b/src/test/java/org/lmdbjava/TxnTest.java
@@ -35,7 +35,6 @@
 import static org.lmdbjava.Txn.State.RESET;
 import static org.lmdbjava.TxnFlags.MDB_RDONLY_TXN;
 
-import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.nio.file.Path;
 import java.util.ArrayList;
@@ -60,9 +59,12 @@ public final class TxnTest {
   private Path file;
   private Env<ByteBuffer> env;
 
+  private TempDir tempDir;
+
   @BeforeEach
   void beforeEach() {
-    file = FileUtil.createTempFile();
+    tempDir = new TempDir();
+    file = tempDir.createTempFile();
     env =
         create()
             .setMapSize(KIBIBYTES.toBytes(256))
@@ -74,11 +76,11 @@ void beforeEach() {
   @AfterEach
   void afterEach() {
     env.close();
-    FileUtil.deleteFile(file);
+    tempDir.cleanup();
   }
 
   @Test
-  void largeKeysRejected() throws IOException {
+  void largeKeysRejected() {
     assertThatThrownBy(
             () -> {
               final Dbi<ByteBuffer> dbi = env.openDbi(DB_1, MDB_CREATE);
diff --git a/src/test/java/org/lmdbjava/VerifierTest.java b/src/test/java/org/lmdbjava/VerifierTest.java
index 64214568..9d127cf8 100644
--- a/src/test/java/org/lmdbjava/VerifierTest.java
+++ b/src/test/java/org/lmdbjava/VerifierTest.java
@@ -22,6 +22,7 @@
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
 
 import java.nio.ByteBuffer;
+import java.nio.file.Path;
 import java.util.concurrent.TimeUnit;
 import org.junit.jupiter.api.Test;
 
@@ -30,18 +31,18 @@ public final class VerifierTest {
 
   @Test
   void verification() {
-    FileUtil.useTempFile(
-        file -> {
-          try (Env<ByteBuffer> env =
-              create()
-                  .setMaxReaders(1)
-                  .setMaxDbs(Verifier.DBI_COUNT)
-                  .setMapSize(MEBIBYTES.toBytes(10))
-                  .open(file.toFile(), MDB_NOSUBDIR)) {
-            final Verifier v = new Verifier(env);
-            final int seconds = Integer.getInteger("verificationSeconds", 2);
-            assertThat(v.runFor(seconds, TimeUnit.SECONDS)).isGreaterThan(1L);
-          }
-        });
+    try (final TempDir tempDir = new TempDir()) {
+      final Path file = tempDir.createTempFile();
+      try (Env<ByteBuffer> env =
+          create()
+              .setMaxReaders(1)
+              .setMaxDbs(Verifier.DBI_COUNT)
+              .setMapSize(MEBIBYTES.toBytes(10))
+              .open(file.toFile(), MDB_NOSUBDIR)) {
+        final Verifier v = new Verifier(env);
+        final int seconds = Integer.getInteger("verificationSeconds", 2);
+        assertThat(v.runFor(seconds, TimeUnit.SECONDS)).isGreaterThan(1L);
+      }
+    }
   }
 }
diff --git a/src/test/resources/CursorIterableRangeTest/testSignedComparatorDupsort.csv b/src/test/resources/CursorIterableRangeTest/testSignedComparatorDupsort.csv
index f35dbedc..1a18f426 100644
--- a/src/test/resources/CursorIterableRangeTest/testSignedComparatorDupsort.csv
+++ b/src/test/resources/CursorIterableRangeTest/testSignedComparatorDupsort.csv
@@ -28,7 +28,7 @@ BACKWARD_CLOSED,7,3,[6 8][6 7][4 6][4 5]
 BACKWARD_CLOSED,6,2,[6 8][6 7][4 6][4 5][2 4][2 3]
 BACKWARD_CLOSED,9,3,[8 10][8 9][6 8][6 7][4 6][4 5]
 BACKWARD_CLOSED,9,-1,[8 10][8 9][6 8][6 7][4 6][4 5][2 4][2 3][0 2][0 1]
-BACKWARD_CLOSED_OPEN,8,3,[8 9][6 8][6 7][4 6][4 5]
+BACKWARD_CLOSED_OPEN,8,3,[8 10][8 9][6 8][6 7][4 6][4 5]
 BACKWARD_CLOSED_OPEN,7,2,[6 8][6 7][4 6][4 5]
 BACKWARD_CLOSED_OPEN,9,3,[8 10][8 9][6 8][6 7][4 6][4 5]
 BACKWARD_CLOSED_OPEN,9,-1,[8 10][8 9][6 8][6 7][4 6][4 5][2 4][2 3][0 2][0 1]
diff --git a/src/test/resources/CursorIterableRangeTest/testUnsignedComparatorDupsort.csv b/src/test/resources/CursorIterableRangeTest/testUnsignedComparatorDupsort.csv
index 01cddbad..e9054cbd 100644
--- a/src/test/resources/CursorIterableRangeTest/testUnsignedComparatorDupsort.csv
+++ b/src/test/resources/CursorIterableRangeTest/testUnsignedComparatorDupsort.csv
@@ -28,7 +28,7 @@ BACKWARD_CLOSED,7,3,[6 8][6 7][4 6][4 5]
 BACKWARD_CLOSED,6,2,[6 8][6 7][4 6][4 5][2 4][2 3]
 BACKWARD_CLOSED,9,3,[8 10][8 9][6 8][6 7][4 6][4 5]
 BACKWARD_CLOSED,9,-1,
-BACKWARD_CLOSED_OPEN,8,3,[8 9][6 8][6 7][4 6][4 5]
+BACKWARD_CLOSED_OPEN,8,3,[8 10][8 9][6 8][6 7][4 6][4 5]
 BACKWARD_CLOSED_OPEN,7,2,[6 8][6 7][4 6][4 5]
 BACKWARD_CLOSED_OPEN,9,3,[8 10][8 9][6 8][6 7][4 6][4 5]
 BACKWARD_CLOSED_OPEN,9,-1,
@@ -47,3 +47,14 @@ BACKWARD_OPEN_CLOSED,7,2,[6 8][6 7][4 6][4 5][2 4][2 3]
 BACKWARD_OPEN_CLOSED,8,4,[6 8][6 7][4 6][4 5]
 BACKWARD_OPEN_CLOSED,9,4,[8 10][8 9][6 8][6 7][4 6][4 5]
 BACKWARD_OPEN_CLOSED,9,-1,
+#
+# TEST gh-267
+BACKWARD_AT_LEAST,6,,[6 8][6 7][4 6][4 5][2 4][2 3][0 2][0 1]
+BACKWARD_AT_LEAST,-2,,[-2 -1][-2 0][8 10][8 9][6 8][6 7][4 6][4 5][2 4][2 3][0 2][0 1]
+BACKWARD_AT_LEAST,9,,[8 10][8 9][6 8][6 7][4 6][4 5][2 4][2 3][0 2][0 1]
+BACKWARD_CLOSED,6,3,[6 8][6 7][4 6][4 5]
+BACKWARD_CLOSED,-2,2,[-2 -1][-2 0][8 10][8 9][6 8][6 7][4 6][4 5][2 4][2 3]
+BACKWARD_CLOSED,9,3,[8 10][8 9][6 8][6 7][4 6][4 5]
+BACKWARD_CLOSED_OPEN,6,2,[6 8][6 7][4 6][4 5]
+BACKWARD_CLOSED_OPEN,-2,3,[-2 -1][-2 0][8 10][8 9][6 8][6 7][4 6][4 5]
+BACKWARD_CLOSED_OPEN,9,-1,
\ No newline at end of file

From e634b3f48fd2dcc6790f580085b8c44dd5d7077b Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Thu, 30 Oct 2025 09:00:45 +1100
Subject: [PATCH 242/322] Fix major performance regression

LmdbJava Benchmarking infrastructure was updated in #262. This
uncovered a major regression in releases 0.9.0 and 0.9.1.

To identify the source of the regression, the updated LmdbJava
Benchmarks were executed with 1,000,000 entries using 100 byte values
and 4 byte integer keys. The sequential read benchmark was
retrospectively executed against LmdbJava commits compiled using Java
25 as detailed in the following table. To rule out native library
variability, LMDB 0.9.33 from the official Arch Linux x86_64 native
package was used via the lmdbjava.native.lib system property.
Benchmarks were run on workstation-grade hardware (64 GB RAM, AMD
Ryzen 9 7900 12-Core Processor) to a 32 GB /tmp directory backed by
tmpfs. The machine was not running any other workloads. Tests were
executed for 1 minute per warmup, 1 minute per iteration, 3 warmups, 3
iterations, and 3 forks. As such each commit was tested for
approximately 18 minutes to overcome jitter and noise found at shorter
durations. It was not possible to test intermediate releases 0.6.3 or
0.7.0 due to JNR-FFI incompatibilities.

As shown, the regression was introduced in commit 0c636f1 (#207). This
followed the 0.8.3 release and was included in releases 0.9.0 and
0.9.1.

The fix provided in this commit has been verified with the benchmark result shown below. In
addition to the automated tests passing, a script was written that
executed "mvn test -Dtest=GarbageCollectionTest" (which was provided
in #207) for 1000 iterations with both Java 17 and 25. This
comprehensively confirms this fix does not introduce the adverse
behaviour initially identified in #207. The logical basis for the fix
is also confirmed in the updated JavaDocs for ReferenceUtil.

While there remains a 4.60% regression relative to the 0.0.1 baseline,
this is lower than any release since 0.0.5. Further work to follow on
automating benchmarking infrastructure and addressing other performance
improvement opportunities.

Commit   Release  Date        Score (ms)      Delta  Notes
------------------------------------------------------------------------
57f355f  v0.0.1   2016-07-07  43.22        Baseline
6d001e8  v0.0.5   2017-02-08  43.97          +1.74%
d3572ca  v0.5.0   2017-07-05  45.29          +4.79%
be2a15b  v0.8.3   2023-02-04  45.26          +4.72%
3524995           2023-02-04  45.41          +5.07%  Refactor Comparator handling
9cf97a5           2023-03-09  45.04          +4.21%  mdb_reader_check API fix
0c636f1           2023-03-23  47.83         +10.67%  Hold strong reference (REGRESSION)
cbdaee6           2023-04-24  47.39          +9.65%  Update formatting/GC test
c5e02f7           2023-04-24  48.24         +11.61%  Merge fixcorruptionbug
f17b63f  v0.9.0   2023-12-05  48.54         +12.31%
0025a48  v0.9.1   2025-02-20  47.61         +10.16%
ddca4bd           2025-07-08  47.55         +10.02%  Fix comparator lost buffer ref
c91893a           2025-10-25  58.67         +35.74%  Fix transient pointer (PEAK REGRESSION)
43ac84f           2025-10-26  55.08         +27.43%
a15f4a7           2025-10-29  55.43         +28.24%  Master before fix
19b0250           2025-10-30  45.21          +4.60%  Empty method fix (REGRESSION ELIMINATED)
---
 src/main/java/org/lmdbjava/ReferenceUtil.java | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/src/main/java/org/lmdbjava/ReferenceUtil.java b/src/main/java/org/lmdbjava/ReferenceUtil.java
index 2b9f211e..67273d05 100644
--- a/src/main/java/org/lmdbjava/ReferenceUtil.java
+++ b/src/main/java/org/lmdbjava/ReferenceUtil.java
@@ -33,17 +33,18 @@ private ReferenceUtil() {}
    * but it was only introduced in Java 9. LmdbJava presently supports Java 8 and therefore this
    * method provides an alternative.
    *
-   * <p>This method is always implemented as a synchronization on {@code ref}. <b>It is the caller's
-   * responsibility to ensure that this synchronization will not cause deadlock.</b>
+   * <p>This method works because HotSpot JIT-compilers prune dead locals based on method bytecode
+   * analysis rather than optimized IR. As Vladimir Ivanov explains: "any usage of a local extends
+   * its live range, even if that usage is eliminated in generated code". The method call at the
+   * bytecode level is sufficient to keep the object alive through safepoints, preventing premature
+   * garbage collection during native operations.
    *
-   * @param ref the reference (null is acceptable but has no effect)
-   * @see <a href="https://github.com/netty/netty/pull/8410">Netty PR 8410</a>
+   * @param ref the reference
+   * @see <a href="https://mail.openjdk.org/pipermail/core-libs-dev/2018-February/051312.html">
+   *     Vladimir Ivanov on reachabilityFence implementation</a>
    */
   public static void reachabilityFence0(final Object ref) {
-    if (ref != null) {
-      synchronized (ref) {
-        // Empty synchronized is ok: https://stackoverflow.com/a/31933260/1151521
-      }
-    }
+    // Empty method body is intentional - the method call itself at bytecode level
+    // extends the object's live range per HotSpot JIT behavior
   }
 }

From e5b510c00a693f3746db6afbba1b51fe1dacc1dc Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Thu, 30 Oct 2025 15:56:03 +1100
Subject: [PATCH 243/322] Replace Zig cross-compilation with native library
 artifact

Commit 288bb09 introduced Zig cross-compilation of LMDB (#217).
Benchmarking as part of #262 revealed the cross-compiled libraries are
significantly slower than LMDB compiled with native toolchains. Using
the methodology from e634b3f:

Library Source                  Score (ms)   Delta vs Baseline
--------------------------------------------------------------
System Arch Linux (GCC)         45.00        Baseline
Fetched Arch Linux (GCC)        45.03        +0.05%
Zig unoptimized (debug)         59.01        +31.12%
Zig optimized (-O2 stripped)    58.82        +30.70%

This removes Zig cross-compilation and adopts the org.lmdbjava:native
artifact, which packages LMDB libraries compiled with native toolchains
from distribution package managers. This simplifies building as Zig
installation and cross-compile.sh are no longer required.
---
 .github/workflows/maven.yml                   | 26 -----------
 README.md                                     | 19 ++------
 cross-compile.sh                              | 43 -------------------
 pom.xml                                       | 23 ++++------
 src/main/java/org/lmdbjava/TargetName.java    |  4 +-
 src/main/resources/org/lmdbjava/.gitignore    |  2 -
 .../java/org/lmdbjava/TargetNameTest.java     |  2 +-
 7 files changed, 16 insertions(+), 103 deletions(-)
 delete mode 100755 cross-compile.sh
 delete mode 100644 src/main/resources/org/lmdbjava/.gitignore

diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml
index 372c0c88..38f6472b 100644
--- a/.github/workflows/maven.yml
+++ b/.github/workflows/maven.yml
@@ -22,23 +22,9 @@ jobs:
         java-version: 25
         cache: maven
 
-    - name: Install Zig
-      uses: mlugg/setup-zig@v2
-
-    - name: Cross compile using Zig
-      run: ./cross-compile.sh
-
     - name: Build with Maven
       run: mvn -B verify -DgcRecordWrites=1000
 
-    - name: Store built native libraries for later jobs
-      uses: actions/upload-artifact@v4
-      with:
-        name: native-libraries
-        path: |
-          src/main/resources/org/lmdbjava/*.so
-          src/main/resources/org/lmdbjava/*.dll
-
     - name: Upload code coverage to Codecov
       uses: codecov/codecov-action@v5
       env:
@@ -65,12 +51,6 @@ jobs:
           java-version: ${{ matrix.java }}
           cache: maven
 
-      - name: Fetch built native libraries
-        uses: actions/download-artifact@v4
-        with:
-          name: native-libraries
-          path: src/main/resources/org/lmdbjava
-
       - name: Execute verifier
         run: mvn -B test -Dtest=VerifierTest -DverificationSeconds=10
 
@@ -104,12 +84,6 @@ jobs:
         gpg-private-key: ${{ secrets.gpg_private_key }}
         gpg-passphrase: MAVEN_GPG_PASSPHRASE
 
-    - name: Install Zig
-      uses: mlugg/setup-zig@v2
-
-    - name: Cross compile using Zig
-      run: ./cross-compile.sh
-
     - name: Publish Maven package
       run: mvn -B -Pcentral-deploy deploy -DskipTests
       env:
diff --git a/README.md b/README.md
index 99ccf54f..77a0c164 100644
--- a/README.md
+++ b/README.md
@@ -57,21 +57,10 @@ any questions.
 
 ### Building
 
-This project uses [Zig](https://ziglang.org/) to cross-compile the LMDB native
-library for all supported architectures. To locally build LmdbJava you must
-firstly install a recent version of Zig and then execute the project's
-[cross-compile.sh](https://github.com/lmdbjava/lmdbjava/tree/master/cross-compile.sh)
-script. This only needs to be repeated when the `cross-compile.sh` script is
-updated (eg following a new official release of the upstream LMDB library).
-
-If you do not wish to install Zig and/or use an operating system which cannot
-easily execute the `cross-compile.sh` script, you can download the compiled
-LMDB native library for your platform from a location of your choice and set the
-`lmdbjava.native.lib` system property to the resulting file system
-location. Possible sources of a compiled LMDB native library include operating
-system package managers, running `cross-compile.sh` on a supported system, or
-copying it from the `org/lmdbjava` directory of any recent, officially released
-LmdbJava JAR.
+LmdbJava uses a standard Maven build. Its native libraries are provided by the
+[`org.lmdbjava:native`](https://github.com/lmdbjava/native) dependency.
+
+To use a different LMDB library, set `lmdbjava.native.lib` system property to the file path.
 
 ### Contributing
 
diff --git a/cross-compile.sh b/cross-compile.sh
deleted file mode 100755
index 5243feec..00000000
--- a/cross-compile.sh
+++ /dev/null
@@ -1,43 +0,0 @@
-#!/bin/bash
-#
-# Copyright © 2016-2025 The LmdbJava Open Source Project
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-
-set -o errexit
-
-rm -rf openldap
-git clone --depth 1 --branch LMDB_0.9.33 https://git.openldap.org/openldap/openldap.git
-pushd openldap/libraries/liblmdb
-trap popd SIGINT
-
-# zig targets | jq -r '.libc[]'
-for target in aarch64-linux-gnu \
-              aarch64-macos-none \
-              x86_64-linux-gnu \
-              x86_64-macos-none \
-              x86_64-windows-gnu
-do
-  echo "##### Building $target ####"
-  make -e clean liblmdb.so CC="zig cc -target $target" AR="zig ar"
-  if [[ "$target" == *-windows-* ]]; then
-    extension="dll"
-  else
-    extension="so"
-  fi
-  cp -v liblmdb.so ../../../src/main/resources/org/lmdbjava/$target.$extension
-done
-
-ls -l ../../../src/main/resources/org/lmdbjava
diff --git a/pom.xml b/pom.xml
index 3cb7ccc5..4d60b903 100644
--- a/pom.xml
+++ b/pom.xml
@@ -39,6 +39,7 @@
     <jnr-ffi.version>2.2.18</jnr-ffi.version>
     <junit.version>5.14.0</junit.version>
     <license-maven-plugin.version>4.6</license-maven-plugin.version>
+    <lmdbjava-native.version>0.9.33-2</lmdbjava-native.version>
     <maven-clean-plugin.version>3.5.0</maven-clean-plugin.version>
     <maven-compiler-plugin.version>3.14.1</maven-compiler-plugin.version>
     <maven-dependency-plugin.version>3.9.0</maven-dependency-plugin.version>
@@ -120,6 +121,11 @@
       <version>${junit.version}</version>
       <scope>test</scope>
     </dependency>
+    <dependency>
+      <groupId>org.lmdbjava</groupId>
+      <artifactId>native</artifactId>
+      <version>${lmdbjava-native.version}</version>
+    </dependency>
     <dependency>
       <groupId>org.mockito</groupId>
       <artifactId>mockito-inline</artifactId>
@@ -407,20 +413,9 @@
   </licenses>
   <developers>
     <developer>
-      <id>krisskross</id>
-      <name>Kristoffer Sjogren</name>
-      <email>stoffe -at- gmail.com</email>
-      <url>http://stoffe.deephacks.org/</url>
-      <organization/>
-      <timezone>+1</timezone>
-    </developer>
-    <developer>
-      <id>benalexau</id>
-      <name>Ben Alex</name>
-      <email>ben.alex@acegi.com.au</email>
-      <url>https://github.com/benalexau/</url>
-      <organization>Acegi Technology Pty Limited</organization>
-      <timezone>+10</timezone>
+      <id>lmdbjava</id>
+      <name>The LmdbJava Open Source Project</name>
+      <url>https://github.com/lmdbjava</url>
     </developer>
   </developers>
   <scm>
diff --git a/src/main/java/org/lmdbjava/TargetName.java b/src/main/java/org/lmdbjava/TargetName.java
index 023ecba5..e3bb5db0 100644
--- a/src/main/java/org/lmdbjava/TargetName.java
+++ b/src/main/java/org/lmdbjava/TargetName.java
@@ -43,7 +43,7 @@ public final class TargetName {
    * Java system property name that can be set to override the embedded library that will be used.
    * This is likely to be required if automatic resolution fails but the user still prefers to use
    * an LmdbJava-bundled library. This path must include the classpath prefix (usually <code>
-   * org/lmdbjava</code>).
+   * org/lmdbjava/native</code>).
    */
   public static final String LMDB_EMBEDDED_LIB_PROP = "lmdbjava.embedded.lib";
 
@@ -94,7 +94,7 @@ static String resolveFilename(
 
     final String pkg = TargetName.class.getPackage().getName().replace('.', '/');
     return pkg
-        + "/"
+        + "/native/"
         + resolveArch(arch)
         + "-"
         + resolveOs(os)
diff --git a/src/main/resources/org/lmdbjava/.gitignore b/src/main/resources/org/lmdbjava/.gitignore
deleted file mode 100644
index 661f98b3..00000000
--- a/src/main/resources/org/lmdbjava/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-*.so
-*.dll
diff --git a/src/test/java/org/lmdbjava/TargetNameTest.java b/src/test/java/org/lmdbjava/TargetNameTest.java
index e766aaa6..04caea83 100644
--- a/src/test/java/org/lmdbjava/TargetNameTest.java
+++ b/src/test/java/org/lmdbjava/TargetNameTest.java
@@ -61,7 +61,7 @@ void externalTakesPriority() {
   }
 
   private void embed(final String lib, final String arch, final String os) {
-    assertThat(resolveFilename(NONE, NONE, arch, os)).isEqualTo("org/lmdbjava/" + lib);
+    assertThat(resolveFilename(NONE, NONE, arch, os)).isEqualTo("org/lmdbjava/native/" + lib);
     assertThat(isExternal(NONE)).isFalse();
   }
 }

From dc24f4b6010e3cbcd498a3d227ddde9e5983a265 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Fri, 31 Oct 2025 11:20:59 +1100
Subject: [PATCH 244/322] Generalise benchmark link

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 77a0c164..adf3fbbf 100644
--- a/README.md
+++ b/README.md
@@ -23,7 +23,7 @@
 
 **LmdbJava** adds Java-specific features to LMDB:
 
-* [Extremely fast](https://github.com/lmdbjava/benchmarks/blob/master/results/20160710/README.md) across a broad range of benchmarks, data sizes and access patterns
+* [Extremely fast](https://github.com/lmdbjava/benchmarks) across a broad range of benchmarks, data sizes and access patterns
 * Modern, idiomatic Java API (including iterators, key ranges, enums, exceptions etc)
 * Nothing to install (the JAR embeds the latest LMDB libraries for Linux, OS X and Windows)
 * Buffer agnostic (Java `ByteBuffer`, Agrona `DirectBuffer`, Netty `ByteBuf`, your own buffer)

From ab6a6a0462a29b8bdc42ca63d506111e4936141f Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Tue, 4 Nov 2025 14:00:22 +1100
Subject: [PATCH 245/322] Resolve write performance regression (fixes #268)

Bisection using the LmdbJava Benchmarks project identified a 40%
write performance regression introduced in commit 68f0a44:

  Commit   Date                    Score    Change     Message
===============================================================================
   be2a15b  2023-02-04 00:28:16     89.07             [maven-release-plugin] pr
   1cc7e6c  2023-12-04 07:42:08     94.49     +6.09%  Test on Java 21
   f17b63f  2023-12-05 01:34:17     91.57     -3.09%  [maven-release-plugin] pr
   b5dfb25  2025-02-16 23:37:16     91.38     -0.21%  Uplift lmdb from 0.9.29 t
 * 68f0a44  2025-02-16 23:46:30    128.63    +40.76%  Add DbiFlags#MDB_UNSIGNED
   928cf7b  2025-02-20 01:26:13    129.12     +0.38%  Add url element to pom.xm
   dc24f4b  2025-10-31 00:20:59    122.03     -5.49%  Generalise benchmark link

Root cause: MaskedFlag.mask() was changed from a simple for-loop to
Stream API in commit 68f0a44. This method is invoked once per write
operation (Cursor.put() line 255), causing significant overhead from
stream creation, lambda allocation, and boxing/unboxing.

Fix: Restore for-loop implementation while preserving the
onlyPropagatedToLmdb filtering logic added in 68f0a44.

Performance verified with 1M entry write benchmark:
  - Before fix: 122.03 ms/op
  - After fix: 90.43 ms/op (within 2% of baseline 89.07 ms/op)
---
 src/main/java/org/lmdbjava/MaskedFlag.java | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/src/main/java/org/lmdbjava/MaskedFlag.java b/src/main/java/org/lmdbjava/MaskedFlag.java
index 00556ecb..58d67d8c 100644
--- a/src/main/java/org/lmdbjava/MaskedFlag.java
+++ b/src/main/java/org/lmdbjava/MaskedFlag.java
@@ -75,7 +75,20 @@ static <M extends MaskedFlag> int mask(final Stream<M> flags) {
    */
   @SafeVarargs
   static <M extends MaskedFlag> int mask(final boolean onlyPropagatedToLmdb, final M... flags) {
-    return flags == null ? 0 : mask(onlyPropagatedToLmdb, Arrays.stream(flags));
+    if (flags == null || flags.length == 0) {
+      return 0;
+    }
+
+    int result = 0;
+    for (final M flag : flags) {
+      if (flag == null) {
+        continue;
+      }
+      if (!onlyPropagatedToLmdb || flag.isPropagatedToLmdb()) {
+        result |= flag.getMask();
+      }
+    }
+    return result;
   }
 
   /**

From c4278017c23b10fe2e052e27ecf4fe6702cad5f8 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Tue, 4 Nov 2025 15:01:16 +0000
Subject: [PATCH 246/322] Add/refactor tests

---
 .../java/org/lmdbjava/AbstractFlagSet.java    |  13 +
 .../java/org/lmdbjava/ByteBufferProxy.java    |   4 +-
 src/main/java/org/lmdbjava/Cursor.java        |   2 +-
 src/main/java/org/lmdbjava/DbiBuilder.java    |  21 +-
 .../org/lmdbjava/ByteBufferProxyTest.java     |  17 +-
 .../CursorIterableIntegerDupTest.java         |  39 ++-
 .../CursorIterableIntegerKeyTest.java         | 154 ++++++++----
 .../java/org/lmdbjava/CursorIterableTest.java |  16 +-
 .../java/org/lmdbjava/DbiBuilderTest.java     |   6 +-
 src/test/java/org/lmdbjava/DbiTest.java       |  34 +--
 .../java/org/lmdbjava/PutFlagSetTest.java     | 225 ++++++++++--------
 src/test/java/org/lmdbjava/TestUtils.java     |   8 +
 12 files changed, 351 insertions(+), 188 deletions(-)

diff --git a/src/main/java/org/lmdbjava/AbstractFlagSet.java b/src/main/java/org/lmdbjava/AbstractFlagSet.java
index 25aa328b..6e9729fb 100644
--- a/src/main/java/org/lmdbjava/AbstractFlagSet.java
+++ b/src/main/java/org/lmdbjava/AbstractFlagSet.java
@@ -325,6 +325,19 @@ public Builder<E, S> setFlag(final E flag) {
       return this;
     }
 
+    /**
+     * Sets multiple flag in the builder.
+     *
+     * @param flags The flags to set in the builder.
+     * @return this builder instance.
+     */
+    public Builder<E, S> setFlags(final Collection<E> flags) {
+      if (flags != null) {
+        enumSet.addAll(flags);
+      }
+      return this;
+    }
+
     /**
      * Clears any flags already set in this {@link Builder}
      *
diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
index 5d5aa2ca..27ae375e 100644
--- a/src/main/java/org/lmdbjava/ByteBufferProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -162,7 +162,9 @@ public static int compareLexicographically(final ByteBuffer o1, final ByteBuffer
     public static int compareAsIntegerKeys(final ByteBuffer o1, final ByteBuffer o2) {
       requireNonNull(o1);
       requireNonNull(o2);
-      // Both buffers should be same lenght according to LMDB API.
+      // Both buffers should be same length according to LMDB API.
+      // From the LMDB docs for MDB_INTEGER_KEY
+      // numeric keys in native byte order: either unsigned int or size_t. The keys must all be of the same size.
       final int len1 = o1.limit();
       final int len2 = o2.limit();
       if (len1 != len2) {
diff --git a/src/main/java/org/lmdbjava/Cursor.java b/src/main/java/org/lmdbjava/Cursor.java
index c1ac7374..127fffc0 100644
--- a/src/main/java/org/lmdbjava/Cursor.java
+++ b/src/main/java/org/lmdbjava/Cursor.java
@@ -472,7 +472,7 @@ public T reserve(final T key, final int size) {
    * Reserve space for data of the given size, but don't copy the given val. Instead, return a
    * pointer to the reserved space, which the caller can fill in later - before the next update
    * operation or the transaction ends. This saves an extra memcpy if the data is being generated
-   * later. LMDB does nothing else with this memory, the caller is expected to modify all of the
+   * later. LMDB does nothing else with this memory, the caller is expected to modify all the
    * space requested.
    *
    * <p>This flag must not be specified if the database was opened with MDB_DUPSORT
diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
index 2b4e6ad8..1bf2489d 100644
--- a/src/main/java/org/lmdbjava/DbiBuilder.java
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -80,6 +80,9 @@ public DbiBuilderStage2<T> withDbName(final byte[] name) {
    * Equivalent to passing null to
    * {@link DbiBuilder#withDbName(String)} or {@link DbiBuilder#withDbName(byte[])}.
    * </p>
+   * <p>Note: The 'unnamed database' is used by LMDB to store the names of named databases, with
+   * the database name being the key. Use of the unnamed database is intended for simple applications
+   * with only one database.</p>
    * @return The next builder stage.
    */
   public DbiBuilderStage2<T> withoutDbName() {
@@ -323,7 +326,7 @@ public DbiBuilderStage3<T> withDbiFlags(final DbiFlagSet dbiFlagSet) {
      * {@link DbiBuilderStage3#withDbiFlags(Collection)}
      * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
      *
-     * @param dbiFlag to open the database with. A null value is a no-op.
+     * @param dbiFlag to add to any existing flags. A null value is a no-op.
      * @return this builder instance.
      */
     public DbiBuilderStage3<T> addDbiFlag(final DbiFlags dbiFlag) {
@@ -331,6 +334,22 @@ public DbiBuilderStage3<T> addDbiFlag(final DbiFlags dbiFlag) {
       return this;
     }
 
+    /**
+     * Adds a dbiFlag to those flags already added to this builder by
+     * {@link DbiBuilderStage3#withDbiFlags(DbiFlags...)},
+     * {@link DbiBuilderStage3#withDbiFlags(Collection)}
+     * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
+     *
+     * @param dbiFlagSet to add to any existing flags. A null value is a no-op.
+     * @return this builder instance.
+     */
+    public DbiBuilderStage3<T> addDbiFlags(final DbiFlagSet dbiFlagSet) {
+      if (dbiFlagSet != null) {
+        flagSetBuilder.setFlags(dbiFlagSet.getFlags());
+      }
+      return this;
+    }
+
     /**
      * Use the supplied transaction to open the {@link Dbi}.
      * <p>
diff --git a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
index c7d8333f..fb736f41 100644
--- a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
+++ b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
@@ -43,6 +43,7 @@
 import java.nio.ByteOrder;
 import java.time.Duration;
 import java.time.Instant;
+import java.util.Arrays;
 import java.util.Comparator;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
@@ -142,9 +143,9 @@ public void unsafeIsDefault() {
   }
 
   /**
-   * For 100 rounds of 1,000,000 comparisons
-   * compareAsIntegerKeys: PT0.267813487S
-   * compareLexicographically: PT0.644165235S
+   * For 100 rounds of 5,000,000 comparisons
+   * compareAsIntegerKeys: PT1.600525631S
+   * compareLexicographically: PT3.381935001S
    */
   @Test
   public void comparatorPerformance() {
@@ -153,7 +154,7 @@ public void comparatorPerformance() {
     final ByteBuffer buffer2 = ByteBuffer.allocateDirect(Long.BYTES);
     buffer1.limit(Long.BYTES);
     buffer2.limit(Long.BYTES);
-    final long[] values = random.longs(1_000_000).toArray();
+    final long[] values = random.longs(5_000_000).toArray();
 
     Instant time = Instant.now();
     int x = 0;
@@ -195,7 +196,13 @@ public void verifyComparators() {
     buffer2native.limit(Long.BYTES);
     buffer1be.limit(Long.BYTES);
     buffer2be.limit(Long.BYTES);
-    final long[] values = random.longs(10_000_000).toArray();
+    final long[] values = random.longs()
+        .filter(i -> i >= 0)
+        .limit(5_000_000)
+        .toArray();
+    System.out.println("stats: " + Arrays.stream(values)
+        .summaryStatistics()
+        .toString());
 
     final LinkedHashMap<String, Comparator<ByteBuffer>> comparators = new LinkedHashMap<>();
     comparators.put("compareAsIntegerKeys", ByteBufferProxy.AbstractByteBufferProxy::compareAsIntegerKeys);
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
index 1acf4328..189aad24 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
@@ -50,6 +50,7 @@
 import static org.lmdbjava.TestUtils.bb;
 import static org.lmdbjava.TestUtils.bbNative;
 import static org.lmdbjava.TestUtils.getNativeInt;
+import static org.lmdbjava.TestUtils.getNativeIntOrLong;
 
 import com.google.common.primitives.UnsignedBytes;
 import java.io.File;
@@ -71,6 +72,7 @@
 import org.hamcrest.CoreMatchers;
 import org.hamcrest.Matchers;
 import org.junit.After;
+import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Ignore;
 import org.junit.Rule;
@@ -88,7 +90,10 @@
 @RunWith(Parameterized.class)
 public final class CursorIterableIntegerDupTest {
 
-  private static final DbiFlagSet DBI_FLAGS = DbiFlagSet.of(MDB_CREATE, MDB_INTEGERDUP, MDB_DUPSORT);
+  private static final DbiFlagSet DBI_FLAGS = DbiFlagSet.of(
+      MDB_CREATE,
+      MDB_INTEGERDUP,
+      MDB_DUPSORT);
   private static final BufferProxy<ByteBuffer> BUFFER_PROXY = ByteBufferProxy.PROXY_OPTIMAL;
   private static final List<Map.Entry<Integer, Integer>> INPUT_DATA;
 
@@ -122,35 +127,47 @@ public final class CursorIterableIntegerDupTest {
 
   @Parameterized.Parameters(name = "{index}: dbi: {0}")
   public static Object[] data() {
-    final DbiFactory defaultComparator = new DbiFactory("defaultComparator", env ->
+    final DbiFactory defaultComparatorDb = new DbiFactory("defaultComparator", env ->
         env.buildDbi()
             .withDbName(DB_1)
             .withDefaultComparator()
             .withDbiFlags(DBI_FLAGS)
             .open());
-    final DbiFactory nativeComparator = new DbiFactory("nativeComparator", env ->
+    final DbiFactory nativeComparatorDb = new DbiFactory("nativeComparator", env ->
         env.buildDbi()
             .withDbName(DB_2)
             .withNativeComparator()
             .withDbiFlags(DBI_FLAGS)
             .open());
-    final DbiFactory callbackComparator = new DbiFactory("callbackComparator", env ->
+    final DbiFactory callbackComparatorDb = new DbiFactory("callbackComparator", env ->
         env.buildDbi()
             .withDbName(DB_3)
-            .withCallbackComparator(BUFFER_PROXY.getComparator(DBI_FLAGS))
+            .withCallbackComparator(buildComparator())
             .withDbiFlags(DBI_FLAGS)
             .open());
-    final DbiFactory iteratorComparator = new DbiFactory("iteratorComparator", env ->
+    final DbiFactory iteratorComparatorDb = new DbiFactory("iteratorComparator", env ->
         env.buildDbi()
             .withDbName(DB_4)
-            .withIteratorComparator(BUFFER_PROXY.getComparator(DBI_FLAGS))
+            .withIteratorComparator(buildComparator())
             .withDbiFlags(DBI_FLAGS)
             .open());
     return new Object[]{
-        defaultComparator,
-        nativeComparator,
-        callbackComparator,
-        iteratorComparator};
+        defaultComparatorDb,
+        nativeComparatorDb,
+        callbackComparatorDb,
+        iteratorComparatorDb};
+  }
+
+  private static Comparator<ByteBuffer> buildComparator() {
+    final Comparator<ByteBuffer> baseComparator = BUFFER_PROXY.getComparator(DBI_FLAGS);
+    return (o1, o2) -> {
+      if (o1.remaining() != o2.remaining()) {
+        // Make sure LMDB is always giving us consistent key lengths.
+        Assert.fail("o1: " + o1 + " " + getNativeIntOrLong(o1)
+            + ", o2: " + o2 + " " + getNativeIntOrLong(o2));
+      }
+      return baseComparator.compare(o1, o2);
+    };
   }
 
   @Before
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
index be91ea4c..1e664fb1 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
@@ -51,6 +51,8 @@
 import static org.lmdbjava.TestUtils.bb;
 import static org.lmdbjava.TestUtils.bbNative;
 import static org.lmdbjava.TestUtils.getNativeInt;
+import static org.lmdbjava.TestUtils.getNativeIntOrLong;
+import static org.lmdbjava.TestUtils.getNativeLong;
 import static org.lmdbjava.TestUtils.getString;
 
 import com.google.common.primitives.UnsignedBytes;
@@ -71,6 +73,7 @@
 import java.util.stream.Collectors;
 import org.hamcrest.Matchers;
 import org.junit.After;
+import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
@@ -104,35 +107,49 @@ public final class CursorIterableIntegerKeyTest {
 
   @Parameterized.Parameters(name = "{index}: dbi: {0}")
   public static Object[] data() {
-    final DbiFactory defaultComparator = new DbiFactory("defaultComparator", env ->
+    final DbiFactory defaultComparatorDb = new DbiFactory("defaultComparator", env ->
         env.buildDbi()
             .withDbName(DB_1)
             .withDefaultComparator()
             .withDbiFlags(DBI_FLAGS)
             .open());
-    final DbiFactory nativeComparator = new DbiFactory("nativeComparator", env ->
+    final DbiFactory nativeComparatorDb = new DbiFactory("nativeComparator", env ->
         env.buildDbi()
             .withDbName(DB_2)
             .withNativeComparator()
             .withDbiFlags(DBI_FLAGS)
             .open());
-    final DbiFactory callbackComparator = new DbiFactory("callbackComparator", env ->
+    final Comparator<ByteBuffer> comparator = buildComparator();
+
+    final DbiFactory callbackComparatorDb = new DbiFactory("callbackComparator", env ->
         env.buildDbi()
             .withDbName(DB_3)
-            .withCallbackComparator(BUFFER_PROXY.getComparator(DBI_FLAGS))
+            .withCallbackComparator(comparator)
             .withDbiFlags(DBI_FLAGS)
             .open());
-    final DbiFactory iteratorComparator = new DbiFactory("iteratorComparator", env ->
+    final DbiFactory iteratorComparatorDb = new DbiFactory("iteratorComparator", env ->
         env.buildDbi()
             .withDbName(DB_4)
-            .withIteratorComparator(BUFFER_PROXY.getComparator(DBI_FLAGS))
+            .withIteratorComparator(comparator)
             .withDbiFlags(DBI_FLAGS)
             .open());
     return new Object[]{
-        defaultComparator,
-        nativeComparator,
-        callbackComparator,
-        iteratorComparator};
+        defaultComparatorDb,
+        nativeComparatorDb,
+        callbackComparatorDb,
+        iteratorComparatorDb};
+  }
+
+  private static Comparator<ByteBuffer> buildComparator() {
+    final Comparator<ByteBuffer> baseComparator = BUFFER_PROXY.getComparator(DBI_FLAGS);
+    return (o1, o2) -> {
+      if (o1.remaining() != o2.remaining()) {
+        // Make sure LMDB is always giving us consistent key lengths.
+        Assert.fail("o1: " + o1 + " " + getNativeIntOrLong(o1)
+            + ", o2: " + o2 + " " + getNativeIntOrLong(o2));
+      }
+      return baseComparator.compare(o1, o2);
+    };
   }
 
   @Before
@@ -162,13 +179,13 @@ public void testNumericOrderLong() {
       final Cursor<ByteBuffer> c = dbi.openCursor(txn);
       long i = 1;
       while (true) {
-//        System.out.println("putting " + i);
+        System.out.println("putting " + i);
         c.put(bbNative(i), bb(i + "-long"));
-          final long i2 = i * 10;
-          if (i2 < i) {
-            // Overflowed
-            break;
-          }
+        final long i2 = i * 10;
+        if (i2 < i) {
+          // Overflowed
+          break;
+        }
         i = i2;
       }
       txn.commit();
@@ -178,8 +195,9 @@ public void testNumericOrderLong() {
     try (Txn<ByteBuffer> txn = env.txnRead()) {
       try (CursorIterable<ByteBuffer> iterable = dbi.iterate(txn)) {
         for (KeyVal<ByteBuffer> keyVal : iterable) {
+          assertThat(keyVal.key().remaining(), is(Long.BYTES));
           final String val = getString(keyVal.val());
-          final long key = TestUtils.getNativeLong(keyVal.key());
+          final long key = getNativeLong(keyVal.key());
           entries.add(new AbstractMap.SimpleEntry<>(key, val));
 //          System.out.println(val);
         }
@@ -208,7 +226,7 @@ public void testNumericOrderInt() {
       final Cursor<ByteBuffer> c = dbi.openCursor(txn);
       int i = 1;
       while (true) {
-//        System.out.println("putting " + i);
+        System.out.println("putting " + i);
         c.put(bbNative(i), bb(i + "-int"));
         final int i2 = i * 10;
         if (i2 < i) {
@@ -224,6 +242,7 @@ public void testNumericOrderInt() {
     try (Txn<ByteBuffer> txn = env.txnRead()) {
       try (CursorIterable<ByteBuffer> iterable = dbi.iterate(txn)) {
         for (KeyVal<ByteBuffer> keyVal : iterable) {
+          assertThat(keyVal.key().remaining(), is(Integer.BYTES));
           final String val = getString(keyVal.val());
           final int key = TestUtils.getNativeInt(keyVal.key());
           entries.add(new AbstractMap.SimpleEntry<>(key, val));
@@ -246,6 +265,41 @@ public void testNumericOrderInt() {
     }
   }
 
+  @Test
+  public void testIntegerKeyKeySize() {
+    final Dbi<ByteBuffer> db = dbiFactory.factory.apply(env);
+    long maxIntAsLong = Integer.MAX_VALUE;
+
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      System.out.println("Flags: " + db.listFlags(txn));
+      int val = 0;
+      db.put(txn, bbNative(0L), bb("val_" + ++val));
+      db.put(txn, bbNative(10L), bb("val_" + ++val));
+      db.put(txn, bbNative(maxIntAsLong - 1_111_111_111), bb("val_" + ++val));
+      db.put(txn, bbNative(maxIntAsLong - 111_111_111), bb("val_" + ++val));
+      db.put(txn, bbNative(maxIntAsLong - 111_111), bb("val_" + ++val));
+      db.put(txn, bbNative(maxIntAsLong - 111), bb("val_" + ++val));
+      db.put(txn, bbNative(maxIntAsLong + 111), bb("val_" + ++val));
+      db.put(txn, bbNative(maxIntAsLong + 111_111), bb("val_" + ++val));
+      db.put(txn, bbNative(maxIntAsLong + 111_111_111), bb("val_" + ++val));
+      db.put(txn, bbNative(maxIntAsLong + 1_111_111_111), bb("val_" + ++val));
+      db.put(txn, bbNative(Long.MAX_VALUE), bb("val_" + ++val));
+      txn.commit();
+    }
+
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      try (CursorIterable<ByteBuffer> iterable = db.iterate(txn)) {
+        for (KeyVal<ByteBuffer> keyVal : iterable) {
+          final String val = getString(keyVal.val());
+          final long key = getNativeLong(keyVal.key());
+          final int remaining = keyVal.key().remaining();
+          System.out.println("key: " + key + ", val: " + val + ", remaining: " + remaining);
+        }
+      }
+    }
+
+  }
+
   @Test
   public void allBackwardTest() {
     verify(allBackward(), 8, 6, 4, 2);
@@ -365,11 +419,11 @@ public void iterate() {
   @Test(expected = IllegalStateException.class)
   public void iteratorOnlyReturnedOnce() {
     final Dbi<ByteBuffer> db = getDb();
-      try (Txn<ByteBuffer> txn = env.txnRead();
-           CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-        c.iterator(); // ok
-        c.iterator(); // fails
-      }
+    try (Txn<ByteBuffer> txn = env.txnRead();
+         CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+      c.iterator(); // ok
+      c.iterator(); // fails
+    }
   }
 
   @Test
@@ -472,57 +526,57 @@ public void removeOddElements() {
   @Test(expected = Env.AlreadyClosedException.class)
   public void nextWithClosedEnvTest() {
     final Dbi<ByteBuffer> db = getDb();
-      try (Txn<ByteBuffer> txn = env.txnRead()) {
-        try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
 
-          env.close();
-          c.next();
-        }
+        env.close();
+        c.next();
       }
+    }
   }
 
   @Test(expected = Env.AlreadyClosedException.class)
   public void removeWithClosedEnvTest() {
     final Dbi<ByteBuffer> db = getDb();
-      try (Txn<ByteBuffer> txn = env.txnWrite()) {
-        try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
 
-          final KeyVal<ByteBuffer> keyVal = c.next();
-          assertThat(keyVal, Matchers.notNullValue());
+        final KeyVal<ByteBuffer> keyVal = c.next();
+        assertThat(keyVal, Matchers.notNullValue());
 
-          env.close();
-          c.remove();
-        }
+        env.close();
+        c.remove();
       }
+    }
   }
 
   @Test(expected = Env.AlreadyClosedException.class)
   public void hasNextWithClosedEnvTest() {
     final Dbi<ByteBuffer> db = getDb();
-      try (Txn<ByteBuffer> txn = env.txnRead()) {
-        try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
 
-          env.close();
-          c.hasNext();
-        }
+        env.close();
+        c.hasNext();
       }
+    }
   }
 
   @Test(expected = Env.AlreadyClosedException.class)
   public void forEachRemainingWithClosedEnvTest() {
     final Dbi<ByteBuffer> db = getDb();
-      try (Txn<ByteBuffer> txn = env.txnRead()) {
-        try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
 
-          env.close();
-          c.forEachRemaining(keyVal -> {
-          });
-        }
+        env.close();
+        c.forEachRemaining(keyVal -> {
+        });
       }
+    }
   }
 
   private void verify(final KeyRange<ByteBuffer> range, final int... expected) {
diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index 7bcbd851..a6b5d7d1 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -93,35 +93,35 @@ public final class CursorIterableTest {
 
   @Parameterized.Parameters(name = "{index}: dbi: {0}")
   public static Object[] data() {
-    final DbiFactory defaultComparator = new DbiFactory("defaultComparator", env ->
+    final DbiFactory defaultComparatorDb = new DbiFactory("defaultComparator", env ->
         env.buildDbi()
             .withDbName(DB_1)
             .withDefaultComparator()
             .withDbiFlags(DBI_FLAGS)
             .open());
-    final DbiFactory nativeComparator = new DbiFactory("nativeComparator", env ->
+    final DbiFactory nativeComparatorDb = new DbiFactory("nativeComparator", env ->
         env.buildDbi()
             .withDbName(DB_2)
             .withNativeComparator()
             .withDbiFlags(DBI_FLAGS)
             .open());
-    final DbiFactory callbackComparator = new DbiFactory("callbackComparator", env ->
+    final DbiFactory callbackComparatorDb = new DbiFactory("callbackComparator", env ->
         env.buildDbi()
             .withDbName(DB_3)
             .withCallbackComparator(BUFFER_PROXY.getComparator(DBI_FLAGS))
             .withDbiFlags(DBI_FLAGS)
             .open());
-    final DbiFactory iteratorComparator = new DbiFactory("iteratorComparator", env ->
+    final DbiFactory iteratorComparatorDb = new DbiFactory("iteratorComparator", env ->
         env.buildDbi()
             .withDbName(DB_4)
             .withIteratorComparator(BUFFER_PROXY.getComparator(DBI_FLAGS))
             .withDbiFlags(DBI_FLAGS)
             .open());
     return new Object[] {
-        defaultComparator,
-        nativeComparator,
-        callbackComparator,
-        iteratorComparator};
+        defaultComparatorDb,
+        nativeComparatorDb,
+        callbackComparatorDb,
+        iteratorComparatorDb};
   }
 
   @Before
diff --git a/src/test/java/org/lmdbjava/DbiBuilderTest.java b/src/test/java/org/lmdbjava/DbiBuilderTest.java
index 74fbd8f5..6f6a4f39 100644
--- a/src/test/java/org/lmdbjava/DbiBuilderTest.java
+++ b/src/test/java/org/lmdbjava/DbiBuilderTest.java
@@ -60,13 +60,12 @@ public void unnamed() {
         .withDefaultComparator()
         .withDbiFlags(DbiFlags.MDB_CREATE)
         .open();
-
+    assertThat(dbi.getName(), Matchers.nullValue());
+    assertThat(dbi.getNameAsString(), Matchers.emptyString());
     assertThat(env.getDbiNames().size(), Matchers.is(0));
-
     assertPutAndGet(dbi);
   }
 
-
   @Test
   public void named() {
     final Dbi<ByteBuffer> dbi = env.buildDbi()
@@ -89,6 +88,7 @@ private void assertPutAndGet(Dbi<ByteBuffer> dbi) {
 
     try (Txn<ByteBuffer> readTxn = env.txnRead()) {
       final ByteBuffer byteBuffer = dbi.get(readTxn, bb(123));
+      assertThat(byteBuffer, Matchers.notNullValue());
       final int val = byteBuffer.getInt();
       assertThat(val, Matchers.is(123_000));
     }
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 2209e614..962aacab 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -74,10 +74,13 @@
 import org.lmdbjava.Env.MapFullException;
 import org.lmdbjava.LmdbNativeException.ConstantDerivedException;
 
-/** Test {@link Dbi}. */
+/**
+ * Test {@link Dbi}.
+ */
 public final class DbiTest {
 
-  @Rule public final TemporaryFolder tmp = new TemporaryFolder();
+  @Rule
+  public final TemporaryFolder tmp = new TemporaryFolder();
   private Env<ByteBuffer> env;
   private Env<byte[]> envBa;
 
@@ -105,10 +108,13 @@ public void before() throws IOException {
   }
 
 
-
   @Test(expected = ConstantDerivedException.class)
   public void close() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> db = env.buildDbi()
+        .withDbName(DB_1)
+        .withDefaultComparator()
+        .addDbiFlag(MDB_CREATE)
+        .open();
     db.put(bb(1), bb(42));
     db.close();
     db.put(bb(2), bb(42)); // error
@@ -154,7 +160,7 @@ private <T> void doCustomComparator(
       txn.commit();
     }
     try (Txn<T> txn = env.txnRead();
-        CursorIterable<T> ci = db.iterate(txn, atMost(serializer.apply(4)))) {
+         CursorIterable<T> ci = db.iterate(txn, atMost(serializer.apply(4)))) {
       final Iterator<KeyVal<T>> iter = ci.iterator();
       assertThat(deserializer.applyAsInt(iter.next().key()), is(8));
       assertThat(deserializer.applyAsInt(iter.next().key()), is(6));
@@ -186,7 +192,7 @@ public <T> void doDbiWithComparatorThreadSafety(
       Supplier<Comparator<T>> comparatorSupplier,
       IntFunction<T> serializer,
       ToIntFunction<T> deserializer) {
-    final DbiFlags[] flags = new DbiFlags[] {MDB_CREATE, MDB_INTEGERKEY};
+    final DbiFlags[] flags = new DbiFlags[]{MDB_CREATE, MDB_INTEGERKEY};
     final Comparator<T> c = comparatorSupplier.get();
     final Dbi<T> db = env.openDbi(DB_1, c, true, flags);
 
@@ -212,7 +218,7 @@ public <T> void doDbiWithComparatorThreadSafety(
     }
 
     try (Txn<T> txn = env.txnRead();
-        CursorIterable<T> ci = db.iterate(txn)) {
+         CursorIterable<T> ci = db.iterate(txn)) {
       final Iterator<KeyVal<T>> iter = ci.iterator();
       final List<Integer> result = new ArrayList<>();
       while (iter.hasNext()) {
@@ -292,8 +298,8 @@ public void getName() {
 
   @Test
   public void getNamesWhenDbisPresent() {
-    final byte[] dbHello = new byte[] {'h', 'e', 'l', 'l', 'o'};
-    final byte[] dbWorld = new byte[] {'w', 'o', 'r', 'l', 'd'};
+    final byte[] dbHello = new byte[]{'h', 'e', 'l', 'l', 'o'};
+    final byte[] dbWorld = new byte[]{'w', 'o', 'r', 'l', 'd'};
     env.openDbi(dbHello, MDB_CREATE);
     env.openDbi(dbWorld, MDB_CREATE);
     final List<byte[]> dbiNames = env.getDbiNames();
@@ -369,11 +375,11 @@ public void putCommitGet() {
   public void putCommitGetByteArray() throws IOException {
     final File path = tmp.newFile();
     try (Env<byte[]> envBa =
-        create(PROXY_BA)
-            .setMapSize(MEBIBYTES.toBytes(64))
-            .setMaxReaders(1)
-            .setMaxDbs(2)
-            .open(path, MDB_NOSUBDIR)) {
+             create(PROXY_BA)
+                 .setMapSize(MEBIBYTES.toBytes(64))
+                 .setMaxReaders(1)
+                 .setMaxDbs(2)
+                 .open(path, MDB_NOSUBDIR)) {
       final Dbi<byte[]> db = envBa.openDbi(DB_1, MDB_CREATE);
       try (Txn<byte[]> txn = envBa.txnWrite()) {
         db.put(txn, ba(5), ba(5));
diff --git a/src/test/java/org/lmdbjava/PutFlagSetTest.java b/src/test/java/org/lmdbjava/PutFlagSetTest.java
index 3e402732..b8b44254 100644
--- a/src/test/java/org/lmdbjava/PutFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/PutFlagSetTest.java
@@ -19,113 +19,150 @@
 import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.MatcherAssert.assertThat;
 
+import java.time.Duration;
+import java.time.Instant;
 import java.util.Arrays;
 import java.util.HashSet;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
 import org.junit.Test;
 
 public class PutFlagSetTest {
 
-    @Test
-    public void testEmpty() {
-        final PutFlagSet putFlagSet = PutFlagSet.empty();
-        assertThat(
-                putFlagSet.getMask(),
-                is(0));
-        assertThat(
-                putFlagSet.size(),
-                is(0));
-        assertThat(
-                putFlagSet.isEmpty(),
-                is(true));
-        assertThat(
-                putFlagSet.isSet(PutFlags.MDB_MULTIPLE),
-                is(false));
-        final PutFlagSet putFlagSet2 = PutFlagSet.builder()
-            .build();
-        assertThat(putFlagSet, is(putFlagSet2));
-        assertThat(putFlagSet, not(PutFlagSet.of(PutFlags.MDB_APPEND)));
-        assertThat(putFlagSet, not(PutFlagSet.of(PutFlags.MDB_APPEND, PutFlags.MDB_RESERVE)));
-        assertThat(putFlagSet, not(PutFlagSet.builder()
-            .setFlag(PutFlags.MDB_CURRENT)
-            .setFlag(PutFlags.MDB_MULTIPLE)
-            .build()));
+  @Test
+  public void testEmpty() {
+    final PutFlagSet putFlagSet = PutFlagSet.empty();
+    assertThat(
+        putFlagSet.getMask(),
+        is(0));
+    assertThat(
+        putFlagSet.size(),
+        is(0));
+    assertThat(
+        putFlagSet.isEmpty(),
+        is(true));
+    assertThat(
+        putFlagSet.isSet(PutFlags.MDB_MULTIPLE),
+        is(false));
+    final PutFlagSet putFlagSet2 = PutFlagSet.builder()
+        .build();
+    assertThat(putFlagSet, is(putFlagSet2));
+    assertThat(putFlagSet, not(PutFlagSet.of(PutFlags.MDB_APPEND)));
+    assertThat(putFlagSet, not(PutFlagSet.of(PutFlags.MDB_APPEND, PutFlags.MDB_RESERVE)));
+    assertThat(putFlagSet, not(PutFlagSet.builder()
+        .setFlag(PutFlags.MDB_CURRENT)
+        .setFlag(PutFlags.MDB_MULTIPLE)
+        .build()));
+  }
+
+  @Test
+  public void testOf() {
+    final PutFlags putFlag = PutFlags.MDB_APPEND;
+    final PutFlagSet putFlagSet = PutFlagSet.of(putFlag);
+    assertThat(
+        putFlagSet.getMask(),
+        is(MaskedFlag.mask(putFlag)));
+    assertThat(
+        putFlagSet.size(),
+        is(1));
+    assertThat(
+        putFlagSet.isSet(PutFlags.MDB_MULTIPLE),
+        is(false));
+    for (PutFlags flag : putFlagSet) {
+      assertThat(
+          putFlagSet.isSet(flag),
+          is(true));
     }
 
-    @Test
-    public void testOf() {
-        final PutFlags putFlag = PutFlags.MDB_APPEND;
-        final PutFlagSet putFlagSet = PutFlagSet.of(putFlag);
-        assertThat(
-                putFlagSet.getMask(),
-                is(MaskedFlag.mask(putFlag)));
-        assertThat(
-                putFlagSet.size(),
-                is(1));
-        assertThat(
-                putFlagSet.isSet(PutFlags.MDB_MULTIPLE),
-                is(false));
-        for (PutFlags flag : putFlagSet) {
-            assertThat(
-                    putFlagSet.isSet(flag),
-                    is(true));
-        }
+    final PutFlagSet putFlagSet2 = PutFlagSet.builder()
+        .setFlag(putFlag)
+        .build();
+    assertThat(putFlagSet, is(putFlagSet2));
+  }
 
-        final PutFlagSet putFlagSet2 = PutFlagSet.builder()
-            .setFlag(putFlag)
-            .build();
-        assertThat(putFlagSet, is(putFlagSet2));
+  @Test
+  public void testOf2() {
+    final PutFlags putFlag1 = PutFlags.MDB_APPEND;
+    final PutFlags putFlag2 = PutFlags.MDB_NOOVERWRITE;
+    final PutFlagSet putFlagSet = PutFlagSet.of(putFlag1, putFlag2);
+    assertThat(
+        putFlagSet.getMask(),
+        is(MaskedFlag.mask(putFlag1, putFlag2)));
+    assertThat(
+        putFlagSet.size(),
+        is(2));
+    assertThat(
+        putFlagSet.isSet(PutFlags.MDB_MULTIPLE),
+        is(false));
+    for (PutFlags flag : putFlagSet) {
+      assertThat(
+          putFlagSet.isSet(flag),
+          is(true));
     }
+  }
 
-    @Test
-    public void testOf2() {
-        final PutFlags putFlag1 = PutFlags.MDB_APPEND;
-        final PutFlags putFlag2 = PutFlags.MDB_NOOVERWRITE;
-        final PutFlagSet putFlagSet = PutFlagSet.of(putFlag1, putFlag2);
-        assertThat(
-                putFlagSet.getMask(),
-                is(MaskedFlag.mask(putFlag1, putFlag2)));
-        assertThat(
-                putFlagSet.size(),
-                is(2));
-        assertThat(
-                putFlagSet.isSet(PutFlags.MDB_MULTIPLE),
-                is(false));
-        for (PutFlags flag : putFlagSet) {
-            assertThat(
-                    putFlagSet.isSet(flag),
-                    is(true));
-        }
+  @Test
+  public void testBuilder() {
+    final PutFlags putFlag1 = PutFlags.MDB_APPEND;
+    final PutFlags putFlag2 = PutFlags.MDB_NOOVERWRITE;
+    final PutFlagSet putFlagSet = PutFlagSet.builder()
+        .setFlag(putFlag1)
+        .setFlag(putFlag2)
+        .build();
+    assertThat(
+        putFlagSet.getMask(),
+        is(MaskedFlag.mask(putFlag1, putFlag2)));
+    assertThat(
+        putFlagSet.size(),
+        is(2));
+    assertThat(
+        putFlagSet.isSet(PutFlags.MDB_MULTIPLE),
+        is(false));
+    for (PutFlags flag : putFlagSet) {
+      assertThat(
+          putFlagSet.isSet(flag),
+          is(true));
     }
+    final PutFlagSet putFlagSet2 = PutFlagSet.builder()
+        .withFlags(putFlag1, putFlag2)
+        .build();
+    final PutFlagSet putFlagSet3 = PutFlagSet.builder()
+        .withFlags(new HashSet<>(Arrays.asList(putFlag1, putFlag2)))
+        .build();
+    assertThat(putFlagSet, is(putFlagSet2));
+    assertThat(putFlagSet, is(putFlagSet3));
+  }
 
-    @Test
-    public void testBuilder() {
-        final PutFlags putFlag1 = PutFlags.MDB_APPEND;
-        final PutFlags putFlag2 = PutFlags.MDB_NOOVERWRITE;
-        final PutFlagSet putFlagSet = PutFlagSet.builder()
-                .setFlag(putFlag1)
-                .setFlag(putFlag2)
-                .build();
-        assertThat(
-                putFlagSet.getMask(),
-                is(MaskedFlag.mask(putFlag1, putFlag2)));
-        assertThat(
-                putFlagSet.size(),
-                is(2));
-        assertThat(
-                putFlagSet.isSet(PutFlags.MDB_MULTIPLE),
-                is(false));
-        for (PutFlags flag : putFlagSet) {
-            assertThat(
-                    putFlagSet.isSet(flag),
-                    is(true));
+  @Test
+  public void testAddFlagVsCheckPresence() {
+
+    final int cnt = 10_000_000;
+    final int[] arr = new int[cnt];
+    final List<PutFlagSet> flagSets = IntStream.range(0, cnt)
+        .boxed()
+        .map(i -> PutFlagSet.of(PutFlags.MDB_APPEND, PutFlags.MDB_NOOVERWRITE, PutFlags.MDB_RESERVE))
+        .collect(Collectors.toList());
+
+    Instant time;
+    for (int i = 0; i < 5; i++) {
+      time = Instant.now();
+      for (int j = 0; j < flagSets.size(); j++) {
+        PutFlagSet flagSet = flagSets.get(j);
+        if (!flagSet.isSet(PutFlags.MDB_RESERVE)) {
+          throw new RuntimeException("Not set");
         }
-        final PutFlagSet putFlagSet2 = PutFlagSet.builder()
-                .withFlags(putFlag1, putFlag2)
-                .build();
-        final PutFlagSet putFlagSet3 = PutFlagSet.builder()
-                .withFlags(new HashSet<>(Arrays.asList(putFlag1, putFlag2)))
-                .build();
-        assertThat(putFlagSet, is(putFlagSet2));
-        assertThat(putFlagSet, is(putFlagSet3));
+        arr[j] = flagSet.getMask();
+      }
+      System.out.println("Check: " + Duration.between(time, Instant.now()));
+
+      time = Instant.now();
+      for (int j = 0; j < flagSets.size(); j++) {
+        PutFlagSet flagSet = flagSets.get(j);
+        final int mask = flagSet.getMaskWith(PutFlags.MDB_RESERVE);
+        arr[j] = mask;
+      }
+      System.out.println("Append:" + Duration.between(time, Instant.now()));
     }
+  }
 }
diff --git a/src/test/java/org/lmdbjava/TestUtils.java b/src/test/java/org/lmdbjava/TestUtils.java
index 511619fe..94ceb3a7 100644
--- a/src/test/java/org/lmdbjava/TestUtils.java
+++ b/src/test/java/org/lmdbjava/TestUtils.java
@@ -93,6 +93,14 @@ static long getNativeLong(final ByteBuffer bb) {
     return val;
   }
 
+  static long getNativeIntOrLong(final ByteBuffer bb) {
+    if (bb.remaining() == BYTES) {
+      return getNativeInt(bb);
+    } else {
+      return getNativeLong(bb);
+    }
+  }
+
   static String getString(final ByteBuffer bb) {
     final String str = StandardCharsets.UTF_8.decode(bb)
         .toString();

From fadcb33abad5d495e20495f76e1f4e4d7e4442f9 Mon Sep 17 00:00:00 2001
From: stroomdev66 <stroomdev66@gmail.com>
Date: Tue, 4 Nov 2025 21:19:15 +0000
Subject: [PATCH 247/322] #273 Improve ByteBufferProxy comparison performance

---
 src/main/java/org/lmdbjava/ByteBufferProxy.java | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
index 9f30f576..3c80b995 100644
--- a/src/main/java/org/lmdbjava/ByteBufferProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -119,9 +119,6 @@ abstract static class AbstractByteBufferProxy extends BufferProxy<ByteBuffer> {
     public static int compareBuff(final ByteBuffer o1, final ByteBuffer o2) {
       requireNonNull(o1);
       requireNonNull(o2);
-      if (o1.equals(o2)) {
-        return 0;
-      }
       final int minLength = Math.min(o1.limit(), o2.limit());
       final int minWords = minLength / Long.BYTES;
 

From 89634ca9fe058f7c7fdab45f3133a070c43015f4 Mon Sep 17 00:00:00 2001
From: stroomdev66 <stroomdev66@gmail.com>
Date: Wed, 5 Nov 2025 10:18:11 +0000
Subject: [PATCH 248/322] #273 Improve DirectBufferProxy comparison performance

---
 src/main/java/org/lmdbjava/DirectBufferProxy.java | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/main/java/org/lmdbjava/DirectBufferProxy.java b/src/main/java/org/lmdbjava/DirectBufferProxy.java
index 17b59b3d..524b81b8 100644
--- a/src/main/java/org/lmdbjava/DirectBufferProxy.java
+++ b/src/main/java/org/lmdbjava/DirectBufferProxy.java
@@ -70,9 +70,7 @@ private DirectBufferProxy() {}
   public static int compareBuff(final DirectBuffer o1, final DirectBuffer o2) {
     requireNonNull(o1);
     requireNonNull(o2);
-    if (o1.equals(o2)) {
-      return 0;
-    }
+
     final int minLength = Math.min(o1.capacity(), o2.capacity());
     final int minWords = minLength / Long.BYTES;
 

From e2be6bf145a100fb2b8d40446dd3b70a54f51e2d Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Wed, 5 Nov 2025 13:06:57 +0000
Subject: [PATCH 249/322] Add integer key comparator tests

---
 .../java/org/lmdbjava/AbstractFlagSet.java    |   2 -
 src/main/java/org/lmdbjava/ByteBufProxy.java  |  74 +++-
 .../java/org/lmdbjava/ByteBufferProxy.java    |   5 +-
 src/main/java/org/lmdbjava/DbiBuilder.java    |  38 +-
 .../java/org/lmdbjava/DirectBufferProxy.java  |  18 +-
 src/main/java/org/lmdbjava/Env.java           | 185 +++++++--
 .../org/lmdbjava/ByteBufferProxyTest.java     |  17 +-
 .../lmdbjava/ComparatorIntegerKeyTest.java    | 369 ++++++++++++++++++
 .../java/org/lmdbjava/ComparatorTest.java     |  10 +
 .../CursorIterableIntegerDupTest.java         |  30 +-
 .../CursorIterableIntegerKeyTest.java         |  32 +-
 .../org/lmdbjava/CursorIterablePerfTest.java  |  12 +-
 .../java/org/lmdbjava/CursorIterableTest.java |  56 +--
 .../java/org/lmdbjava/DbiBuilderTest.java     | 125 +++++-
 src/test/java/org/lmdbjava/DbiTest.java       |   2 +-
 src/test/java/org/lmdbjava/TestUtils.java     |  35 ++
 .../java/org/lmdbjava/TxnFlagSetTest.java     | 111 +++---
 17 files changed, 906 insertions(+), 215 deletions(-)
 create mode 100644 src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java

diff --git a/src/main/java/org/lmdbjava/AbstractFlagSet.java b/src/main/java/org/lmdbjava/AbstractFlagSet.java
index 6e9729fb..058969de 100644
--- a/src/main/java/org/lmdbjava/AbstractFlagSet.java
+++ b/src/main/java/org/lmdbjava/AbstractFlagSet.java
@@ -26,8 +26,6 @@
 
 /**
  * Encapsulates an immutable set of flags and the associated bit mask for the flags in the set.
- *
- * @param <T>
  */
 public abstract class AbstractFlagSet<T extends Enum<T> & MaskedFlag> implements FlagSet<T> {
 
diff --git a/src/main/java/org/lmdbjava/ByteBufProxy.java b/src/main/java/org/lmdbjava/ByteBufProxy.java
index 319256fb..19d94392 100644
--- a/src/main/java/org/lmdbjava/ByteBufProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufProxy.java
@@ -23,6 +23,7 @@
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.PooledByteBufAllocator;
 import java.lang.reflect.Field;
+import java.nio.ByteOrder;
 import java.util.Comparator;
 import jnr.ffi.Pointer;
 
@@ -44,13 +45,6 @@ public final class ByteBufProxy extends BufferProxy<ByteBuf> {
   private static final String FIELD_NAME_ADDRESS = "memoryAddress";
   private static final String FIELD_NAME_LENGTH = "length";
   private static final String NAME = "io.netty.buffer.PooledUnsafeDirectByteBuf";
-  private static final Comparator<ByteBuf> comparator =
-      (o1, o2) -> {
-        requireNonNull(o1);
-        requireNonNull(o2);
-
-        return o1.compareTo(o2);
-      };
   private final long lengthOffset;
   private final long addressOffset;
 
@@ -81,6 +75,66 @@ public ByteBufProxy(final PooledByteBufAllocator allocator) {
     }
   }
 
+  /**
+   * Lexicographically compare two buffers.
+   *
+   * @param o1 left operand (required)
+   * @param o2 right operand (required)
+   * @return as specified by {@link Comparable} interface
+   */
+  public static int compareLexicographically(final ByteBuf o1, final ByteBuf o2) {
+    requireNonNull(o1);
+    requireNonNull(o2);
+    return o1.compareTo(o2);
+  }
+
+  /**
+   * Buffer comparator specifically for 4/8 byte keys that are unsigned ints/longs,
+   * i.e. when using MDB_INTEGER_KEY/MDB_INTEGERDUP. Compares the buffers numerically.
+   *
+   * @param o1 left operand (required)
+   * @param o2 right operand (required)
+   * @return as specified by {@link Comparable} interface
+   */
+  public static int compareAsIntegerKeys(final ByteBuf o1, final ByteBuf o2) {
+    requireNonNull(o1);
+    requireNonNull(o2);
+    // Both buffers should be same length according to LMDB API.
+    // From the LMDB docs for MDB_INTEGER_KEY
+    // numeric keys in native byte order: either unsigned int or size_t. The keys must all be of the same size.
+    final int len1 = o1.readableBytes();
+    final int len2 = o2.readableBytes();
+    if (len1 != len2) {
+      throw new RuntimeException("Length mismatch, len1: " + len1 + ", len2: " + len2
+          + ". Lengths must be identical and either 4 or 8 bytes.");
+    }
+    if (len1 == 8) {
+      final long lw;
+      final long rw;
+      if (ByteOrder.nativeOrder() == ByteOrder.LITTLE_ENDIAN) {
+        lw = o1.readLongLE();
+        rw = o2.readLongLE();
+      } else {
+        lw = o1.readLong();
+        rw = o2.readLong();
+      }
+      return Long.compareUnsigned(lw, rw);
+    } else if (len1 == 4) {
+      final int lw;
+      final int rw;
+      if (ByteOrder.nativeOrder() == ByteOrder.LITTLE_ENDIAN) {
+        lw = o1.readIntLE();
+        rw = o2.readIntLE();
+      } else {
+        lw = o1.readInt();
+        rw = o2.readInt();
+      }
+      return Integer.compareUnsigned(lw, rw);
+    } else {
+      return compareLexicographically(o1, o2);
+    }
+  }
+
   static Field findField(final String c, final String name) {
     Class<?> clazz;
     try {
@@ -115,7 +169,11 @@ protected ByteBuf allocate() {
 
   @Override
   public Comparator<ByteBuf> getComparator(final DbiFlagSet dbiFlagSet) {
-    return comparator;
+    if (dbiFlagSet.areAnySet(DbiFlagSet.INTEGER_KEY_FLAGS)) {
+      return ByteBufProxy::compareAsIntegerKeys;
+    } else {
+      return ByteBufProxy::compareLexicographically;
+    }
   }
 
   @Override
diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
index 27ae375e..c682bec8 100644
--- a/src/main/java/org/lmdbjava/ByteBufferProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -60,6 +60,7 @@ public final class ByteBufferProxy {
    */
   public static final BufferProxy<ByteBuffer> PROXY_SAFE;
 
+  private static final ByteOrder NATIVE_ORDER = ByteOrder.nativeOrder();
 
   static {
     PROXY_SAFE = new ReflectiveProxy();
@@ -172,8 +173,8 @@ public static int compareAsIntegerKeys(final ByteBuffer o1, final ByteBuffer o2)
             + ". Lengths must be identical and either 4 or 8 bytes.");
       }
       // Keys for MDB_INTEGER_KEY are written in native order so ensure we read them in that order
-      o1.order(ByteOrder.nativeOrder());
-      o2.order(ByteOrder.nativeOrder());
+      o1.order(NATIVE_ORDER);
+      o2.order(NATIVE_ORDER);
       // TODO it might be worth the DbiBuilder having a method to capture fixedKeyLength() or -1
       //  for variable length keys. This can be passed to getComparator(..) so it can return a
       //  comparator that doesn't need to test the length every time. There may be other benefits
diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
index 1bf2489d..f94118a7 100644
--- a/src/main/java/org/lmdbjava/DbiBuilder.java
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -53,12 +53,12 @@ public class DbiBuilder<T> {
    *            (see also {@link DbiBuilder#withoutDbName()})
    * @return The next builder stage.
    */
-  public DbiBuilderStage2<T> withDbName(final String name) {
+  public DbiBuilderStage2<T> setDbName(final String name) {
     // Null name is allowed so no null check
     final byte[] nameBytes = name == null
         ? null
         : name.getBytes(Env.DEFAULT_NAME_CHARSET);
-    return withDbName(nameBytes);
+    return setDbName(nameBytes);
   }
 
   /**
@@ -66,7 +66,7 @@ public DbiBuilderStage2<T> withDbName(final String name) {
    * @param name The name of the database in byte form.
    * @return The next builder stage.
    */
-  public DbiBuilderStage2<T> withDbName(final byte[] name) {
+  public DbiBuilderStage2<T> setDbName(final byte[] name) {
     // Null name is allowed so no null check
     this.name = name;
     return new DbiBuilderStage2<>(this);
@@ -78,7 +78,7 @@ public DbiBuilderStage2<T> withDbName(final byte[] name) {
    * </p>
    * <p>
    * Equivalent to passing null to
-   * {@link DbiBuilder#withDbName(String)} or {@link DbiBuilder#withDbName(byte[])}.
+   * {@link DbiBuilder#setDbName(String)} or {@link DbiBuilder#setDbName(byte[])}.
    * </p>
    * <p>Note: The 'unnamed database' is used by LMDB to store the names of named databases, with
    * the database name being the key. Use of the unnamed database is intended for simple applications
@@ -86,7 +86,7 @@ public DbiBuilderStage2<T> withDbName(final byte[] name) {
    * @return The next builder stage.
    */
   public DbiBuilderStage2<T> withoutDbName() {
-    return withDbName((byte[]) null);
+    return setDbName((byte[]) null);
   }
 
 
@@ -254,8 +254,8 @@ private DbiBuilderStage3(DbiBuilderStage2<T> dbiBuilderStage2) {
      * </p>
      * <p>
      * Clears all flags currently set by previous calls to
-     * {@link DbiBuilderStage3#withDbiFlags(Collection)},
-     * {@link DbiBuilderStage3#withDbiFlags(DbiFlags...)}
+     * {@link DbiBuilderStage3#setDbiFlags(Collection)},
+     * {@link DbiBuilderStage3#setDbiFlags(DbiFlags...)}
      * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
      * </p>
      *
@@ -263,7 +263,7 @@ private DbiBuilderStage3(DbiBuilderStage2<T> dbiBuilderStage2) {
      *                 A null {@link Collection} will just clear all set flags.
      *                 Null items are ignored.
      */
-    public DbiBuilderStage3<T> withDbiFlags(final Collection<DbiFlags> dbiFlags) {
+    public DbiBuilderStage3<T> setDbiFlags(final Collection<DbiFlags> dbiFlags) {
       flagSetBuilder.clear();
       if (dbiFlags != null) {
         dbiFlags.stream()
@@ -279,8 +279,8 @@ public DbiBuilderStage3<T> withDbiFlags(final Collection<DbiFlags> dbiFlags) {
      * </p>
      * <p>
      * Clears all flags currently set by previous calls to
-     * {@link DbiBuilderStage3#withDbiFlags(Collection)},
-     * {@link DbiBuilderStage3#withDbiFlags(DbiFlags...)}
+     * {@link DbiBuilderStage3#setDbiFlags(Collection)},
+     * {@link DbiBuilderStage3#setDbiFlags(DbiFlags...)}
      * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
      * </p>
      *
@@ -288,7 +288,7 @@ public DbiBuilderStage3<T> withDbiFlags(final Collection<DbiFlags> dbiFlags) {
      *                 A null array will just clear all set flags.
      *                 Null items are ignored.
      */
-    public DbiBuilderStage3<T> withDbiFlags(final DbiFlags... dbiFlags) {
+    public DbiBuilderStage3<T> setDbiFlags(final DbiFlags... dbiFlags) {
       flagSetBuilder.clear();
       if (dbiFlags != null) {
         Arrays.stream(dbiFlags)
@@ -304,15 +304,15 @@ public DbiBuilderStage3<T> withDbiFlags(final DbiFlags... dbiFlags) {
      * </p>
      * <p>
      * Clears all flags currently set by previous calls to
-     * {@link DbiBuilderStage3#withDbiFlags(Collection)},
-     * {@link DbiBuilderStage3#withDbiFlags(DbiFlags...)}
+     * {@link DbiBuilderStage3#setDbiFlags(Collection)},
+     * {@link DbiBuilderStage3#setDbiFlags(DbiFlags...)}
      * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
      * </p>
      *
      * @param dbiFlagSet to open the database with.
      *                 A null value will just clear all set flags.
      */
-    public DbiBuilderStage3<T> withDbiFlags(final DbiFlagSet dbiFlagSet) {
+    public DbiBuilderStage3<T> setDbiFlags(final DbiFlagSet dbiFlagSet) {
       flagSetBuilder.clear();
       if (dbiFlagSet != null) {
         this.flagSetBuilder.withFlags(dbiFlagSet.getFlags());
@@ -322,8 +322,8 @@ public DbiBuilderStage3<T> withDbiFlags(final DbiFlagSet dbiFlagSet) {
 
     /**
      * Adds a dbiFlag to those flags already added to this builder by
-     * {@link DbiBuilderStage3#withDbiFlags(DbiFlags...)},
-     * {@link DbiBuilderStage3#withDbiFlags(Collection)}
+     * {@link DbiBuilderStage3#setDbiFlags(DbiFlags...)},
+     * {@link DbiBuilderStage3#setDbiFlags(Collection)}
      * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
      *
      * @param dbiFlag to add to any existing flags. A null value is a no-op.
@@ -336,8 +336,8 @@ public DbiBuilderStage3<T> addDbiFlag(final DbiFlags dbiFlag) {
 
     /**
      * Adds a dbiFlag to those flags already added to this builder by
-     * {@link DbiBuilderStage3#withDbiFlags(DbiFlags...)},
-     * {@link DbiBuilderStage3#withDbiFlags(Collection)}
+     * {@link DbiBuilderStage3#setDbiFlags(DbiFlags...)},
+     * {@link DbiBuilderStage3#setDbiFlags(Collection)}
      * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
      *
      * @param dbiFlagSet to add to any existing flags. A null value is a no-op.
@@ -367,7 +367,7 @@ public DbiBuilderStage3<T> addDbiFlags(final DbiFlagSet dbiFlagSet) {
      *            else it needs to be a read/write {@link Txn}.
      * @return this builder instance.
      */
-    public DbiBuilderStage3<T> withTxn(final Txn<T> txn) {
+    public DbiBuilderStage3<T> setTxn(final Txn<T> txn) {
       this.txn = Objects.requireNonNull(txn);
       return this;
     }
diff --git a/src/main/java/org/lmdbjava/DirectBufferProxy.java b/src/main/java/org/lmdbjava/DirectBufferProxy.java
index 180eee0a..46bdfd22 100644
--- a/src/main/java/org/lmdbjava/DirectBufferProxy.java
+++ b/src/main/java/org/lmdbjava/DirectBufferProxy.java
@@ -22,6 +22,7 @@
 import static org.lmdbjava.UnsafeAccess.UNSAFE;
 
 import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
 import java.util.ArrayDeque;
 import java.util.Comparator;
 import jnr.ffi.Pointer;
@@ -50,6 +51,8 @@ public final class DirectBufferProxy extends BufferProxy<DirectBuffer> {
   private static final ThreadLocal<ArrayDeque<DirectBuffer>> BUFFERS =
       withInitial(() -> new ArrayDeque<>(16));
 
+  private static final ByteOrder NATIVE_ORDER = ByteOrder.nativeOrder();
+
   private DirectBufferProxy() {}
 
   /**
@@ -110,16 +113,19 @@ public static int compareAsIntegerKeys(final DirectBuffer o1, final DirectBuffer
           + ". Lengths must be identical and either 4 or 8 bytes.");
     }
     if (len1 == 8) {
-      final long lw = o1.getLong(0, BIG_ENDIAN);
-      final long rw = o2.getLong(0, BIG_ENDIAN);
+      final long lw = o1.getLong(0, NATIVE_ORDER);
+      final long rw = o2.getLong(0, NATIVE_ORDER);
       return Long.compareUnsigned(lw, rw);
     } else if (len1 == 4) {
-      final int lw = o1.getInt(0, BIG_ENDIAN);
-      final int rw = o2.getInt(0, BIG_ENDIAN);
+      final int lw = o1.getInt(0, NATIVE_ORDER);
+      final int rw = o2.getInt(0, NATIVE_ORDER);
       return Integer.compareUnsigned(lw, rw);
     } else {
-      throw new RuntimeException("Unexpected length len1: " + len1 + ", len2: " + len2
-          + ". Lengths must be identical and either 4 or 8 bytes.");
+      // size_t and int are likely to be 8bytes and 4bytes respectively on 64bit.
+      // If 32bit then would be 4/2 respectively.
+      // Short.compareUnsigned is not available in Java8.
+      // For now just fall back to our standard comparator
+      return compareLexicographically(o1, o2);
     }
   }
 
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 8ea08ccb..b8003cbb 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -23,18 +23,20 @@
 import static org.lmdbjava.EnvFlags.MDB_RDONLY_ENV;
 import static org.lmdbjava.Library.LIB;
 import static org.lmdbjava.Library.RUNTIME;
-import static org.lmdbjava.MaskedFlag.isSet;
-import static org.lmdbjava.MaskedFlag.mask;
 import static org.lmdbjava.ResultCodeMapper.checkRc;
 
 import java.io.File;
 import java.nio.ByteBuffer;
 import java.nio.charset.Charset;
 import java.nio.charset.StandardCharsets;
+import java.nio.file.Path;
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.List;
+import java.util.Objects;
 import jnr.ffi.Pointer;
 import jnr.ffi.byref.IntByReference;
 import jnr.ffi.byref.PointerByReference;
@@ -102,6 +104,8 @@ public static <T> Builder<T> create(final BufferProxy<T> proxy) {
   }
 
   /**
+   * @deprecated Instead use {@link Env#create()} or {@link Env#create(BufferProxy)}
+   * <p>
    * Opens an environment with a single default database in 0664 mode using the {@link
    * ByteBufferProxy#PROXY_OPTIMAL}.
    *
@@ -110,6 +114,7 @@ public static <T> Builder<T> create(final BufferProxy<T> proxy) {
    * @param flags the flags for this new environment
    * @return env the environment (never null)
    */
+  @Deprecated
   public static Env<ByteBuffer> open(final File path, final int size, final EnvFlags... flags) {
     return new Builder<>(PROXY_OPTIMAL)
         .setMapSize(size * 1_024L * 1_024L)
@@ -496,18 +501,6 @@ public Txn<T> txn(final Txn<T> parent) {
     return new Txn<>(this, parent, proxy, TxnFlagSet.EMPTY);
   }
 
-  /**
-   * Obtain a transaction with the requested parent and flags.
-   *
-   * @param parent parent transaction (may be null if no parent)
-   * @param flag   applicable flag (eg for a reusable, read-only transaction)
-   * @return a transaction (never null)
-   */
-  public Txn<T> txn(final Txn<T> parent, final TxnFlags flag) {
-    checkNotClosed();
-    return new Txn<>(this, parent, proxy, flag);
-  }
-
   /**
    * Obtain a transaction with the requested parent and flags.
    *
@@ -616,6 +609,10 @@ public AlreadyOpenException() {
     }
   }
 
+
+  // --------------------------------------------------------------------------------
+
+
   /**
    * Builder for configuring and opening Env.
    *
@@ -629,6 +626,8 @@ public static final class Builder<T> {
     private int maxReaders = MAX_READERS_DEFAULT;
     private boolean opened;
     private final BufferProxy<T> proxy;
+    private int mode = 0664;
+    private AbstractFlagSet.Builder<EnvFlags, EnvFlagSet> flagSetBuilder = EnvFlagSet.builder();
 
     Builder(final BufferProxy<T> proxy) {
       requireNonNull(proxy);
@@ -642,10 +641,49 @@ public static final class Builder<T> {
      * @param mode  Unix permissions to set on created files and semaphores
      * @param flags the flags for this new environment
      * @return an environment ready for use
+     * @deprecated Instead use {@link Builder#open(Path)}, {@link Builder#setFilePermissions(int)}
+     * and {@link Builder#setEnvFlags(EnvFlags...)}.
      */
+    @Deprecated
     public Env<T> open(final File path, final int mode, final EnvFlags... flags) {
-      // TODO Use EnvFlagSet and deprecate
-      // TODO Make setUnixPermissions(int) method on builder.
+      setFilePermissions(mode);
+      setEnvFlags(flags);
+      return open(requireNonNull(path).toPath());
+    }
+
+    /**
+     * Opens the environment.
+     *
+     * @param path file system destination
+     * @return an environment ready for use
+     * @deprecated Instead use {@link Builder#open(Path)}
+     */
+    @Deprecated
+    public Env<T> open(final File path) {
+      return open(requireNonNull(path).toPath());
+    }
+
+    /**
+     * Opens the environment with 0664 mode.
+     *
+     * @param path  file system destination
+     * @param flags the flags for this new environment
+     * @return an environment ready for use
+     * @deprecated Instead use {@link Builder#open(Path)} and {@link Builder#setEnvFlags(EnvFlags...)}.
+     */
+    @Deprecated
+    public Env<T> open(final File path, final EnvFlags... flags) {
+      setEnvFlags(flags);
+      return open(requireNonNull(path).toPath());
+    }
+
+    /**
+     * Opens the environment.
+     *
+     * @param path file system destination
+     * @return an environment ready for use
+     */
+    public Env<T> open(final Path path) {
       requireNonNull(path);
       if (opened) {
         throw new AlreadyOpenException();
@@ -658,10 +696,10 @@ public Env<T> open(final File path, final int mode, final EnvFlags... flags) {
         checkRc(LIB.mdb_env_set_mapsize(ptr, mapSize));
         checkRc(LIB.mdb_env_set_maxdbs(ptr, maxDbs));
         checkRc(LIB.mdb_env_set_maxreaders(ptr, maxReaders));
-        final int flagsMask = mask(flags);
-        final boolean readOnly = isSet(flagsMask, MDB_RDONLY_ENV);
-        final boolean noSubDir = isSet(flagsMask, MDB_NOSUBDIR);
-        checkRc(LIB.mdb_env_open(ptr, path.getAbsolutePath(), flagsMask, mode));
+        final EnvFlagSet flags = flagSetBuilder.build();
+        final boolean readOnly = flags.isSet(MDB_RDONLY_ENV);
+        final boolean noSubDir = flags.isSet(MDB_NOSUBDIR);
+        checkRc(LIB.mdb_env_open(ptr, path.toAbsolutePath().toString(), flags.getMask(), mode));
         return new Env<>(proxy, ptr, readOnly, noSubDir);
       } catch (final LmdbNativeException e) {
         LIB.mdb_env_close(ptr);
@@ -670,19 +708,7 @@ public Env<T> open(final File path, final int mode, final EnvFlags... flags) {
     }
 
     /**
-     * Opens the environment with 0664 mode.
-     *
-     * @param path  file system destination
-     * @param flags the flags for this new environment
-     * @return an environment ready for use
-     */
-    public Env<T> open(final File path, final EnvFlags... flags) {
-      // TODO make constant
-      return open(path, 0664, flags);
-    }
-
-    /**
-     * Sets the map size.
+     * Sets the map size in bytes.
      *
      * @param mapSize new limit in bytes
      * @return the builder
@@ -725,6 +751,99 @@ public Builder<T> setMaxReaders(final int readers) {
       this.maxReaders = readers;
       return this;
     }
+
+    /**
+     * Sets the Unix file permissions to use on created files and semaphores, e.g. {@code 0664}.
+     * If this method is not called, the default of {@code 0664} will be used.
+     *
+     * @param mode Unix permissions to set on created files and semaphores
+     * @return the builder
+     */
+    public Builder<T> setFilePermissions(final int mode) {
+      if (opened) {
+        throw new AlreadyOpenException();
+      }
+      this.mode = mode;
+      return this;
+    }
+
+    /**
+     * Sets all the flags used to open this {@link Env}.
+     *
+     * @param envFlags The flags to use.
+     *                 Clears any existing flags.
+     *                 A null value results in no flags being set.
+     * @return this builder instance.
+     */
+    public Builder<T> setEnvFlags(final Collection<EnvFlags> envFlags) {
+      flagSetBuilder.clear();
+      if (envFlags != null) {
+        envFlags.stream()
+            .filter(Objects::nonNull)
+            .forEach(envFlags::add);
+      }
+      return this;
+    }
+
+    /**
+     * Sets all the flags used to open this {@link Env}.
+     *
+     * @param envFlags The flags to use.
+     *                 Clears any existing flags.
+     *                 A null value results in no flags being set.
+     * @return this builder instance.
+     */
+    public Builder<T> setEnvFlags(final EnvFlags... envFlags) {
+      flagSetBuilder.clear();
+      if (envFlags != null) {
+        Arrays.stream(envFlags)
+            .filter(Objects::nonNull)
+            .forEach(this.flagSetBuilder::setFlag);
+      }
+      return this;
+    }
+
+    /**
+     * Sets all the flags used to open this {@link Env}.
+     *
+     * @param envFlagSet The flags to use.
+     *                   Clears any existing flags.
+     *                   A null value results in no flags being set.
+     * @return this builder instance.
+     */
+    public Builder<T> setEnvFlags(final EnvFlagSet envFlagSet) {
+      flagSetBuilder.clear();
+      if (envFlagSet != null) {
+        this.flagSetBuilder.withFlags(envFlagSet.getFlags());
+      }
+      return this;
+    }
+
+    /**
+     * Adds a single {@link EnvFlags} to any existing flags.
+     *
+     * @param dbiFlag The flag to add to any existing flags.
+     *                A null value is a no-op.
+     * @return this builder instance.
+     */
+    public Builder<T> addEnvFlag(final EnvFlags dbiFlag) {
+      this.flagSetBuilder.setFlag(dbiFlag);
+      return this;
+    }
+
+    /**
+     * Adds a set of {@link EnvFlags} to any existing flags.
+     *
+     * @param dbiFlagSet The set of flags to add to any existing flags.
+     *                   A null value is a no-op.
+     * @return this builder instance.
+     */
+    public Builder<T> addEnvFlags(final EnvFlagSet dbiFlagSet) {
+      if (dbiFlagSet != null) {
+        flagSetBuilder.setFlags(dbiFlagSet.getFlags());
+      }
+      return this;
+    }
   }
 
   /**
diff --git a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
index 0c83f31e..dc034f7f 100644
--- a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
+++ b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
@@ -39,7 +39,6 @@
 import java.nio.ByteOrder;
 import java.time.Duration;
 import java.time.Instant;
-import java.util.Arrays;
 import java.util.Comparator;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
@@ -65,8 +64,14 @@ void buffersMustBeDirect() {
         () -> {
           FileUtil.useTempDir(
               dir -> {
-                try (Env<ByteBuffer> env = create().setMaxReaders(1).open(dir.toFile())) {
-                  final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+                try (Env<ByteBuffer> env = create()
+                    .setMaxReaders(1)
+                    .open(dir)) {
+                  final Dbi<ByteBuffer> db = env.buildDbi()
+                      .setDbName(DB_1)
+                      .withDefaultComparator()
+                      .setDbiFlags(MDB_CREATE)
+                      .open();
                   final ByteBuffer key = allocate(100);
                   key.putInt(1).flip();
                   final ByteBuffer val = allocate(100);
@@ -201,9 +206,9 @@ public void verifyComparators() {
         .filter(i -> i >= 0)
         .limit(5_000_000)
         .toArray();
-    System.out.println("stats: " + Arrays.stream(values)
-        .summaryStatistics()
-        .toString());
+//    System.out.println("stats: " + Arrays.stream(values)
+//        .summaryStatistics()
+//        .toString());
 
     final LinkedHashMap<String, Comparator<ByteBuffer>> comparators = new LinkedHashMap<>();
     comparators.put("compareAsIntegerKeys", ByteBufferProxy.AbstractByteBufferProxy::compareAsIntegerKeys);
diff --git a/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java b/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java
new file mode 100644
index 00000000..5b9e0761
--- /dev/null
+++ b/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java
@@ -0,0 +1,369 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.lmdbjava;
+
+import static io.netty.buffer.PooledByteBufAllocator.DEFAULT;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.lmdbjava.ByteBufProxy.PROXY_NETTY;
+import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
+import static org.lmdbjava.ComparatorTest.ComparatorResult.EQUAL_TO;
+import static org.lmdbjava.ComparatorTest.ComparatorResult.GREATER_THAN;
+import static org.lmdbjava.ComparatorTest.ComparatorResult.LESS_THAN;
+import static org.lmdbjava.ComparatorTest.ComparatorResult.get;
+import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
+
+import io.netty.buffer.ByteBuf;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.Comparator;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Random;
+import java.util.stream.Stream;
+import org.agrona.DirectBuffer;
+import org.agrona.concurrent.UnsafeBuffer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+/**
+ * Tests comparator functions are consistent across buffers.
+ */
+public final class ComparatorIntegerKeyTest {
+
+  static Stream<Arguments> comparatorProvider() {
+    return Stream.of(
+        Arguments.argumentSet("LongRunner", new DirectBufferRunner()),
+        Arguments.argumentSet("DirectBufferRunner", new DirectBufferRunner()),
+        Arguments.argumentSet("ByteBufferRunner", new ByteBufferRunner()),
+        Arguments.argumentSet("NettyRunner", new NettyRunner()));
+  }
+
+  private static byte[] buffer(final int... bytes) {
+    final byte[] array = new byte[bytes.length];
+    for (int i = 0; i < bytes.length; i++) {
+      array[i] = (byte) bytes[i];
+    }
+    return array;
+  }
+
+  @ParameterizedTest
+  @MethodSource("comparatorProvider")
+  void testLong(final ComparatorRunner comparator) {
+
+    assertThat(get(comparator.compare(0L, 0L))).isEqualTo(EQUAL_TO);
+    assertThat(get(comparator.compare(Long.MAX_VALUE, Long.MAX_VALUE))).isEqualTo(EQUAL_TO);
+
+    assertThat(get(comparator.compare(0L, 1L))).isEqualTo(LESS_THAN);
+    assertThat(get(comparator.compare(0L, Long.MAX_VALUE))).isEqualTo(LESS_THAN);
+    assertThat(get(comparator.compare(0L, 10L))).isEqualTo(LESS_THAN);
+    assertThat(get(comparator.compare(10L, 100L))).isEqualTo(LESS_THAN);
+    assertThat(get(comparator.compare(10L, 100L))).isEqualTo(LESS_THAN);
+    assertThat(get(comparator.compare(10L, 1000L))).isEqualTo(LESS_THAN);
+
+    assertThat(get(comparator.compare(1L, 0L))).isEqualTo(GREATER_THAN);
+    assertThat(get(comparator.compare(Long.MAX_VALUE, 0L))).isEqualTo(GREATER_THAN);
+  }
+
+  @ParameterizedTest
+  @MethodSource("comparatorProvider")
+  void testInt(final ComparatorRunner comparator) {
+
+    assertThat(get(comparator.compare(0, 0))).isEqualTo(EQUAL_TO);
+    assertThat(get(comparator.compare(Integer.MAX_VALUE, Integer.MAX_VALUE))).isEqualTo(EQUAL_TO);
+
+    assertThat(get(comparator.compare(0, 1))).isEqualTo(LESS_THAN);
+    assertThat(get(comparator.compare(0, Integer.MAX_VALUE))).isEqualTo(LESS_THAN);
+    assertThat(get(comparator.compare(0, 10))).isEqualTo(LESS_THAN);
+    assertThat(get(comparator.compare(10, 100))).isEqualTo(LESS_THAN);
+    assertThat(get(comparator.compare(10, 100))).isEqualTo(LESS_THAN);
+    assertThat(get(comparator.compare(10, 1000))).isEqualTo(LESS_THAN);
+
+    assertThat(get(comparator.compare(1, 0))).isEqualTo(GREATER_THAN);
+    assertThat(get(comparator.compare(Integer.MAX_VALUE, 0))).isEqualTo(GREATER_THAN);
+  }
+
+  @Test
+  void testRandomLong() {
+    final Random random = new Random(3239480);
+    final Map<String, ComparatorRunner> nameToRunnerMap = new LinkedHashMap<>();
+    nameToRunnerMap.put("DirectBufferRunner", new DirectBufferRunner());
+    nameToRunnerMap.put("ByteBufferRunner", new ByteBufferRunner());
+    nameToRunnerMap.put("NettyRunner", new NettyRunner());
+
+    // 5mil random longs to compare
+    final long[] values = random.longs()
+        .filter(i -> i >= 0)
+        .limit(5_000_000)
+        .toArray();
+
+    for (int i = 1; i < values.length; i++) {
+      final long long1 = values[i - 1];
+      final long long2 = values[i];
+      for (Map.Entry<String, ComparatorRunner> entry : nameToRunnerMap.entrySet()) {
+        final String name = entry.getKey();
+        final ComparatorRunner runner = entry.getValue();
+        // Make sure the comparator under test gives the same outcome as just comparing two longs
+        final ComparatorTest.ComparatorResult result = get(runner.compare(long1, long2));
+        final ComparatorTest.ComparatorResult expectedResult = get(Long.compare(long1, long2));
+
+        assertThat(result)
+            .withFailMessage(() -> "Compare mismatch for " + name + " - long1: " + long1
+                + ", long2: " + long2
+                + ", expected: " + expectedResult
+                + ", actual: " + result)
+            .isEqualTo(expectedResult);
+
+        final ComparatorTest.ComparatorResult result2 = get(runner.compare(long2, long1));
+        final ComparatorTest.ComparatorResult expectedResult2 = expectedResult.opposite();
+
+        assertThat(result)
+            .withFailMessage(() -> "Compare mismatch for " + name + " - long2: " + long2
+                + ", long1: " + long1
+                + ", expected2: " + expectedResult2
+                + ", actual2: " + result2)
+            .isEqualTo(expectedResult);
+      }
+    }
+  }
+
+  @Test
+  void testRandomInt() {
+    final Random random = new Random(3239480);
+    final Map<String, ComparatorRunner> nameToRunnerMap = new LinkedHashMap<>();
+    nameToRunnerMap.put("DirectBufferRunner", new DirectBufferRunner());
+    nameToRunnerMap.put("ByteBufferRunner", new ByteBufferRunner());
+    nameToRunnerMap.put("NettyRunner", new NettyRunner());
+
+    // 5mil random ints to compare
+    final int[] values = random.ints()
+        .filter(i -> i >= 0)
+        .limit(5_000_000)
+        .toArray();
+
+    for (int i = 1; i < values.length; i++) {
+      final int int1 = values[i - 1];
+      final int int2 = values[i];
+      for (Map.Entry<String, ComparatorRunner> entry : nameToRunnerMap.entrySet()) {
+        final String name = entry.getKey();
+        final ComparatorRunner runner = entry.getValue();
+        // Make sure the comparator under test gives the same outcome as just comparing two ints
+        final ComparatorTest.ComparatorResult result = get(runner.compare(int1, int2));
+        final ComparatorTest.ComparatorResult expectedResult = get(Integer.compare(int1, int2));
+
+        assertThat(result)
+            .withFailMessage(() -> "Compare mismatch for " + name + " - int1: " + int1
+                + ", int2: " + int2
+                + ", expected: " + expectedResult
+                + ", actual: " + result)
+            .isEqualTo(expectedResult);
+
+        final ComparatorTest.ComparatorResult result2 = get(runner.compare(int2, int1));
+        final ComparatorTest.ComparatorResult expectedResult2 = expectedResult.opposite();
+
+        assertThat(result)
+            .withFailMessage(() -> "Compare mismatch for " + name + " - int2: " + int2
+                + ", int1: " + int1
+                + ", expected2: " + expectedResult2
+                + ", actual2: " + result2)
+            .isEqualTo(expectedResult);
+      }
+    }
+  }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  /**
+   * Tests {@link ByteBufferProxy}.
+   */
+  private static final class ByteBufferRunner implements ComparatorRunner {
+
+    private static final Comparator<ByteBuffer> COMPARATOR = PROXY_OPTIMAL.getComparator(DbiFlags.MDB_INTEGERKEY);
+
+    @Override
+    public int compare(long long1, long long2) {
+      // Convert arrays to buffers that are larger than the array, with
+      // limit set at the array length. One buffer bigger than the other.
+      ByteBuffer o1b = longToBuffer(long1, Long.BYTES * 3);
+      ByteBuffer o2b = longToBuffer(long2, Long.BYTES * 2);
+      final int result = COMPARATOR.compare(o1b, o2b);
+
+      // Now swap which buffer is bigger
+      o1b = longToBuffer(long1, Long.BYTES * 2);
+      o2b = longToBuffer(long2, Long.BYTES * 3);
+      final int result2 = COMPARATOR.compare(o1b, o2b);
+
+      assertThat(result2).isEqualTo(result);
+
+      // Now try with buffers sized to the array.
+      o1b = longToBuffer(long1, Long.BYTES);
+      o2b = longToBuffer(long2, Long.BYTES);
+      final int result3 = COMPARATOR.compare(o1b, o2b);
+
+      assertThat(result3).isEqualTo(result);
+      return result;
+    }
+
+    @Override
+    public int compare(int int1, int int2) {
+      // Convert arrays to buffers that are larger than the array, with
+      // limit set at the array length. One buffer bigger than the other.
+      ByteBuffer o1b = intToBuffer(int1, Integer.BYTES * 3);
+      ByteBuffer o2b = intToBuffer(int2, Integer.BYTES * 2);
+      final int result = COMPARATOR.compare(o1b, o2b);
+
+      // Now swap which buffer is bigger
+      o1b = intToBuffer(int1, Integer.BYTES * 2);
+      o2b = intToBuffer(int2, Integer.BYTES * 3);
+      final int result2 = COMPARATOR.compare(o1b, o2b);
+
+      assertThat(result2).isEqualTo(result);
+
+      // Now try with buffers sized to the array.
+      o1b = intToBuffer(int1, Integer.BYTES);
+      o2b = intToBuffer(int2, Integer.BYTES);
+      final int result3 = COMPARATOR.compare(o1b, o2b);
+
+      assertThat(result3).isEqualTo(result);
+      return result;
+    }
+
+    private ByteBuffer longToBuffer(final long val, final int bufferCapacity) {
+      final ByteBuffer byteBuffer = ByteBuffer.allocate(bufferCapacity);
+      byteBuffer.order(ByteOrder.nativeOrder());
+      byteBuffer.putLong(0, val);
+      byteBuffer.limit(Long.BYTES);
+      byteBuffer.position(0);
+      return byteBuffer;
+    }
+
+    private ByteBuffer intToBuffer(final int val, final int bufferCapacity) {
+      final ByteBuffer byteBuffer = ByteBuffer.allocate(bufferCapacity);
+      byteBuffer.order(ByteOrder.nativeOrder());
+      byteBuffer.putInt(0, val);
+      byteBuffer.limit(Integer.BYTES);
+      byteBuffer.position(0);
+      return byteBuffer;
+    }
+  }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  /**
+   * Tests {@link DirectBufferProxy}.
+   */
+  private static final class DirectBufferRunner implements ComparatorRunner {
+    private static final Comparator<DirectBuffer> COMPARATOR = PROXY_DB.getComparator(DbiFlags.MDB_INTEGERKEY);
+
+    @Override
+    public int compare(long long1, long long2) {
+      final UnsafeBuffer o1b = new UnsafeBuffer(new byte[Long.BYTES]);
+      final UnsafeBuffer o2b = new UnsafeBuffer(new byte[Long.BYTES]);
+      o1b.putLong(0, long1, ByteOrder.nativeOrder());
+      o2b.putLong(0, long2, ByteOrder.nativeOrder());
+      return COMPARATOR.compare(o1b, o2b);
+    }
+
+    @Override
+    public int compare(int int1, int int2) {
+      final UnsafeBuffer o1b = new UnsafeBuffer(new byte[Integer.BYTES]);
+      final UnsafeBuffer o2b = new UnsafeBuffer(new byte[Integer.BYTES]);
+      o1b.putInt(0, int1, ByteOrder.nativeOrder());
+      o2b.putInt(0, int2, ByteOrder.nativeOrder());
+      return COMPARATOR.compare(o1b, o2b);
+    }
+  }
+
+  /**
+   * Tests {@link ByteBufProxy}.
+   */
+  private static final class NettyRunner implements ComparatorRunner {
+
+    private static final Comparator<ByteBuf> COMPARATOR = PROXY_NETTY.getComparator(DbiFlags.MDB_INTEGERKEY);
+
+    @Override
+    public int compare(long long1, long long2) {
+      final ByteBuf o1b = DEFAULT.directBuffer(Long.BYTES);
+      final ByteBuf o2b = DEFAULT.directBuffer(Long.BYTES);
+      if (ByteOrder.nativeOrder() == ByteOrder.LITTLE_ENDIAN) {
+        o1b.writeLongLE(long1);
+        o2b.writeLongLE(long2);
+      } else {
+        o1b.writeLong(long1);
+        o2b.writeLong(long2);
+      }
+      o1b.resetReaderIndex();
+      o2b.resetReaderIndex();
+      final int res = COMPARATOR.compare(o1b, o2b);
+      o1b.release();
+      o2b.release();
+      return res;
+    }
+
+    @Override
+    public int compare(int int1, int int2) {
+      final ByteBuf o1b = DEFAULT.directBuffer(Integer.BYTES);
+      final ByteBuf o2b = DEFAULT.directBuffer(Integer.BYTES);
+      if (ByteOrder.nativeOrder() == ByteOrder.LITTLE_ENDIAN) {
+        o1b.writeIntLE(int1);
+        o2b.writeIntLE(int2);
+      } else {
+        o1b.writeInt(int1);
+        o2b.writeInt(int2);
+      }
+      o1b.resetReaderIndex();
+      o2b.resetReaderIndex();
+      final int res = COMPARATOR.compare(o1b, o2b);
+      o1b.release();
+      o2b.release();
+      return res;
+    }
+  }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  /**
+   * Interface that can test a {@link BufferProxy} <code>compare</code> method.
+   */
+  private interface ComparatorRunner {
+
+    /**
+     * Write the two longs to a buffer using native order and compare the resulting buffers.
+     *
+     * @param long1 lhs value
+     * @param long2 rhs value
+     * @return as per {@link Comparable}
+     */
+    int compare(final long long1, final long long2);
+
+    /**
+     * Write the two int to a buffer using native order and compare the resulting buffers.
+     *
+     * @param int1 lhs value
+     * @param int2 rhs value
+     * @return as per {@link Comparable}
+     */
+    int compare(final int int1, final int int2);
+  }
+}
diff --git a/src/test/java/org/lmdbjava/ComparatorTest.java b/src/test/java/org/lmdbjava/ComparatorTest.java
index bc7ddefe..1d4ed4c8 100644
--- a/src/test/java/org/lmdbjava/ComparatorTest.java
+++ b/src/test/java/org/lmdbjava/ComparatorTest.java
@@ -259,6 +259,16 @@ static ComparatorResult get(final int comparatorResult) {
       }
       return comparatorResult < 0 ? LESS_THAN : GREATER_THAN;
     }
+
+    ComparatorResult opposite() {
+      if (this == LESS_THAN) {
+        return GREATER_THAN;
+      } else if (this == GREATER_THAN) {
+        return LESS_THAN;
+      } else {
+        return EQUAL_TO;
+      }
+    }
   }
 
   /** Interface that can test a {@link BufferProxy} <code>compare</code> method. */
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
index c55687c4..393065a3 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
@@ -191,11 +191,11 @@ private void populateDatabase(final Dbi<ByteBuffer> dbi) {
     try (Txn<ByteBuffer> txn = env.txnRead();
          CursorIterable<ByteBuffer> c = dbi.iterate(txn)) {
 
-      for (final KeyVal<ByteBuffer> kv : c) {
-        System.out.print(getNativeInt(kv.key()) + " => " + kv.val().getInt());
-        System.out.print(", ");
-      }
-      System.out.println();
+//      for (final KeyVal<ByteBuffer> kv : c) {
+//        System.out.print(getNativeInt(kv.key()) + " => " + kv.val().getInt());
+//        System.out.print(", ");
+//      }
+//      System.out.println();
     }
   }
 
@@ -480,14 +480,14 @@ private void verify(final KeyRange<ByteBuffer> range,
         .collect(Collectors.toList());
 
     final List<Integer> results = new ArrayList<>();
-    System.out.println(rangeToString(range) + ", expected: " + expectedValues);
+//    System.out.println(rangeToString(range) + ", expected: " + expectedValues);
 
     try (Txn<ByteBuffer> txn = env.txnRead();
          CursorIterable<ByteBuffer> c = dbi.iterate(txn, range)) {
       for (final KeyVal<ByteBuffer> kv : c) {
         final int key = getNativeInt(kv.key());
         final int val = kv.val().getInt();
-        System.out.println(key + " => " + val);
+//        System.out.println(key + " => " + val);
         results.add(val);
         assertThat(val).satisfiesAnyOf(
             v -> assertThat(v).isEqualTo((key * 10) + 1),
@@ -544,27 +544,27 @@ public Stream<? extends Arguments> provideArguments(ParameterDeclarations parame
                                                         ExtensionContext context) throws Exception {
       final DbiFactory defaultComparatorDb = new DbiFactory("defaultComparator", env ->
           env.buildDbi()
-              .withDbName(DB_1)
+              .setDbName(DB_1)
               .withDefaultComparator()
-              .withDbiFlags(DBI_FLAGS)
+              .setDbiFlags(DBI_FLAGS)
               .open());
       final DbiFactory nativeComparatorDb = new DbiFactory("nativeComparator", env ->
           env.buildDbi()
-              .withDbName(DB_2)
+              .setDbName(DB_2)
               .withNativeComparator()
-              .withDbiFlags(DBI_FLAGS)
+              .setDbiFlags(DBI_FLAGS)
               .open());
       final DbiFactory callbackComparatorDb = new DbiFactory("callbackComparator", env ->
           env.buildDbi()
-              .withDbName(DB_3)
+              .setDbName(DB_3)
               .withCallbackComparator(buildComparator())
-              .withDbiFlags(DBI_FLAGS)
+              .setDbiFlags(DBI_FLAGS)
               .open());
       final DbiFactory iteratorComparatorDb = new DbiFactory("iteratorComparator", env ->
           env.buildDbi()
-              .withDbName(DB_4)
+              .setDbName(DB_4)
               .withIteratorComparator(buildComparator())
-              .withDbiFlags(DBI_FLAGS)
+              .setDbiFlags(DBI_FLAGS)
               .open());
       return Stream.of(
               defaultComparatorDb,
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
index 21d34d30..aa23235a 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
@@ -20,7 +20,6 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
 import static org.lmdbjava.DbiFlags.MDB_INTEGERKEY;
-import static org.lmdbjava.Env.create;
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
 import static org.lmdbjava.KeyRange.all;
 import static org.lmdbjava.KeyRange.allBackward;
@@ -45,7 +44,6 @@
 import static org.lmdbjava.TestUtils.DB_2;
 import static org.lmdbjava.TestUtils.DB_3;
 import static org.lmdbjava.TestUtils.DB_4;
-import static org.lmdbjava.TestUtils.POSIX_MODE;
 import static org.lmdbjava.TestUtils.bb;
 import static org.lmdbjava.TestUtils.bbNative;
 import static org.lmdbjava.TestUtils.getNativeInt;
@@ -101,16 +99,16 @@ public final class CursorIterableIntegerKeyTest {
   @Parameter
   public DbiFactory dbiFactory;
 
-
   @BeforeEach
   public void before() throws IOException {
     file = FileUtil.createTempFile();
     final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
-    env = create(bufferProxy)
+    env = Env.create(bufferProxy)
         .setMapSize(KIBIBYTES.toBytes(256))
         .setMaxReaders(1)
         .setMaxDbs(3)
-        .open(file.toFile(), POSIX_MODE, MDB_NOSUBDIR);
+        .setEnvFlags(MDB_NOSUBDIR)
+        .open(file);
 
     populateTestDataList();
   }
@@ -129,7 +127,7 @@ public void testNumericOrderLong() {
       final Cursor<ByteBuffer> c = dbi.openCursor(txn);
       long i = 1;
       while (true) {
-        System.out.println("putting " + i);
+//        System.out.println("putting " + i);
         c.put(bbNative(i), bb(i + "-long"));
         final long i2 = i * 10;
         if (i2 < i) {
@@ -176,7 +174,7 @@ public void testNumericOrderInt() {
       final Cursor<ByteBuffer> c = dbi.openCursor(txn);
       int i = 1;
       while (true) {
-        System.out.println("putting " + i);
+//        System.out.println("putting " + i);
         c.put(bbNative(i), bb(i + "-int"));
         final int i2 = i * 10;
         if (i2 < i) {
@@ -221,7 +219,7 @@ public void testIntegerKeyKeySize() {
     long maxIntAsLong = Integer.MAX_VALUE;
 
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      System.out.println("Flags: " + db.listFlags(txn));
+//      System.out.println("Flags: " + db.listFlags(txn));
       int val = 0;
       db.put(txn, bbNative(0L), bb("val_" + ++val));
       db.put(txn, bbNative(10L), bb("val_" + ++val));
@@ -243,7 +241,7 @@ public void testIntegerKeyKeySize() {
           final String val = getString(keyVal.val());
           final long key = getNativeLong(keyVal.key());
           final int remaining = keyVal.key().remaining();
-          System.out.println("key: " + key + ", val: " + val + ", remaining: " + remaining);
+//          System.out.println("key: " + key + ", val: " + val + ", remaining: " + remaining);
         }
       }
     }
@@ -603,29 +601,29 @@ public Stream<? extends Arguments> provideArguments(ParameterDeclarations parame
                                                         ExtensionContext context) throws Exception {
       final DbiFactory defaultComparatorDb = new DbiFactory("defaultComparator", env ->
           env.buildDbi()
-              .withDbName(DB_1)
+              .setDbName(DB_1)
               .withDefaultComparator()
-              .withDbiFlags(DBI_FLAGS)
+              .setDbiFlags(DBI_FLAGS)
               .open());
       final DbiFactory nativeComparatorDb = new DbiFactory("nativeComparator", env ->
           env.buildDbi()
-              .withDbName(DB_2)
+              .setDbName(DB_2)
               .withNativeComparator()
-              .withDbiFlags(DBI_FLAGS)
+              .setDbiFlags(DBI_FLAGS)
               .open());
       final Comparator<ByteBuffer> comparator = buildComparator();
 
       final DbiFactory callbackComparatorDb = new DbiFactory("callbackComparator", env ->
           env.buildDbi()
-              .withDbName(DB_3)
+              .setDbName(DB_3)
               .withCallbackComparator(comparator)
-              .withDbiFlags(DBI_FLAGS)
+              .setDbiFlags(DBI_FLAGS)
               .open());
       final DbiFactory iteratorComparatorDb = new DbiFactory("iteratorComparator", env ->
           env.buildDbi()
-              .withDbName(DB_4)
+              .setDbName(DB_4)
               .withIteratorComparator(comparator)
-              .withDbiFlags(DBI_FLAGS)
+              .setDbiFlags(DBI_FLAGS)
               .open());
       return Stream.of(
               defaultComparatorDb,
diff --git a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
index 6bf1ee71..008695fd 100644
--- a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
@@ -65,22 +65,22 @@ public void before() throws IOException {
     final DbiFlagSet dbiFlagSet = MDB_CREATE;
     // Use a java comparator for start/stop keys only
     dbJavaComparator = env.buildDbi()
-        .withDbName("JavaComparator")
+        .setDbName("JavaComparator")
         .withDefaultComparator()
-        .withDbiFlags(dbiFlagSet)
+        .setDbiFlags(dbiFlagSet)
         .open();
     // Use LMDB comparator for start/stop keys
     dbLmdbComparator = env.buildDbi()
-        .withDbName("LmdbComparator")
+        .setDbName("LmdbComparator")
         .withNativeComparator()
-        .withDbiFlags(dbiFlagSet)
+        .setDbiFlags(dbiFlagSet)
         .open();
 
     // Use a java comparator for start/stop keys and as a callback comparator
     dbCallbackComparator = env.buildDbi()
-        .withDbName("CallBackComparator")
+        .setDbName("CallBackComparator")
         .withCallbackComparator(bufferProxy.getComparator(dbiFlagSet))
-        .withDbiFlags(dbiFlagSet)
+        .setDbiFlags(dbiFlagSet)
         .open();
 
     dbs.add(dbJavaComparator);
diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index 30894a9c..0286fa88 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -46,7 +46,6 @@
 import static org.lmdbjava.TestUtils.DB_2;
 import static org.lmdbjava.TestUtils.DB_3;
 import static org.lmdbjava.TestUtils.DB_4;
-import static org.lmdbjava.TestUtils.POSIX_MODE;
 import static org.lmdbjava.TestUtils.bb;
 
 import com.google.common.primitives.UnsignedBytes;
@@ -95,42 +94,6 @@ public final class CursorIterableTest {
   @Parameter
   public DbiFactory dbiFactory;
 
-//  ArgumentsSource
-
-//  @Parameterized.Parameters(name = "{index}: dbi: {0}")
-
-//  public static Object[] data() {
-//    final DbiFactory defaultComparatorDb = new DbiFactory("defaultComparator", env ->
-//        env.buildDbi()
-//            .withDbName(DB_1)
-//            .withDefaultComparator()
-//            .withDbiFlags(DBI_FLAGS)
-//            .open());
-//    final DbiFactory nativeComparatorDb = new DbiFactory("nativeComparator", env ->
-//        env.buildDbi()
-//            .withDbName(DB_2)
-//            .withNativeComparator()
-//            .withDbiFlags(DBI_FLAGS)
-//            .open());
-//    final DbiFactory callbackComparatorDb = new DbiFactory("callbackComparator", env ->
-//        env.buildDbi()
-//            .withDbName(DB_3)
-//            .withCallbackComparator(BUFFER_PROXY.getComparator(DBI_FLAGS))
-//            .withDbiFlags(DBI_FLAGS)
-//            .open());
-//    final DbiFactory iteratorComparatorDb = new DbiFactory("iteratorComparator", env ->
-//        env.buildDbi()
-//            .withDbName(DB_4)
-//            .withIteratorComparator(BUFFER_PROXY.getComparator(DBI_FLAGS))
-//            .withDbiFlags(DBI_FLAGS)
-//            .open());
-//    return new Object[]{
-//        defaultComparatorDb,
-//        nativeComparatorDb,
-//        callbackComparatorDb,
-//        iteratorComparatorDb};
-//  }
-
   @BeforeEach
   void beforeEach() {
     file = FileUtil.createTempFile();
@@ -139,7 +102,8 @@ void beforeEach() {
         .setMapSize(KIBIBYTES.toBytes(256))
         .setMaxReaders(1)
         .setMaxDbs(3)
-        .open(file.toFile(), POSIX_MODE, MDB_NOSUBDIR);
+        .setEnvFlags(MDB_NOSUBDIR)
+        .open(file);
 
     populateTestDataList();
   }
@@ -571,27 +535,27 @@ public Stream<? extends Arguments> provideArguments(ParameterDeclarations parame
                                                         ExtensionContext context) throws Exception {
       final DbiFactory defaultComparatorDb = new DbiFactory("defaultComparator", env ->
           env.buildDbi()
-              .withDbName(DB_1)
+              .setDbName(DB_1)
               .withDefaultComparator()
-              .withDbiFlags(DBI_FLAGS)
+              .setDbiFlags(DBI_FLAGS)
               .open());
       final DbiFactory nativeComparatorDb = new DbiFactory("nativeComparator", env ->
           env.buildDbi()
-              .withDbName(DB_2)
+              .setDbName(DB_2)
               .withNativeComparator()
-              .withDbiFlags(DBI_FLAGS)
+              .setDbiFlags(DBI_FLAGS)
               .open());
       final DbiFactory callbackComparatorDb = new DbiFactory("callbackComparator", env ->
           env.buildDbi()
-              .withDbName(DB_3)
+              .setDbName(DB_3)
               .withCallbackComparator(BUFFER_PROXY.getComparator(DBI_FLAGS))
-              .withDbiFlags(DBI_FLAGS)
+              .setDbiFlags(DBI_FLAGS)
               .open());
       final DbiFactory iteratorComparatorDb = new DbiFactory("iteratorComparator", env ->
           env.buildDbi()
-              .withDbName(DB_4)
+              .setDbName(DB_4)
               .withIteratorComparator(BUFFER_PROXY.getComparator(DBI_FLAGS))
-              .withDbiFlags(DBI_FLAGS)
+              .setDbiFlags(DBI_FLAGS)
               .open());
       return Stream.of(
               defaultComparatorDb,
diff --git a/src/test/java/org/lmdbjava/DbiBuilderTest.java b/src/test/java/org/lmdbjava/DbiBuilderTest.java
index fa0a4792..25e622bf 100644
--- a/src/test/java/org/lmdbjava/DbiBuilderTest.java
+++ b/src/test/java/org/lmdbjava/DbiBuilderTest.java
@@ -20,11 +20,15 @@
 import static org.lmdbjava.Env.create;
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
 import static org.lmdbjava.TestUtils.bb;
+import static org.lmdbjava.TestUtils.getString;
 
-import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -35,18 +39,20 @@ public class DbiBuilderTest {
   private Env<ByteBuffer> env;
 
   @BeforeEach
-  public void before() throws IOException {
+  public void before() {
     file = FileUtil.createTempFile();
     env = create()
         .setMapSize(MEBIBYTES.toBytes(64))
         .setMaxReaders(2)
         .setMaxDbs(2)
-        .open(file.toFile(), MDB_NOSUBDIR);
+        .setEnvFlags(MDB_NOSUBDIR)
+        .open(file);
   }
 
   @AfterEach
   public void after() {
     env.close();
+    FileUtil.delete(file);
   }
 
   @Test
@@ -54,7 +60,7 @@ public void unnamed() {
     final Dbi<ByteBuffer> dbi = env.buildDbi()
         .withoutDbName()
         .withDefaultComparator()
-        .withDbiFlags(DbiFlags.MDB_CREATE)
+        .setDbiFlags(DbiFlags.MDB_CREATE)
         .open();
     assertThat(dbi.getName()).isNull();
     assertThat(dbi.getNameAsString()).isEmpty();
@@ -65,15 +71,120 @@ public void unnamed() {
   @Test
   public void named() {
     final Dbi<ByteBuffer> dbi = env.buildDbi()
-        .withDbName("foo")
+        .setDbName("foo")
         .withDefaultComparator()
-        .withDbiFlags(DbiFlags.MDB_CREATE)
+        .setDbiFlags(DbiFlags.MDB_CREATE)
         .open();
 
     assertPutAndGet(dbi);
 
     assertThat(env.getDbiNames()).hasSize(1);
-    assertThat(new String(env.getDbiNames().get(0), StandardCharsets.UTF_8)).isEqualTo("foo");
+    assertThat(new String(env.getDbiNames().get(0), StandardCharsets.UTF_8))
+        .isEqualTo("foo");
+    assertThat(dbi.getNameAsString())
+        .isEqualTo("foo");
+    assertThat(dbi.getNameAsString(StandardCharsets.UTF_8))
+        .isEqualTo("foo");
+  }
+
+  @Test
+  public void named2() {
+    final Dbi<ByteBuffer> dbi = env.buildDbi()
+        .setDbName("foo".getBytes(StandardCharsets.US_ASCII))
+        .withDefaultComparator()
+        .setDbiFlags(DbiFlags.MDB_CREATE)
+        .open();
+
+    assertPutAndGet(dbi);
+
+    assertThat(env.getDbiNames()).hasSize(1);
+    assertThat(new String(env.getDbiNames().get(0), StandardCharsets.US_ASCII))
+        .isEqualTo("foo");
+    assertThat(dbi.getNameAsString())
+        .isEqualTo("foo");
+    assertThat(dbi.getNameAsString(StandardCharsets.US_ASCII))
+        .isEqualTo("foo");
+  }
+
+  @Test
+  public void nativeComparator() {
+    final Dbi<ByteBuffer> dbi = env.buildDbi()
+        .setDbName("foo")
+        .withNativeComparator()
+        .addDbiFlags(DbiFlags.MDB_CREATE)
+        .open();
+
+    assertPutAndGet(dbi);
+    assertThat(env.getDbiNames()).hasSize(1);
+  }
+
+  @Test
+  public void callback() {
+    final Comparator<ByteBuffer> proxyOptimal = ByteBufferProxy.PROXY_OPTIMAL.getComparator();
+    // Compare on key length, falling back to default
+    final Comparator<ByteBuffer> comparator = (o1, o2) -> {
+      final int res = Integer.compare(o1.remaining(), o2.remaining());
+      if (res == 0) {
+        return proxyOptimal.compare(o1, o2);
+      } else {
+        return res;
+      }
+    };
+
+    final Dbi<ByteBuffer> dbi = env.buildDbi()
+        .setDbName("foo")
+        .withCallbackComparator(comparator)
+        .addDbiFlags(DbiFlags.MDB_CREATE)
+        .open();
+
+    TestUtils.doWithWriteTxn(env, txn -> {
+      dbi.put(txn, bb("fox"), bb("val_1"));
+      dbi.put(txn, bb("rabbit"), bb("val_2"));
+      dbi.put(txn, bb("deer"), bb("val_3"));
+      dbi.put(txn, bb("badger"), bb("val_4"));
+      txn.commit();
+    });
+
+    final List<String> keys = new ArrayList<>();
+    TestUtils.doWithReadTxn(env, txn -> {
+      try (CursorIterable<ByteBuffer> cursorIterable = dbi.iterate(txn)) {
+        final Iterator<CursorIterable.KeyVal<ByteBuffer>> iterator = cursorIterable.iterator();
+        iterator.forEachRemaining(keyVal -> {
+          keys.add(getString(keyVal.key()));
+        });
+      }
+    });
+    assertThat(keys).containsExactly(
+        "fox",
+        "deer",
+        "badger",
+        "rabbit");
+  }
+
+  @Test
+  public void flags() {
+    final Dbi<ByteBuffer> dbi = env.buildDbi()
+        .setDbName("foo")
+        .withDefaultComparator()
+        .setDbiFlags(DbiFlags.MDB_DUPSORT, DbiFlags.MDB_DUPFIXED) // Will get overwritten
+        .setDbiFlags() // clear them
+        .addDbiFlags(DbiFlags.MDB_CREATE) // Not a dbi flag as far as lmdb is concerned.
+        .addDbiFlags(DbiFlags.MDB_INTEGERKEY)
+        .addDbiFlags(DbiFlags.MDB_REVERSEKEY)
+        .open();
+
+    assertPutAndGet(dbi);
+
+    assertThat(env.getDbiNames()).hasSize(1);
+    assertThat(new String(env.getDbiNames().get(0), StandardCharsets.UTF_8))
+        .isEqualTo("foo");
+
+    TestUtils.doWithReadTxn(env, readTxn -> {
+      assertThat(dbi.listFlags(readTxn))
+          .containsExactlyInAnyOrder(
+              DbiFlags.MDB_INTEGERKEY,
+              DbiFlags.MDB_REVERSEKEY);
+    });
   }
 
   private void assertPutAndGet(Dbi<ByteBuffer> dbi) {
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index c369c193..7302018c 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -110,7 +110,7 @@ void close() {
     assertThatThrownBy(
             () -> {
               final Dbi<ByteBuffer> db = env.buildDbi()
-                  .withDbName(DB_1)
+                  .setDbName(DB_1)
                   .withDefaultComparator()
                   .addDbiFlag(MDB_CREATE)
                   .open();
diff --git a/src/test/java/org/lmdbjava/TestUtils.java b/src/test/java/org/lmdbjava/TestUtils.java
index 94ceb3a7..68d988d1 100644
--- a/src/test/java/org/lmdbjava/TestUtils.java
+++ b/src/test/java/org/lmdbjava/TestUtils.java
@@ -25,6 +25,9 @@
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 import java.nio.charset.StandardCharsets;
+import java.util.Objects;
+import java.util.function.Consumer;
+import java.util.function.Function;
 import org.agrona.MutableDirectBuffer;
 import org.agrona.concurrent.UnsafeBuffer;
 
@@ -133,4 +136,36 @@ static ByteBuf nb(final int value) {
     b.writeInt(value);
     return b;
   }
+
+  static <T> void doWithReadTxn(final Env<T> env, final Consumer<Txn<T>> work) {
+    Objects.requireNonNull(env);
+    Objects.requireNonNull(work);
+    try (Txn<T> readTxn = env.txnRead()) {
+      work.accept(readTxn);
+    }
+  }
+
+  static <T, R> R getWithReadTxn(final Env<T> env, final Function<Txn<T>, R> work) {
+    Objects.requireNonNull(env);
+    Objects.requireNonNull(work);
+    try (Txn<T> readTxn = env.txnRead()) {
+      return work.apply(readTxn);
+    }
+  }
+
+  static <T> void doWithWriteTxn(final Env<T> env, final Consumer<Txn<T>> work) {
+    Objects.requireNonNull(env);
+    Objects.requireNonNull(work);
+    try (Txn<T> readTxn = env.txnWrite()) {
+      work.accept(readTxn);
+    }
+  }
+
+  static <T, R> R getWithWriteTxn(final Env<T> env, final Function<Txn<T>, R> work) {
+    Objects.requireNonNull(env);
+    Objects.requireNonNull(work);
+    try (Txn<T> readTxn = env.txnWrite()) {
+      return work.apply(readTxn);
+    }
+  }
 }
diff --git a/src/test/java/org/lmdbjava/TxnFlagSetTest.java b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
index bdaf9320..58f75aa6 100644
--- a/src/test/java/org/lmdbjava/TxnFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
@@ -23,57 +23,74 @@
 
 public class TxnFlagSetTest {
 
-    @Test
-    public void testEmpty() {
-        final TxnFlagSet txnFlagSet = TxnFlagSet.empty();
-        assertThat(txnFlagSet.getMask()).isEqualTo(0);
-        assertThat(txnFlagSet.size()).isEqualTo(0);
-        assertThat(txnFlagSet.isEmpty()).isEqualTo(true);
-        assertThat(txnFlagSet.isSet(TxnFlags.MDB_RDONLY_TXN)).isEqualTo(false);
-        final TxnFlagSet txnFlagSet2 = TxnFlagSet.builder()
-            .build();
-        assertThat(txnFlagSet).isEqualTo(txnFlagSet2);
-        assertThat(txnFlagSet).isNotEqualTo(TxnFlagSet.of(TxnFlags.MDB_RDONLY_TXN));
-        assertThat(txnFlagSet).isNotEqualTo(TxnFlagSet.builder()
-            .setFlag(TxnFlags.MDB_RDONLY_TXN)
-            .build());
+  @Test
+  void testSingleEnum() {
+    final TxnFlagSet txnFlagSet = TxnFlags.MDB_RDONLY_TXN;
+    assertThat(txnFlagSet.getMask()).isEqualTo(MaskedFlag.mask(TxnFlags.MDB_RDONLY_TXN));
+    assertThat(txnFlagSet.size()).isEqualTo(1);
+    for (TxnFlags flag : txnFlagSet) {
+      assertThat(txnFlagSet.isSet(flag)).isEqualTo(true);
     }
 
-    @Test
-    public void testOf() {
-        final TxnFlags txnFlag = TxnFlags.MDB_RDONLY_TXN;
-        final TxnFlagSet txnFlagSet = TxnFlagSet.of(txnFlag);
-        assertThat(txnFlagSet.getMask()).isEqualTo(MaskedFlag.mask(txnFlag));
-        assertThat(txnFlagSet.size()).isEqualTo(1);
-        for (TxnFlags flag : txnFlagSet) {
-            assertThat(txnFlagSet.isSet(flag)).isEqualTo(true);
-        }
+    final TxnFlagSet txnFlagSet2 = TxnFlagSet.builder()
+        .setFlag(TxnFlags.MDB_RDONLY_TXN)
+        .build();
+    assertThat(txnFlagSet2.getFlags()).containsExactlyElementsOf(txnFlagSet.getFlags());
+    assertThat(txnFlagSet.areAnySet(TxnFlags.MDB_RDONLY_TXN)).isTrue();
+    assertThat(txnFlagSet.areAnySet(TxnFlagSet.empty())).isFalse();
+  }
 
-        final TxnFlagSet txnFlagSet2 = TxnFlagSet.builder()
-            .setFlag(txnFlag)
-            .build();
-        assertThat(txnFlagSet).isEqualTo(txnFlagSet2);
+  @Test
+  public void testEmpty() {
+    final TxnFlagSet txnFlagSet = TxnFlagSet.empty();
+    assertThat(txnFlagSet.getMask()).isEqualTo(0);
+    assertThat(txnFlagSet.size()).isEqualTo(0);
+    assertThat(txnFlagSet.isEmpty()).isEqualTo(true);
+    assertThat(txnFlagSet.isSet(TxnFlags.MDB_RDONLY_TXN)).isEqualTo(false);
+    final TxnFlagSet txnFlagSet2 = TxnFlagSet.builder()
+        .build();
+    assertThat(txnFlagSet).isEqualTo(txnFlagSet2);
+    assertThat(txnFlagSet).isNotEqualTo(TxnFlagSet.of(TxnFlags.MDB_RDONLY_TXN));
+    assertThat(txnFlagSet).isNotEqualTo(TxnFlagSet.builder()
+        .setFlag(TxnFlags.MDB_RDONLY_TXN)
+        .build());
+  }
+
+  @Test
+  public void testOf() {
+    final TxnFlags txnFlag = TxnFlags.MDB_RDONLY_TXN;
+    final TxnFlagSet txnFlagSet = TxnFlagSet.of(txnFlag);
+    assertThat(txnFlagSet.getMask()).isEqualTo(MaskedFlag.mask(txnFlag));
+    assertThat(txnFlagSet.size()).isEqualTo(1);
+    for (TxnFlags flag : txnFlagSet) {
+      assertThat(txnFlagSet.isSet(flag)).isEqualTo(true);
     }
 
-    @Test
-    public void testBuilder() {
-        final TxnFlags txnFlag1 = TxnFlags.MDB_RDONLY_TXN;
-        final TxnFlagSet txnFlagSet = TxnFlagSet.builder()
-                .setFlag(txnFlag1)
-                .build();
-        assertThat(txnFlagSet.getMask()).isEqualTo(MaskedFlag.mask(txnFlag1));
-        assertThat(txnFlagSet.size()).isEqualTo(1);
-        assertThat(txnFlagSet.isSet(TxnFlags.MDB_RDONLY_TXN)).isEqualTo(true);
-        for (TxnFlags flag : txnFlagSet) {
-            assertThat(txnFlagSet.isSet(flag)).isEqualTo(true);
-        }
-        final TxnFlagSet txnFlagSet2 = TxnFlagSet.builder()
-                .withFlags(txnFlag1)
-                .build();
-        final TxnFlagSet txnFlagSet3 = TxnFlagSet.builder()
-                .withFlags(new HashSet<>(Collections.singletonList(txnFlag1)))
-                .build();
-        assertThat(txnFlagSet).isEqualTo(txnFlagSet2);
-        assertThat(txnFlagSet).isEqualTo(txnFlagSet3);
+    final TxnFlagSet txnFlagSet2 = TxnFlagSet.builder()
+        .setFlag(txnFlag)
+        .build();
+    assertThat(txnFlagSet).isEqualTo(txnFlagSet2);
+  }
+
+  @Test
+  public void testBuilder() {
+    final TxnFlags txnFlag1 = TxnFlags.MDB_RDONLY_TXN;
+    final TxnFlagSet txnFlagSet = TxnFlagSet.builder()
+        .setFlag(txnFlag1)
+        .build();
+    assertThat(txnFlagSet.getMask()).isEqualTo(MaskedFlag.mask(txnFlag1));
+    assertThat(txnFlagSet.size()).isEqualTo(1);
+    assertThat(txnFlagSet.isSet(TxnFlags.MDB_RDONLY_TXN)).isEqualTo(true);
+    for (TxnFlags flag : txnFlagSet) {
+      assertThat(txnFlagSet.isSet(flag)).isEqualTo(true);
     }
+    final TxnFlagSet txnFlagSet2 = TxnFlagSet.builder()
+        .withFlags(txnFlag1)
+        .build();
+    final TxnFlagSet txnFlagSet3 = TxnFlagSet.builder()
+        .withFlags(new HashSet<>(Collections.singletonList(txnFlag1)))
+        .build();
+    assertThat(txnFlagSet).isEqualTo(txnFlagSet2);
+    assertThat(txnFlagSet).isEqualTo(txnFlagSet3);
+  }
 }

From 7374fde065fd2c71ce5b90ac785a3989a0a92207 Mon Sep 17 00:00:00 2001
From: stroomdev66 <stroomdev66@gmail.com>
Date: Wed, 5 Nov 2025 13:21:08 +0000
Subject: [PATCH 250/322] #267 Fix to establish start key when iterating
 backwards from a start key using DUPSORT

---
 .../java/org/lmdbjava/ComparatorTest.java     | 35 ++++++++++-------
 .../java/org/lmdbjava/CursorParamTest.java    | 38 +++++++++----------
 2 files changed, 40 insertions(+), 33 deletions(-)

diff --git a/src/test/java/org/lmdbjava/ComparatorTest.java b/src/test/java/org/lmdbjava/ComparatorTest.java
index a5e010ab..674f4059 100644
--- a/src/test/java/org/lmdbjava/ComparatorTest.java
+++ b/src/test/java/org/lmdbjava/ComparatorTest.java
@@ -34,9 +34,12 @@
 import java.util.stream.Stream;
 import org.agrona.DirectBuffer;
 import org.agrona.concurrent.UnsafeBuffer;
+import org.junit.jupiter.api.extension.ExtensionContext;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.params.provider.ArgumentsProvider;
+import org.junit.jupiter.params.provider.ArgumentsSource;
+import org.junit.jupiter.params.support.ParameterDeclarations;
 
 /** Tests comparator functions are consistent across buffers. */
 public final class ComparatorTest {
@@ -54,16 +57,20 @@ public final class ComparatorTest {
   private static final byte[] LX = buffer(0);
   private static final byte[] XX = buffer();
 
-  static Stream<Arguments> comparatorProvider() {
-    return Stream.of(
-        Arguments.argumentSet("StringRunner", new StringRunner()),
-        Arguments.argumentSet("DirectBufferRunner", new DirectBufferRunner()),
-        Arguments.argumentSet("ByteArrayRunner", new ByteArrayRunner()),
-        Arguments.argumentSet("UnsignedByteArrayRunner", new UnsignedByteArrayRunner()),
-        Arguments.argumentSet("ByteBufferRunner", new ByteBufferRunner()),
-        Arguments.argumentSet("NettyRunner", new NettyRunner()),
-        Arguments.argumentSet("GuavaUnsignedBytes", new GuavaUnsignedBytes()),
-        Arguments.argumentSet("GuavaSignedBytes", new GuavaSignedBytes()));
+  static class MyArgumentProvider implements ArgumentsProvider {
+    @Override
+    public Stream<? extends Arguments> provideArguments(
+        ParameterDeclarations parameters, ExtensionContext context) {
+      return Stream.of(
+          Arguments.argumentSet("StringRunner", new StringRunner()),
+          Arguments.argumentSet("DirectBufferRunner", new DirectBufferRunner()),
+          Arguments.argumentSet("ByteArrayRunner", new ByteArrayRunner()),
+          Arguments.argumentSet("UnsignedByteArrayRunner", new UnsignedByteArrayRunner()),
+          Arguments.argumentSet("ByteBufferRunner", new ByteBufferRunner()),
+          Arguments.argumentSet("NettyRunner", new NettyRunner()),
+          Arguments.argumentSet("GuavaUnsignedBytes", new GuavaUnsignedBytes()),
+          Arguments.argumentSet("GuavaSignedBytes", new GuavaSignedBytes()));
+    }
   }
 
   private static byte[] buffer(final int... bytes) {
@@ -75,7 +82,7 @@ private static byte[] buffer(final int... bytes) {
   }
 
   @ParameterizedTest
-  @MethodSource("comparatorProvider")
+  @ArgumentsSource(MyArgumentProvider.class)
   void atLeastOneBufferHasEightBytes(final ComparatorRunner comparator) {
     assertThat(get(comparator.compare(HLLLLLLL, LLLLLLLL))).isEqualTo(GREATER_THAN);
     assertThat(get(comparator.compare(LLLLLLLL, HLLLLLLL))).isEqualTo(LESS_THAN);
@@ -94,7 +101,7 @@ void atLeastOneBufferHasEightBytes(final ComparatorRunner comparator) {
   }
 
   @ParameterizedTest
-  @MethodSource("comparatorProvider")
+  @ArgumentsSource(MyArgumentProvider.class)
   void buffersOfTwoBytes(final ComparatorRunner comparator) {
     assertThat(get(comparator.compare(LL, XX))).isEqualTo(GREATER_THAN);
     assertThat(get(comparator.compare(XX, LL))).isEqualTo(LESS_THAN);
@@ -110,7 +117,7 @@ void buffersOfTwoBytes(final ComparatorRunner comparator) {
   }
 
   @ParameterizedTest
-  @MethodSource("comparatorProvider")
+  @ArgumentsSource(MyArgumentProvider.class)
   void equalBuffers(final ComparatorRunner comparator) {
     assertThat(get(comparator.compare(LL, LL))).isEqualTo(EQUAL_TO);
     assertThat(get(comparator.compare(HX, HX))).isEqualTo(EQUAL_TO);
diff --git a/src/test/java/org/lmdbjava/CursorParamTest.java b/src/test/java/org/lmdbjava/CursorParamTest.java
index 7f0bad8a..6a0b01cd 100644
--- a/src/test/java/org/lmdbjava/CursorParamTest.java
+++ b/src/test/java/org/lmdbjava/CursorParamTest.java
@@ -32,15 +32,8 @@
 import static org.lmdbjava.GetOp.MDB_SET_KEY;
 import static org.lmdbjava.GetOp.MDB_SET_RANGE;
 import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
-import static org.lmdbjava.SeekOp.MDB_FIRST;
-import static org.lmdbjava.SeekOp.MDB_LAST;
-import static org.lmdbjava.SeekOp.MDB_NEXT;
-import static org.lmdbjava.SeekOp.MDB_PREV;
-import static org.lmdbjava.TestUtils.DB_1;
-import static org.lmdbjava.TestUtils.POSIX_MODE;
-import static org.lmdbjava.TestUtils.bb;
-import static org.lmdbjava.TestUtils.mdb;
-import static org.lmdbjava.TestUtils.nb;
+import static org.lmdbjava.SeekOp.*;
+import static org.lmdbjava.TestUtils.*;
 
 import io.netty.buffer.ByteBuf;
 import java.nio.ByteBuffer;
@@ -48,26 +41,33 @@
 import java.util.stream.Stream;
 import org.agrona.DirectBuffer;
 import org.agrona.MutableDirectBuffer;
+import org.junit.jupiter.api.extension.ExtensionContext;
 import org.junit.jupiter.api.io.TempDir;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.params.provider.ArgumentsProvider;
+import org.junit.jupiter.params.provider.ArgumentsSource;
+import org.junit.jupiter.params.support.ParameterDeclarations;
 
 /** Test {@link Cursor} with different buffer implementations. */
 public final class CursorParamTest {
 
-  static Stream<Arguments> data() {
-    return Stream.of(
-        Arguments.argumentSet(
-            "ByteBufferRunner(PROXY_OPTIMAL)", new ByteBufferRunner(PROXY_OPTIMAL)),
-        Arguments.argumentSet("ByteBufferRunner(PROXY_SAFE)", new ByteBufferRunner(PROXY_SAFE)),
-        Arguments.argumentSet("ByteArrayRunner(PROXY_BA)", new ByteArrayRunner(PROXY_BA)),
-        Arguments.argumentSet("DirectBufferRunner", new DirectBufferRunner()),
-        Arguments.argumentSet("NettyBufferRunner", new NettyBufferRunner()));
+  static class MyArgumentProvider implements ArgumentsProvider {
+    @Override
+    public Stream<? extends Arguments> provideArguments(
+        ParameterDeclarations parameters, ExtensionContext context) {
+      return Stream.of(
+          Arguments.argumentSet(
+              "ByteBufferRunner(PROXY_OPTIMAL)", new ByteBufferRunner(PROXY_OPTIMAL)),
+          Arguments.argumentSet("ByteBufferRunner(PROXY_SAFE)", new ByteBufferRunner(PROXY_SAFE)),
+          Arguments.argumentSet("ByteArrayRunner(PROXY_BA)", new ByteArrayRunner(PROXY_BA)),
+          Arguments.argumentSet("DirectBufferRunner", new DirectBufferRunner()),
+          Arguments.argumentSet("NettyBufferRunner", new NettyBufferRunner()));
+    }
   }
 
   @ParameterizedTest
-  @MethodSource("data")
+  @ArgumentsSource(MyArgumentProvider.class)
   void execute(final BufferRunner<?> runner, @TempDir final Path tmp) {
     runner.execute(tmp);
   }

From 787d6d38aa7f161cf2fd8ee3e10d466e69ab20eb Mon Sep 17 00:00:00 2001
From: stroomdev66 <stroomdev66@gmail.com>
Date: Wed, 5 Nov 2025 13:22:45 +0000
Subject: [PATCH 251/322] #267 Fix to establish start key when iterating
 backwards from a start key using DUPSORT

---
 src/main/java/org/lmdbjava/MaskedFlag.java | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/main/java/org/lmdbjava/MaskedFlag.java b/src/main/java/org/lmdbjava/MaskedFlag.java
index 58d67d8c..87deb3c9 100644
--- a/src/main/java/org/lmdbjava/MaskedFlag.java
+++ b/src/main/java/org/lmdbjava/MaskedFlag.java
@@ -17,7 +17,6 @@
 
 import static java.util.Objects.requireNonNull;
 
-import java.util.Arrays;
 import java.util.Objects;
 import java.util.function.Predicate;
 import java.util.stream.Stream;

From c289763641e81d0b8c3e94e73725eb3abb36d9f2 Mon Sep 17 00:00:00 2001
From: stroomdev66 <stroomdev66@gmail.com>
Date: Wed, 5 Nov 2025 13:43:06 +0000
Subject: [PATCH 252/322] #267 Fix to establish start key when iterating
 backwards from a start key using DUPSORT

---
 .gitignore                                    |   1 -
 .../java/org/lmdbjava/CursorIterable.java     |   6 +-
 .../java/org/lmdbjava/ComparatorTest.java     |   5 +-
 .../org/lmdbjava/CursorIterableRangeTest.java | 106 +++---------------
 .../java/org/lmdbjava/CursorParamTest.java    |  11 +-
 src/test/java/org/lmdbjava/DbiTest.java       |  16 ++-
 src/test/java/org/lmdbjava/EnvTest.java       |   6 +-
 src/test/java/org/lmdbjava/TutorialTest.java  |   4 +-
 8 files changed, 52 insertions(+), 103 deletions(-)

diff --git a/.gitignore b/.gitignore
index 44fe1d51..5f3ff273 100644
--- a/.gitignore
+++ b/.gitignore
@@ -16,5 +16,4 @@ dependency-reduced-pom.xml
 gpg-sign.json
 mvn-sync.json
 secrets.tar
-openldap
 pom.xml.versionsBackup
diff --git a/src/main/java/org/lmdbjava/CursorIterable.java b/src/main/java/org/lmdbjava/CursorIterable.java
index b6d58e3d..80fd5ef3 100644
--- a/src/main/java/org/lmdbjava/CursorIterable.java
+++ b/src/main/java/org/lmdbjava/CursorIterable.java
@@ -15,7 +15,11 @@
  */
 package org.lmdbjava;
 
-import static org.lmdbjava.CursorIterable.State.*;
+import static org.lmdbjava.CursorIterable.State.RELEASED;
+import static org.lmdbjava.CursorIterable.State.REQUIRES_INITIAL_OP;
+import static org.lmdbjava.CursorIterable.State.REQUIRES_ITERATOR_OP;
+import static org.lmdbjava.CursorIterable.State.REQUIRES_NEXT_OP;
+import static org.lmdbjava.CursorIterable.State.TERMINATED;
 import static org.lmdbjava.GetOp.MDB_SET_RANGE;
 
 import java.util.Comparator;
diff --git a/src/test/java/org/lmdbjava/ComparatorTest.java b/src/test/java/org/lmdbjava/ComparatorTest.java
index 674f4059..2fabb3da 100644
--- a/src/test/java/org/lmdbjava/ComparatorTest.java
+++ b/src/test/java/org/lmdbjava/ComparatorTest.java
@@ -22,7 +22,10 @@
 import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
 import static org.lmdbjava.ByteBufProxy.PROXY_NETTY;
 import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
-import static org.lmdbjava.ComparatorTest.ComparatorResult.*;
+import static org.lmdbjava.ComparatorTest.ComparatorResult.EQUAL_TO;
+import static org.lmdbjava.ComparatorTest.ComparatorResult.GREATER_THAN;
+import static org.lmdbjava.ComparatorTest.ComparatorResult.LESS_THAN;
+import static org.lmdbjava.ComparatorTest.ComparatorResult.get;
 import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
 
 import com.google.common.primitives.SignedBytes;
diff --git a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
index dd33e885..0802c047 100644
--- a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
@@ -19,12 +19,22 @@
 import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
 import static java.nio.ByteBuffer.allocateDirect;
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.lmdbjava.DbiFlags.*;
+import static org.lmdbjava.DbiFlags.MDB_CREATE;
+import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
+import static org.lmdbjava.DbiFlags.MDB_INTEGERKEY;
 import static org.lmdbjava.Env.create;
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
-import static org.lmdbjava.TestUtils.*;
+import static org.lmdbjava.TestUtils.DB_1;
+import static org.lmdbjava.TestUtils.POSIX_MODE;
+import static org.lmdbjava.TestUtils.bb;
 
-import java.io.*;
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.Reader;
+import java.io.StringWriter;
+import java.io.UncheckedIOException;
+import java.io.Writer;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 import java.nio.file.Path;
@@ -231,96 +241,6 @@ private long getLong(final ByteBuffer byteBuffer, final ByteOrder byteOrder) {
     }
   }
 
-  //
-  //  @Test
-  //  void testSignedComparator() throws IOException {
-  //    test(ByteBuffer::compareTo, true, "testSignedComparator", 1, MDB_CREATE);
-  //  }
-  //
-  //  @Test
-  //  void testUnsignedComparator() throws IOException {
-  //    test(AbstractByteBufferProxy::compareBuff, false, "testUnsignedComparator", 1, MDB_CREATE);
-  //  }
-  //
-  //  @Test
-  //  void testSignedComparatorDupsort() throws IOException {
-  //    test(ByteBuffer::compareTo, true, "testSignedComparatorDupsort", 2, MDB_CREATE,
-  // MDB_DUPSORT);
-  //  }
-  //
-  //  @Test
-  //  void testUnsignedComparatorDupsort() throws IOException {
-  //    test(AbstractByteBufferProxy::compareBuff, false, "testUnsignedComparatorDupsort", 2,
-  // MDB_CREATE, MDB_DUPSORT);
-  //  }
-  //
-  //  private void test(final Comparator<ByteBuffer> comparator,
-  //                    final boolean nativeCb,
-  //                    final String testName,
-  //                    final BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> dbPopulator,
-  //                    final DbiFlags... flags) throws IOException {
-  //    final Path dbPath = Files.createTempFile("test", "db");
-  //    try (final Env<ByteBuffer> env =
-  //                 create()
-  //                         .setMapSize(KIBIBYTES.toBytes(256))
-  //                         .setMaxReaders(1)
-  //                         .setMaxDbs(1)
-  //                         .open(dbPath.toFile(), POSIX_MODE, MDB_NOSUBDIR)) {
-  //      final Dbi<ByteBuffer> dbi = env.openDbi(DB_1, comparator, nativeCb, flags);
-  //      dbPopulator.accept(env, dbi);
-  //
-  //      final File tests = new File("src/test/resources/CursorIterableRangeTest/tests.csv");
-  //      final File actual = tests.getParentFile().toPath().resolve(testName + ".actual").toFile();
-  //      final File expected = tests.getParentFile().toPath().resolve(testName +
-  // ".expected").toFile();
-  //      final String csv = readFile(tests);
-  //      final String[] parts = csv.split("\n");
-  //      try (final Writer writer = new FileWriter(actual)) {
-  //        for (final String part : parts) {
-  //          final String[] params = part.split(",");
-  //          final KeyRangeType keyRangeType = KeyRangeType.valueOf(params[0].trim());
-  //          ByteBuffer start = null;
-  //          ByteBuffer stop = null;
-  //          if (params.length > 1 && params[1].trim().length() > 0) {
-  //            start = bb(Integer.parseInt(params[1].trim()));
-  //          }
-  //          if (params.length > 2 && params[2].trim().length() > 0) {
-  //            stop = bb(Integer.parseInt(params[2].trim()));
-  //          }
-  //
-  //          for (int i = 0; i < 3; i++) {
-  //            if (params.length > i) {
-  //              writer.append(params[i].trim());
-  //            }
-  //            writer.append(",");
-  //          }
-  //
-  //          final KeyRange<ByteBuffer> keyRange = new KeyRange<>(keyRangeType, start, stop);
-  //          try (Txn<ByteBuffer> txn = env.txnRead();
-  //               CursorIterable<ByteBuffer> c = dbi.iterate(txn, keyRange)) {
-  //            for (final KeyVal<ByteBuffer> kv : c) {
-  //              final int key = kv.key().getInt();
-  //              final int val = kv.val().getInt();
-  //              writer.append("[");
-  //              writer.append(String.valueOf(key));
-  //              writer.append(" ");
-  //              writer.append(String.valueOf(val));
-  //              writer.append("]");
-  //            }
-  //          }
-  //          writer.append("\n");
-  //        }
-  //      }
-  //
-  //      // Compare files.
-  //      final String act = readFile(actual);
-  //      final String exp = readFile(expected);
-  //      assertThat(act).withFailMessage("Files are not equal").isEqualTo(exp);
-  //    } finally {
-  //      FileUtil.deleteFile(dbPath);
-  //    }
-  //  }
-
   private BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> createBasicDBPopulator() {
     return (env, dbi) -> {
       try (Txn<ByteBuffer> txn = env.txnWrite()) {
diff --git a/src/test/java/org/lmdbjava/CursorParamTest.java b/src/test/java/org/lmdbjava/CursorParamTest.java
index 6a0b01cd..e228e968 100644
--- a/src/test/java/org/lmdbjava/CursorParamTest.java
+++ b/src/test/java/org/lmdbjava/CursorParamTest.java
@@ -32,8 +32,15 @@
 import static org.lmdbjava.GetOp.MDB_SET_KEY;
 import static org.lmdbjava.GetOp.MDB_SET_RANGE;
 import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
-import static org.lmdbjava.SeekOp.*;
-import static org.lmdbjava.TestUtils.*;
+import static org.lmdbjava.SeekOp.MDB_FIRST;
+import static org.lmdbjava.SeekOp.MDB_LAST;
+import static org.lmdbjava.SeekOp.MDB_NEXT;
+import static org.lmdbjava.SeekOp.MDB_PREV;
+import static org.lmdbjava.TestUtils.DB_1;
+import static org.lmdbjava.TestUtils.POSIX_MODE;
+import static org.lmdbjava.TestUtils.bb;
+import static org.lmdbjava.TestUtils.mdb;
+import static org.lmdbjava.TestUtils.nb;
 
 import io.netty.buffer.ByteBuf;
 import java.nio.ByteBuffer;
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 2c4a90b7..563215c4 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -29,14 +29,20 @@
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
 import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
-import static org.lmdbjava.DbiFlags.*;
+import static org.lmdbjava.DbiFlags.MDB_CREATE;
+import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
+import static org.lmdbjava.DbiFlags.MDB_INTEGERKEY;
+import static org.lmdbjava.DbiFlags.MDB_REVERSEKEY;
 import static org.lmdbjava.Env.create;
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
 import static org.lmdbjava.GetOp.MDB_SET_KEY;
 import static org.lmdbjava.KeyRange.atMost;
 import static org.lmdbjava.PutFlags.MDB_NODUPDATA;
 import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
-import static org.lmdbjava.TestUtils.*;
+import static org.lmdbjava.TestUtils.DB_1;
+import static org.lmdbjava.TestUtils.ba;
+import static org.lmdbjava.TestUtils.bb;
+import static org.lmdbjava.TestUtils.fromBa;
 
 import java.nio.ByteBuffer;
 import java.nio.file.Path;
@@ -44,7 +50,11 @@
 import java.util.Comparator;
 import java.util.Iterator;
 import java.util.List;
-import java.util.concurrent.*;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.BiConsumer;
 import java.util.function.Function;
diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index d66aa3a3..6c24c406 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -40,7 +40,11 @@
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.lmdbjava.Env.*;
+import org.lmdbjava.Env.AlreadyClosedException;
+import org.lmdbjava.Env.AlreadyOpenException;
+import org.lmdbjava.Env.Builder;
+import org.lmdbjava.Env.InvalidCopyDestination;
+import org.lmdbjava.Env.MapFullException;
 import org.lmdbjava.Txn.BadReaderLockException;
 
 /** Test {@link Env}. */
diff --git a/src/test/java/org/lmdbjava/TutorialTest.java b/src/test/java/org/lmdbjava/TutorialTest.java
index 8376fbe7..6af2599b 100644
--- a/src/test/java/org/lmdbjava/TutorialTest.java
+++ b/src/test/java/org/lmdbjava/TutorialTest.java
@@ -27,7 +27,9 @@
 import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
 import static org.lmdbjava.Env.create;
 import static org.lmdbjava.GetOp.MDB_SET;
-import static org.lmdbjava.SeekOp.*;
+import static org.lmdbjava.SeekOp.MDB_FIRST;
+import static org.lmdbjava.SeekOp.MDB_LAST;
+import static org.lmdbjava.SeekOp.MDB_PREV;
 
 import java.nio.ByteBuffer;
 import java.nio.file.Path;

From 1acd9711efb752013b6588e5e3d106474afa5822 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Wed, 5 Nov 2025 16:57:43 +0000
Subject: [PATCH 253/322] Add ComparatorFactory

---
 src/main/java/org/lmdbjava/DbiBuilder.java    |  50 +++++---
 .../lmdbjava/ComparatorIntegerKeyTest.java    | 109 ++++++++----------
 .../CursorIterableIntegerDupTest.java         |   6 +-
 .../CursorIterableIntegerKeyTest.java         |   8 +-
 .../org/lmdbjava/CursorIterablePerfTest.java  |   2 +-
 .../java/org/lmdbjava/CursorIterableTest.java |  11 +-
 .../java/org/lmdbjava/DbiBuilderTest.java     |   2 +-
 7 files changed, 96 insertions(+), 92 deletions(-)

diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
index f94118a7..9cb85616 100644
--- a/src/main/java/org/lmdbjava/DbiBuilder.java
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -49,8 +49,9 @@ public class DbiBuilder<T> {
    * <p>
    * The name will be converted into bytes using {@link StandardCharsets#UTF_8}.
    * </p>
+   *
    * @param name The name of the database or null for the unnamed database
-   *            (see also {@link DbiBuilder#withoutDbName()})
+   *             (see also {@link DbiBuilder#withoutDbName()})
    * @return The next builder stage.
    */
   public DbiBuilderStage2<T> setDbName(final String name) {
@@ -63,6 +64,7 @@ public DbiBuilderStage2<T> setDbName(final String name) {
 
   /**
    * Create the {@link Dbi} with the passed name in byte[] form.
+   *
    * @param name The name of the database in byte form.
    * @return The next builder stage.
    */
@@ -83,6 +85,7 @@ public DbiBuilderStage2<T> setDbName(final byte[] name) {
    * <p>Note: The 'unnamed database' is used by LMDB to store the names of named databases, with
    * the database name being the key. Use of the unnamed database is intended for simple applications
    * with only one database.</p>
+   *
    * @return The next builder stage.
    */
   public DbiBuilderStage2<T> withoutDbName() {
@@ -102,7 +105,7 @@ public static class DbiBuilderStage2<T> {
 
     private final DbiBuilder<T> dbiBuilder;
 
-    private java.util.Comparator<T> customComparator;
+    private ComparatorFactory<T> comparatorFactory;
     private ComparatorType comparatorType;
 
     private DbiBuilderStage2(final DbiBuilder<T> dbiBuilder) {
@@ -130,7 +133,7 @@ private DbiBuilderStage2(final DbiBuilder<T> dbiBuilder) {
      * If you do not intend to use {@link CursorIterable} then it doesn't matter whether
      * you choose {@link DbiBuilderStage2#withNativeComparator()},
      * {@link DbiBuilderStage2#withDefaultComparator()} or
-     * {@link DbiBuilderStage2#withIteratorComparator(Comparator)} as these comparators will
+     * {@link DbiBuilderStage2#withIteratorComparator(ComparatorFactory)} as these comparators will
      * never be used.
      * </p>
      *
@@ -157,7 +160,7 @@ public DbiBuilderStage3<T> withDefaultComparator() {
      * If you do not intend to use {@link CursorIterable} then it doesn't matter whether
      * you choose {@link DbiBuilderStage2#withNativeComparator()},
      * {@link DbiBuilderStage2#withDefaultComparator()} or
-     * {@link DbiBuilderStage2#withIteratorComparator(Comparator)} as these comparators will
+     * {@link DbiBuilderStage2#withIteratorComparator(ComparatorFactory)} as these comparators will
      * never be used.
      * </p>
      *
@@ -186,11 +189,13 @@ public DbiBuilderStage3<T> withNativeComparator() {
      * are stored in the database.
      * </p>
      *
-     * @param comparator for all key comparison operations.
+     * @param comparatorFactory A factory to create a comparator. {@link ComparatorFactory#create(DbiFlagSet)}
+     *                          will be called once during the initialisation of the {@link Dbi}. It must
+     *                          not return null.
      * @return The next builder stage.
      */
-    public DbiBuilderStage3<T> withCallbackComparator(final Comparator<T> comparator) {
-      this.customComparator = Objects.requireNonNull(comparator);
+    public DbiBuilderStage3<T> withCallbackComparator(final ComparatorFactory<T> comparatorFactory) {
+      this.comparatorFactory = Objects.requireNonNull(comparatorFactory);
       this.comparatorType = ComparatorType.CALLBACK;
       return new DbiBuilderStage3<>(this);
     }
@@ -215,15 +220,17 @@ public DbiBuilderStage3<T> withCallbackComparator(final Comparator<T> comparator
      * If you do not intend to use {@link CursorIterable} then it doesn't matter whether
      * you choose {@link DbiBuilderStage2#withNativeComparator()},
      * {@link DbiBuilderStage2#withDefaultComparator()} or
-     * {@link DbiBuilderStage2#withIteratorComparator(Comparator)} as these comparators will
+     * {@link DbiBuilderStage2#withIteratorComparator(ComparatorFactory)} as these comparators will
      * never be used.
      * </p>
      *
-     * @param comparator The comparator to use with {@link CursorIterable}.
+     * @param comparatorFactory The comparator to use with {@link CursorIterable}.
+     *                          {@link ComparatorFactory#create(DbiFlagSet)} will be called once during the
+     *                          initialisation of the {@link Dbi}. It must not return null.
      * @return The next builder stage.
      */
-    public DbiBuilderStage3<T> withIteratorComparator(final Comparator<T> comparator) {
-      this.customComparator = Objects.requireNonNull(comparator);
+    public DbiBuilderStage3<T> withIteratorComparator(final ComparatorFactory<T> comparatorFactory) {
+      this.comparatorFactory = Objects.requireNonNull(comparatorFactory);
       this.comparatorType = ComparatorType.ITERATOR;
       return new DbiBuilderStage3<>(this);
     }
@@ -267,8 +274,8 @@ public DbiBuilderStage3<T> setDbiFlags(final Collection<DbiFlags> dbiFlags) {
       flagSetBuilder.clear();
       if (dbiFlags != null) {
         dbiFlags.stream()
-                .filter(Objects::nonNull)
-                .forEach(dbiFlags::add);
+            .filter(Objects::nonNull)
+            .forEach(dbiFlags::add);
       }
       return this;
     }
@@ -310,7 +317,7 @@ public DbiBuilderStage3<T> setDbiFlags(final DbiFlags... dbiFlags) {
      * </p>
      *
      * @param dbiFlagSet to open the database with.
-     *                 A null value will just clear all set flags.
+     *                   A null value will just clear all set flags.
      */
     public DbiBuilderStage3<T> setDbiFlags(final DbiFlagSet dbiFlagSet) {
       flagSetBuilder.clear();
@@ -413,7 +420,9 @@ private Comparator<T> getComparator(final DbiBuilder<T> dbiBuilder,
           break;
         case CALLBACK:
         case ITERATOR:
-          comparator = dbiBuilderStage2.customComparator;
+          comparator = Objects.requireNonNull(
+              dbiBuilderStage2.comparatorFactory.create(dbiFlagSet),
+              () -> "comparatorFactory returned null");
           break;
         case NATIVE:
           break;
@@ -465,4 +474,15 @@ private enum ComparatorType {
     ITERATOR,
     ;
   }
+
+
+  // --------------------------------------------------------------------------------
+
+
+  @FunctionalInterface
+  public interface ComparatorFactory<T> {
+
+    Comparator<T> create(final DbiFlagSet dbiFlagSet);
+
+  }
 }
diff --git a/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java b/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java
index 5b9e0761..32e0c8c5 100644
--- a/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java
+++ b/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java
@@ -30,13 +30,10 @@
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 import java.util.Comparator;
-import java.util.LinkedHashMap;
-import java.util.Map;
 import java.util.Random;
 import java.util.stream.Stream;
 import org.agrona.DirectBuffer;
 import org.agrona.concurrent.UnsafeBuffer;
-import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
@@ -98,13 +95,10 @@ void testInt(final ComparatorRunner comparator) {
     assertThat(get(comparator.compare(Integer.MAX_VALUE, 0))).isEqualTo(GREATER_THAN);
   }
 
-  @Test
-  void testRandomLong() {
+  @ParameterizedTest
+  @MethodSource("comparatorProvider")
+  void testRandomLong(final ComparatorRunner runner) {
     final Random random = new Random(3239480);
-    final Map<String, ComparatorRunner> nameToRunnerMap = new LinkedHashMap<>();
-    nameToRunnerMap.put("DirectBufferRunner", new DirectBufferRunner());
-    nameToRunnerMap.put("ByteBufferRunner", new ByteBufferRunner());
-    nameToRunnerMap.put("NettyRunner", new NettyRunner());
 
     // 5mil random longs to compare
     final long[] values = random.longs()
@@ -115,40 +109,33 @@ void testRandomLong() {
     for (int i = 1; i < values.length; i++) {
       final long long1 = values[i - 1];
       final long long2 = values[i];
-      for (Map.Entry<String, ComparatorRunner> entry : nameToRunnerMap.entrySet()) {
-        final String name = entry.getKey();
-        final ComparatorRunner runner = entry.getValue();
-        // Make sure the comparator under test gives the same outcome as just comparing two longs
-        final ComparatorTest.ComparatorResult result = get(runner.compare(long1, long2));
-        final ComparatorTest.ComparatorResult expectedResult = get(Long.compare(long1, long2));
-
-        assertThat(result)
-            .withFailMessage(() -> "Compare mismatch for " + name + " - long1: " + long1
-                + ", long2: " + long2
-                + ", expected: " + expectedResult
-                + ", actual: " + result)
-            .isEqualTo(expectedResult);
-
-        final ComparatorTest.ComparatorResult result2 = get(runner.compare(long2, long1));
-        final ComparatorTest.ComparatorResult expectedResult2 = expectedResult.opposite();
-
-        assertThat(result)
-            .withFailMessage(() -> "Compare mismatch for " + name + " - long2: " + long2
-                + ", long1: " + long1
-                + ", expected2: " + expectedResult2
-                + ", actual2: " + result2)
-            .isEqualTo(expectedResult);
-      }
+      // Make sure the comparator under test gives the same outcome as just comparing two longs
+      final ComparatorTest.ComparatorResult result = get(runner.compare(long1, long2));
+      final ComparatorTest.ComparatorResult expectedResult = get(Long.compare(long1, long2));
+
+      assertThat(result)
+          .withFailMessage(() -> "Compare mismatch - long1: " + long1
+              + ", long2: " + long2
+              + ", expected: " + expectedResult
+              + ", actual: " + result)
+          .isEqualTo(expectedResult);
+
+      final ComparatorTest.ComparatorResult result2 = get(runner.compare(long2, long1));
+      final ComparatorTest.ComparatorResult expectedResult2 = expectedResult.opposite();
+
+      assertThat(result)
+          .withFailMessage(() -> "Compare mismatch for - long2: " + long2
+              + ", long1: " + long1
+              + ", expected2: " + expectedResult2
+              + ", actual2: " + result2)
+          .isEqualTo(expectedResult);
     }
   }
 
-  @Test
-  void testRandomInt() {
+  @ParameterizedTest
+  @MethodSource("comparatorProvider")
+  void testRandomInt(final ComparatorRunner runner) {
     final Random random = new Random(3239480);
-    final Map<String, ComparatorRunner> nameToRunnerMap = new LinkedHashMap<>();
-    nameToRunnerMap.put("DirectBufferRunner", new DirectBufferRunner());
-    nameToRunnerMap.put("ByteBufferRunner", new ByteBufferRunner());
-    nameToRunnerMap.put("NettyRunner", new NettyRunner());
 
     // 5mil random ints to compare
     final int[] values = random.ints()
@@ -159,30 +146,26 @@ void testRandomInt() {
     for (int i = 1; i < values.length; i++) {
       final int int1 = values[i - 1];
       final int int2 = values[i];
-      for (Map.Entry<String, ComparatorRunner> entry : nameToRunnerMap.entrySet()) {
-        final String name = entry.getKey();
-        final ComparatorRunner runner = entry.getValue();
-        // Make sure the comparator under test gives the same outcome as just comparing two ints
-        final ComparatorTest.ComparatorResult result = get(runner.compare(int1, int2));
-        final ComparatorTest.ComparatorResult expectedResult = get(Integer.compare(int1, int2));
-
-        assertThat(result)
-            .withFailMessage(() -> "Compare mismatch for " + name + " - int1: " + int1
-                + ", int2: " + int2
-                + ", expected: " + expectedResult
-                + ", actual: " + result)
-            .isEqualTo(expectedResult);
-
-        final ComparatorTest.ComparatorResult result2 = get(runner.compare(int2, int1));
-        final ComparatorTest.ComparatorResult expectedResult2 = expectedResult.opposite();
-
-        assertThat(result)
-            .withFailMessage(() -> "Compare mismatch for " + name + " - int2: " + int2
-                + ", int1: " + int1
-                + ", expected2: " + expectedResult2
-                + ", actual2: " + result2)
-            .isEqualTo(expectedResult);
-      }
+      // Make sure the comparator under test gives the same outcome as just comparing two ints
+      final ComparatorTest.ComparatorResult result = get(runner.compare(int1, int2));
+      final ComparatorTest.ComparatorResult expectedResult = get(Integer.compare(int1, int2));
+
+      assertThat(result)
+          .withFailMessage(() -> "Compare mismatch for - int1: " + int1
+              + ", int2: " + int2
+              + ", expected: " + expectedResult
+              + ", actual: " + result)
+          .isEqualTo(expectedResult);
+
+      final ComparatorTest.ComparatorResult result2 = get(runner.compare(int2, int1));
+      final ComparatorTest.ComparatorResult expectedResult2 = expectedResult.opposite();
+
+      assertThat(result)
+          .withFailMessage(() -> "Compare mismatch for - int2: " + int2
+              + ", int1: " + int1
+              + ", expected2: " + expectedResult2
+              + ", actual2: " + result2)
+          .isEqualTo(expectedResult);
     }
   }
 
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
index 393065a3..775ac4bc 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
@@ -557,13 +557,13 @@ public Stream<? extends Arguments> provideArguments(ParameterDeclarations parame
       final DbiFactory callbackComparatorDb = new DbiFactory("callbackComparator", env ->
           env.buildDbi()
               .setDbName(DB_3)
-              .withCallbackComparator(buildComparator())
+              .withCallbackComparator(MyArgumentProvider::buildComparator)
               .setDbiFlags(DBI_FLAGS)
               .open());
       final DbiFactory iteratorComparatorDb = new DbiFactory("iteratorComparator", env ->
           env.buildDbi()
               .setDbName(DB_4)
-              .withIteratorComparator(buildComparator())
+              .withIteratorComparator(MyArgumentProvider::buildComparator)
               .setDbiFlags(DBI_FLAGS)
               .open());
       return Stream.of(
@@ -574,7 +574,7 @@ public Stream<? extends Arguments> provideArguments(ParameterDeclarations parame
           .map(Arguments::of);
     }
 
-    private static Comparator<ByteBuffer> buildComparator() {
+    private static Comparator<ByteBuffer> buildComparator(final DbiFlagSet dbiFlagSet) {
       final Comparator<ByteBuffer> baseComparator = BUFFER_PROXY.getComparator(DBI_FLAGS);
       return (o1, o2) -> {
         if (o1.remaining() != o2.remaining()) {
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
index aa23235a..a0d9ab0c 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
@@ -611,18 +611,16 @@ public Stream<? extends Arguments> provideArguments(ParameterDeclarations parame
               .withNativeComparator()
               .setDbiFlags(DBI_FLAGS)
               .open());
-      final Comparator<ByteBuffer> comparator = buildComparator();
-
       final DbiFactory callbackComparatorDb = new DbiFactory("callbackComparator", env ->
           env.buildDbi()
               .setDbName(DB_3)
-              .withCallbackComparator(comparator)
+              .withCallbackComparator(MyArgumentProvider::buildComparator)
               .setDbiFlags(DBI_FLAGS)
               .open());
       final DbiFactory iteratorComparatorDb = new DbiFactory("iteratorComparator", env ->
           env.buildDbi()
               .setDbName(DB_4)
-              .withIteratorComparator(comparator)
+              .withIteratorComparator(MyArgumentProvider::buildComparator)
               .setDbiFlags(DBI_FLAGS)
               .open());
       return Stream.of(
@@ -633,7 +631,7 @@ public Stream<? extends Arguments> provideArguments(ParameterDeclarations parame
           .map(Arguments::of);
     }
 
-    private static Comparator<ByteBuffer> buildComparator() {
+    private static Comparator<ByteBuffer> buildComparator(final DbiFlagSet dbiFlagSet) {
       final Comparator<ByteBuffer> baseComparator = BUFFER_PROXY.getComparator(DBI_FLAGS);
       return (o1, o2) -> {
         if (o1.remaining() != o2.remaining()) {
diff --git a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
index 008695fd..e0a40fd9 100644
--- a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
@@ -79,7 +79,7 @@ public void before() throws IOException {
     // Use a java comparator for start/stop keys and as a callback comparator
     dbCallbackComparator = env.buildDbi()
         .setDbName("CallBackComparator")
-        .withCallbackComparator(bufferProxy.getComparator(dbiFlagSet))
+        .withCallbackComparator(bufferProxy::getComparator)
         .setDbiFlags(dbiFlagSet)
         .open();
 
diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index 0286fa88..e48f1e69 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -83,7 +83,6 @@ public final class CursorIterableTest {
   private static final BufferProxy<ByteBuffer> BUFFER_PROXY = ByteBufferProxy.PROXY_OPTIMAL;
 
   private Path file;
-  private Dbi<ByteBuffer> db;
   private Env<ByteBuffer> env;
   private Deque<Integer> list;
 
@@ -309,7 +308,11 @@ void openClosedBackwardTestWithGuava() {
           bb2.reset();
           return guava.compare(array1, array2);
         };
-    final Dbi<ByteBuffer> guavaDbi = env.openDbi(DB_1, comparator, MDB_CREATE);
+    final Dbi<ByteBuffer> guavaDbi = env.buildDbi()
+        .setDbName(DB_1)
+        .withDefaultComparator()
+        .setDbiFlags(MDB_CREATE)
+        .open();
     populateDatabase(guavaDbi);
     verify(openClosedBackward(bb(7), bb(2)), guavaDbi, 6, 4, 2);
     verify(openClosedBackward(bb(8), bb(4)), guavaDbi, 6, 4);
@@ -548,13 +551,13 @@ public Stream<? extends Arguments> provideArguments(ParameterDeclarations parame
       final DbiFactory callbackComparatorDb = new DbiFactory("callbackComparator", env ->
           env.buildDbi()
               .setDbName(DB_3)
-              .withCallbackComparator(BUFFER_PROXY.getComparator(DBI_FLAGS))
+              .withCallbackComparator(BUFFER_PROXY::getComparator)
               .setDbiFlags(DBI_FLAGS)
               .open());
       final DbiFactory iteratorComparatorDb = new DbiFactory("iteratorComparator", env ->
           env.buildDbi()
               .setDbName(DB_4)
-              .withIteratorComparator(BUFFER_PROXY.getComparator(DBI_FLAGS))
+              .withIteratorComparator(BUFFER_PROXY::getComparator)
               .setDbiFlags(DBI_FLAGS)
               .open());
       return Stream.of(
diff --git a/src/test/java/org/lmdbjava/DbiBuilderTest.java b/src/test/java/org/lmdbjava/DbiBuilderTest.java
index 25e622bf..d01f6417 100644
--- a/src/test/java/org/lmdbjava/DbiBuilderTest.java
+++ b/src/test/java/org/lmdbjava/DbiBuilderTest.java
@@ -133,7 +133,7 @@ public void callback() {
 
     final Dbi<ByteBuffer> dbi = env.buildDbi()
         .setDbName("foo")
-        .withCallbackComparator(comparator)
+        .withCallbackComparator(ignored -> comparator)
         .addDbiFlags(DbiFlags.MDB_CREATE)
         .open();
 

From 69eb5b742dcaad89275c9896bc05366a62374101 Mon Sep 17 00:00:00 2001
From: stroomdev66 <stroomdev66@gmail.com>
Date: Wed, 5 Nov 2025 17:01:14 +0000
Subject: [PATCH 254/322] #269 Initial iterator performance enhancements and
 testing.

---
 .../org/lmdbjava/CursorIterableRangeTest.java |  40 +++----
 .../CursorIterableRangeTest/testLongKey.csv   | 108 +++++++++---------
 2 files changed, 74 insertions(+), 74 deletions(-)

diff --git a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
index 0802c047..f0471bab 100644
--- a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
@@ -123,7 +123,7 @@ void testIntegerKey(
         stopKey,
         expectedKV,
         Integer.BYTES,
-        ByteOrder.LITTLE_ENDIAN);
+        ByteOrder.nativeOrder());
   }
 
   @ParameterizedTest(name = "{index} => {0}: ({1}, {2})")
@@ -140,7 +140,7 @@ void testLongKey(
         stopKey,
         expectedKV,
         Long.BYTES,
-        ByteOrder.LITTLE_ENDIAN);
+        ByteOrder.nativeOrder());
   }
 
   private void testCSV(
@@ -197,7 +197,7 @@ private void testCSV(
               CursorIterable<ByteBuffer> c = dbi.iterate(txn, keyRange)) {
             for (final KeyVal<ByteBuffer> kv : c) {
               final long key = getLong(kv.key(), byteOrder);
-              final long val = getLong(kv.val(), byteOrder);
+              final long val = getLong(kv.val(), ByteOrder.BIG_ENDIAN);
               writer.append("[");
               writer.append(String.valueOf(key));
               writer.append(" ");
@@ -215,11 +215,11 @@ private void testCSV(
 
   private ByteBuffer parseKey(final String key, final int keyLen, final ByteOrder byteOrder) {
     if (key != null) {
-      if (ByteOrder.LITTLE_ENDIAN.equals(byteOrder)) {
+      if (ByteOrder.nativeOrder().equals(byteOrder)) {
         if (keyLen == Integer.BYTES) {
-          return bbLeInt(Integer.parseInt(key.trim()));
+          return bbNativeInt(Integer.parseInt(key.trim()));
         } else {
-          return bbLeLong(Long.parseLong(key.trim()));
+          return bbNativeLong(Long.parseLong(key.trim()));
         }
       } else {
         if (keyLen == Integer.BYTES) {
@@ -277,11 +277,11 @@ private BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> createIntegerDBPopulator()
     return (env, dbi) -> {
       try (Txn<ByteBuffer> txn = env.txnWrite()) {
         final Cursor<ByteBuffer> c = dbi.openCursor(txn);
-        c.put(bbLeInt(Integer.MIN_VALUE), bb(1));
-        c.put(bbLeInt(-1000), bb(2));
-        c.put(bbLeInt(0), bb(3));
-        c.put(bbLeInt(1000), bb(4));
-        c.put(bbLeInt(Integer.MAX_VALUE), bb(5));
+        c.put(bbNativeInt(0), bb(1));
+        c.put(bbNativeInt(1000), bb(2));
+        c.put(bbNativeInt(1000000), bb(3));
+        c.put(bbNativeInt(-1000000), bb(4));
+        c.put(bbNativeInt(-1000), bb(5));
         txn.commit();
       }
     };
@@ -291,11 +291,11 @@ private BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> createLongDBPopulator() {
     return (env, dbi) -> {
       try (Txn<ByteBuffer> txn = env.txnWrite()) {
         final Cursor<ByteBuffer> c = dbi.openCursor(txn);
-        c.put(bbLeLong(Long.MIN_VALUE), bb(1));
-        c.put(bbLeLong(-1000), bb(2));
-        c.put(bbLeLong(0), bb(3));
-        c.put(bbLeLong(1000), bb(4));
-        c.put(bbLeLong(Long.MAX_VALUE), bb(5));
+        c.put(bbNativeLong(0), bb(1));
+        c.put(bbNativeLong(1000), bb(2));
+        c.put(bbNativeLong(1000000), bb(3));
+        c.put(bbNativeLong(-1000000), bb(4));
+        c.put(bbNativeLong(-1000), bb(5));
         txn.commit();
       }
     };
@@ -329,14 +329,14 @@ private String readFile(final File file) throws IOException {
     return result.toString();
   }
 
-  static ByteBuffer bbLeInt(final int value) {
-    final ByteBuffer bb = allocateDirect(Integer.BYTES).order(ByteOrder.LITTLE_ENDIAN);
+  static ByteBuffer bbNativeInt(final int value) {
+    final ByteBuffer bb = allocateDirect(Integer.BYTES).order(ByteOrder.nativeOrder());
     bb.putInt(value).flip();
     return bb;
   }
 
-  static ByteBuffer bbLeLong(final long value) {
-    final ByteBuffer bb = allocateDirect(Long.BYTES).order(ByteOrder.LITTLE_ENDIAN);
+  static ByteBuffer bbNativeLong(final long value) {
+    final ByteBuffer bb = allocateDirect(Long.BYTES).order(ByteOrder.nativeOrder());
     bb.putLong(value).flip();
     return bb;
   }
diff --git a/src/test/resources/CursorIterableRangeTest/testLongKey.csv b/src/test/resources/CursorIterableRangeTest/testLongKey.csv
index f3504662..d8d6dc35 100644
--- a/src/test/resources/CursorIterableRangeTest/testLongKey.csv
+++ b/src/test/resources/CursorIterableRangeTest/testLongKey.csv
@@ -1,55 +1,55 @@
-FORWARD_ALL,,,[0 50331648][1000 67108864][9223372036854775807 83886080][-9223372036854775808 16777216][-1000 33554432]
-FORWARD_AT_LEAST,999,,[1000 67108864][9223372036854775807 83886080][-9223372036854775808 16777216][-1000 33554432]
-FORWARD_AT_LEAST,1000,,[1000 67108864][9223372036854775807 83886080][-9223372036854775808 16777216][-1000 33554432]
-FORWARD_AT_LEAST,1001,,[9223372036854775807 83886080][-9223372036854775808 16777216][-1000 33554432]
-FORWARD_AT_MOST,,999,[0 50331648]
-FORWARD_AT_MOST,,1000,[0 50331648][1000 67108864]
-FORWARD_AT_MOST,,1001,[0 50331648][1000 67108864]
-FORWARD_CLOSED,999,1001,[1000 67108864]
-FORWARD_CLOSED,1000,1000,[1000 67108864]
-FORWARD_CLOSED_OPEN,999,1001,[1000 67108864]
+FORWARD_ALL,,,[0 1][1000 2][1000000 3][-1000000 4][-1000 5]
+FORWARD_AT_LEAST,999,,[1000 2][1000000 3][-1000000 4][-1000 5]
+FORWARD_AT_LEAST,1000,,[1000 2][1000000 3][-1000000 4][-1000 5]
+FORWARD_AT_LEAST,1001,,[1000000 3][-1000000 4][-1000 5]
+FORWARD_AT_MOST,,999,[0 1]
+FORWARD_AT_MOST,,1000,[0 1][1000 2]
+FORWARD_AT_MOST,,1001,[0 1][1000 2]
+FORWARD_CLOSED,999,1001,[1000 2]
+FORWARD_CLOSED,1000,1000,[1000 2]
+FORWARD_CLOSED_OPEN,999,1001,[1000 2]
 FORWARD_CLOSED_OPEN,1000,1000,
-FORWARD_CLOSED_OPEN,1000,1001,[1000 67108864]
-FORWARD_GREATER_THAN,999,,[1000 67108864][9223372036854775807 83886080][-9223372036854775808 16777216][-1000 33554432]
-FORWARD_GREATER_THAN,1000,,[9223372036854775807 83886080][-9223372036854775808 16777216][-1000 33554432]
-FORWARD_GREATER_THAN,1001,,[9223372036854775807 83886080][-9223372036854775808 16777216][-1000 33554432]
-FORWARD_LESS_THAN,,999,[0 50331648]
-FORWARD_LESS_THAN,,1000,[0 50331648]
-FORWARD_LESS_THAN,,1001,[0 50331648][1000 67108864]
-
-
-#FORWARD_OPEN,3,7,[4 5][6 7]
-#FORWARD_OPEN,2,8,[4 5][6 7]
-#FORWARD_OPEN_CLOSED,3,8,[4 5][6 7][8 9]
-#FORWARD_OPEN_CLOSED,2,6,[4 5][6 7]
-#BACKWARD_ALL,,,[-2 -1][8 9][6 7][4 5][2 3][0 1]
-#BACKWARD_AT_LEAST,5,,[4 5][2 3][0 1]
-#BACKWARD_AT_LEAST,6,,[6 7][4 5][2 3][0 1]
-#BACKWARD_AT_LEAST,9,,[8 9][6 7][4 5][2 3][0 1]
-#BACKWARD_AT_LEAST,-1,,[-2 -1][8 9][6 7][4 5][2 3][0 1]
-#BACKWARD_AT_MOST,,5,[-2 -1][8 9][6 7]
-#BACKWARD_AT_MOST,,6,[-2 -1][8 9][6 7]
-#BACKWARD_AT_MOST,,-1,
-#BACKWARD_CLOSED,7,3,[6 7][4 5]
-#BACKWARD_CLOSED,6,2,[6 7][4 5][2 3]
-#BACKWARD_CLOSED,9,3,[8 9][6 7][4 5]
-#BACKWARD_CLOSED,9,-1,
-#BACKWARD_CLOSED_OPEN,8,3,[8 9][6 7][4 5]
-#BACKWARD_CLOSED_OPEN,7,2,[6 7][4 5]
-#BACKWARD_CLOSED_OPEN,9,3,[8 9][6 7][4 5]
-#BACKWARD_CLOSED_OPEN,9,-1,
-#BACKWARD_GREATER_THAN,6,,[4 5][2 3][0 1]
-#BACKWARD_GREATER_THAN,7,,[6 7][4 5][2 3][0 1]
-#BACKWARD_GREATER_THAN,9,,[8 9][6 7][4 5][2 3][0 1]
-#BACKWARD_GREATER_THAN,-1,,[-2 -1][8 9][6 7][4 5][2 3][0 1]
-#BACKWARD_LESS_THAN,,5,[-2 -1][8 9][6 7]
-#BACKWARD_LESS_THAN,,2,[-2 -1][8 9][6 7][4 5]
-#BACKWARD_LESS_THAN,,-1,
-#BACKWARD_OPEN,7,2,[6 7][4 5]
-#BACKWARD_OPEN,8,1,[6 7][4 5][2 3]
-#BACKWARD_OPEN,9,4,[8 9][6 7]
-#BACKWARD_OPEN,9,-1,
-#BACKWARD_OPEN_CLOSED,7,2,[6 7][4 5][2 3]
-#BACKWARD_OPEN_CLOSED,8,4,[6 7][4 5]
-#BACKWARD_OPEN_CLOSED,9,4,[8 9][6 7][4 5]
-#BACKWARD_OPEN_CLOSED,9,-1,
+FORWARD_CLOSED_OPEN,1000,1001,[1000 2]
+FORWARD_GREATER_THAN,999,,[1000 2][1000000 3][-1000000 4][-1000 5]
+FORWARD_GREATER_THAN,1000,,[1000000 3][-1000000 4][-1000 5]
+FORWARD_GREATER_THAN,1001,,[1000000 3][-1000000 4][-1000 5]
+FORWARD_LESS_THAN,,999,[0 1]
+FORWARD_LESS_THAN,,1000,[0 1]
+FORWARD_LESS_THAN,,1001,[0 1][1000 2]
+FORWARD_OPEN,999,1001,[1000 2]
+FORWARD_OPEN,999,1000,
+FORWARD_OPEN,1000,1000,
+FORWARD_OPEN,1000,1001,
+FORWARD_OPEN_CLOSED,999,1001,[1000 2]
+FORWARD_OPEN_CLOSED,999,1000,[1000 2]
+FORWARD_OPEN_CLOSED,1000,1000,
+FORWARD_OPEN_CLOSED,1000,1001,
+BACKWARD_ALL,,,[-1000 5][-1000000 4][1000000 3][1000 2][0 1]
+BACKWARD_AT_LEAST,999,,[0 1]
+BACKWARD_AT_LEAST,1000,,[1000 2][0 1]
+BACKWARD_AT_LEAST,1001,,[1000 2][0 1]
+BACKWARD_AT_MOST,,999,[-1000 5][-1000000 4][1000000 3][1000 2]
+BACKWARD_AT_MOST,,1000,[-1000 5][-1000000 4][1000000 3][1000 2]
+BACKWARD_AT_MOST,,1001,[-1000 5][-1000000 4][1000000 3]
+BACKWARD_CLOSED,1001,999,[1000 2]
+BACKWARD_CLOSED,1000,1000,[1000 2]
+BACKWARD_CLOSED_OPEN,1001,999,[1000 2]
+BACKWARD_CLOSED_OPEN,1000,999,[1000 2]
+BACKWARD_CLOSED_OPEN,1000,1000,
+BACKWARD_CLOSED_OPEN,1001,1000,
+BACKWARD_GREATER_THAN,999,,[0 1]
+BACKWARD_GREATER_THAN,1000,,[0 1]
+BACKWARD_GREATER_THAN,1001,,[1000 2][0 1]
+BACKWARD_LESS_THAN,,999,[-1000 5][-1000000 4][1000000 3][1000 2]
+BACKWARD_LESS_THAN,,1000,[-1000 5][-1000000 4][1000000 3]
+BACKWARD_LESS_THAN,,1001,[-1000 5][-1000000 4][1000000 3]
+BACKWARD_OPEN,999,1001,[1000 2]
+BACKWARD_OPEN,999,1000,
+BACKWARD_OPEN,999,1001,[1000 2]
+BACKWARD_OPEN,1000,1000,
+BACKWARD_OPEN,1000,1001,
+BACKWARD_OPEN_CLOSED,999,1001,[1000 2]
+BACKWARD_OPEN_CLOSED,999,1000,[1000 2]
+BACKWARD_OPEN_CLOSED,1000,1000,
+BACKWARD_OPEN_CLOSED,1000,1001,
+BACKWARD_OPEN_CLOSED,1000,1001,

From 915edce19bdb9e30d719fdd9af0906df25723ec4 Mon Sep 17 00:00:00 2001
From: stroomdev66 <stroomdev66@gmail.com>
Date: Wed, 5 Nov 2025 17:01:55 +0000
Subject: [PATCH 255/322] #269 Initial iterator performance enhancements and
 testing.

---
 .../testIntegerKey.csv                        | 104 +++++++++---------
 1 file changed, 55 insertions(+), 49 deletions(-)

diff --git a/src/test/resources/CursorIterableRangeTest/testIntegerKey.csv b/src/test/resources/CursorIterableRangeTest/testIntegerKey.csv
index ceda992a..d8d6dc35 100644
--- a/src/test/resources/CursorIterableRangeTest/testIntegerKey.csv
+++ b/src/test/resources/CursorIterableRangeTest/testIntegerKey.csv
@@ -1,49 +1,55 @@
-FORWARD_ALL,,,[0 50331648][1000 67108864][2147483647 83886080][-2147483648 16777216][-1000 33554432]
-#FORWARD_AT_LEAST,5,,[1000 67108864][2147483647 83886080][-2147483648 16777216][-1000 33554432]
-#FORWARD_AT_LEAST,6,,[1000 67108864][2147483647 83886080][-2147483648 16777216][-1000 33554432]
-#FORWARD_AT_MOST,,5,[0 50331648]
-#FORWARD_AT_MOST,,2147483647,[0 50331648]
-#FORWARD_CLOSED,3,7,
-#FORWARD_CLOSED,2,6,
-#FORWARD_CLOSED,1,7,
-#FORWARD_CLOSED_OPEN,3,8,[4 5][6 7]
-#FORWARD_CLOSED_OPEN,2,6,[2 3][4 5]
-#FORWARD_GREATER_THAN,4,,[6 7][8 9][-2 -1]
-#FORWARD_GREATER_THAN,3,,[4 5][6 7][8 9][-2 -1]
-#FORWARD_LESS_THAN,,5,[0 1][2 3][4 5]
-#FORWARD_LESS_THAN,,8,[0 1][2 3][4 5][6 7]
-#FORWARD_OPEN,3,7,[4 5][6 7]
-#FORWARD_OPEN,2,8,[4 5][6 7]
-#FORWARD_OPEN_CLOSED,3,8,[4 5][6 7][8 9]
-#FORWARD_OPEN_CLOSED,2,6,[4 5][6 7]
-#BACKWARD_ALL,,,[-2 -1][8 9][6 7][4 5][2 3][0 1]
-#BACKWARD_AT_LEAST,5,,[4 5][2 3][0 1]
-#BACKWARD_AT_LEAST,6,,[6 7][4 5][2 3][0 1]
-#BACKWARD_AT_LEAST,9,,[8 9][6 7][4 5][2 3][0 1]
-#BACKWARD_AT_LEAST,-1,,[-2 -1][8 9][6 7][4 5][2 3][0 1]
-#BACKWARD_AT_MOST,,5,[-2 -1][8 9][6 7]
-#BACKWARD_AT_MOST,,6,[-2 -1][8 9][6 7]
-#BACKWARD_AT_MOST,,-1,
-#BACKWARD_CLOSED,7,3,[6 7][4 5]
-#BACKWARD_CLOSED,6,2,[6 7][4 5][2 3]
-#BACKWARD_CLOSED,9,3,[8 9][6 7][4 5]
-#BACKWARD_CLOSED,9,-1,
-#BACKWARD_CLOSED_OPEN,8,3,[8 9][6 7][4 5]
-#BACKWARD_CLOSED_OPEN,7,2,[6 7][4 5]
-#BACKWARD_CLOSED_OPEN,9,3,[8 9][6 7][4 5]
-#BACKWARD_CLOSED_OPEN,9,-1,
-#BACKWARD_GREATER_THAN,6,,[4 5][2 3][0 1]
-#BACKWARD_GREATER_THAN,7,,[6 7][4 5][2 3][0 1]
-#BACKWARD_GREATER_THAN,9,,[8 9][6 7][4 5][2 3][0 1]
-#BACKWARD_GREATER_THAN,-1,,[-2 -1][8 9][6 7][4 5][2 3][0 1]
-#BACKWARD_LESS_THAN,,5,[-2 -1][8 9][6 7]
-#BACKWARD_LESS_THAN,,2,[-2 -1][8 9][6 7][4 5]
-#BACKWARD_LESS_THAN,,-1,
-#BACKWARD_OPEN,7,2,[6 7][4 5]
-#BACKWARD_OPEN,8,1,[6 7][4 5][2 3]
-#BACKWARD_OPEN,9,4,[8 9][6 7]
-#BACKWARD_OPEN,9,-1,
-#BACKWARD_OPEN_CLOSED,7,2,[6 7][4 5][2 3]
-#BACKWARD_OPEN_CLOSED,8,4,[6 7][4 5]
-#BACKWARD_OPEN_CLOSED,9,4,[8 9][6 7][4 5]
-#BACKWARD_OPEN_CLOSED,9,-1,
+FORWARD_ALL,,,[0 1][1000 2][1000000 3][-1000000 4][-1000 5]
+FORWARD_AT_LEAST,999,,[1000 2][1000000 3][-1000000 4][-1000 5]
+FORWARD_AT_LEAST,1000,,[1000 2][1000000 3][-1000000 4][-1000 5]
+FORWARD_AT_LEAST,1001,,[1000000 3][-1000000 4][-1000 5]
+FORWARD_AT_MOST,,999,[0 1]
+FORWARD_AT_MOST,,1000,[0 1][1000 2]
+FORWARD_AT_MOST,,1001,[0 1][1000 2]
+FORWARD_CLOSED,999,1001,[1000 2]
+FORWARD_CLOSED,1000,1000,[1000 2]
+FORWARD_CLOSED_OPEN,999,1001,[1000 2]
+FORWARD_CLOSED_OPEN,1000,1000,
+FORWARD_CLOSED_OPEN,1000,1001,[1000 2]
+FORWARD_GREATER_THAN,999,,[1000 2][1000000 3][-1000000 4][-1000 5]
+FORWARD_GREATER_THAN,1000,,[1000000 3][-1000000 4][-1000 5]
+FORWARD_GREATER_THAN,1001,,[1000000 3][-1000000 4][-1000 5]
+FORWARD_LESS_THAN,,999,[0 1]
+FORWARD_LESS_THAN,,1000,[0 1]
+FORWARD_LESS_THAN,,1001,[0 1][1000 2]
+FORWARD_OPEN,999,1001,[1000 2]
+FORWARD_OPEN,999,1000,
+FORWARD_OPEN,1000,1000,
+FORWARD_OPEN,1000,1001,
+FORWARD_OPEN_CLOSED,999,1001,[1000 2]
+FORWARD_OPEN_CLOSED,999,1000,[1000 2]
+FORWARD_OPEN_CLOSED,1000,1000,
+FORWARD_OPEN_CLOSED,1000,1001,
+BACKWARD_ALL,,,[-1000 5][-1000000 4][1000000 3][1000 2][0 1]
+BACKWARD_AT_LEAST,999,,[0 1]
+BACKWARD_AT_LEAST,1000,,[1000 2][0 1]
+BACKWARD_AT_LEAST,1001,,[1000 2][0 1]
+BACKWARD_AT_MOST,,999,[-1000 5][-1000000 4][1000000 3][1000 2]
+BACKWARD_AT_MOST,,1000,[-1000 5][-1000000 4][1000000 3][1000 2]
+BACKWARD_AT_MOST,,1001,[-1000 5][-1000000 4][1000000 3]
+BACKWARD_CLOSED,1001,999,[1000 2]
+BACKWARD_CLOSED,1000,1000,[1000 2]
+BACKWARD_CLOSED_OPEN,1001,999,[1000 2]
+BACKWARD_CLOSED_OPEN,1000,999,[1000 2]
+BACKWARD_CLOSED_OPEN,1000,1000,
+BACKWARD_CLOSED_OPEN,1001,1000,
+BACKWARD_GREATER_THAN,999,,[0 1]
+BACKWARD_GREATER_THAN,1000,,[0 1]
+BACKWARD_GREATER_THAN,1001,,[1000 2][0 1]
+BACKWARD_LESS_THAN,,999,[-1000 5][-1000000 4][1000000 3][1000 2]
+BACKWARD_LESS_THAN,,1000,[-1000 5][-1000000 4][1000000 3]
+BACKWARD_LESS_THAN,,1001,[-1000 5][-1000000 4][1000000 3]
+BACKWARD_OPEN,999,1001,[1000 2]
+BACKWARD_OPEN,999,1000,
+BACKWARD_OPEN,999,1001,[1000 2]
+BACKWARD_OPEN,1000,1000,
+BACKWARD_OPEN,1000,1001,
+BACKWARD_OPEN_CLOSED,999,1001,[1000 2]
+BACKWARD_OPEN_CLOSED,999,1000,[1000 2]
+BACKWARD_OPEN_CLOSED,1000,1000,
+BACKWARD_OPEN_CLOSED,1000,1001,
+BACKWARD_OPEN_CLOSED,1000,1001,

From 5a62965505ee651bd5a89dbae8c1173a522dd521 Mon Sep 17 00:00:00 2001
From: stroomdev66 <stroomdev66@gmail.com>
Date: Wed, 5 Nov 2025 18:24:10 +0000
Subject: [PATCH 256/322] Merged new comparator code

---
 .../java/org/lmdbjava/AbstractFlagSet.java    | 359 ++++++++++
 src/main/java/org/lmdbjava/BufferProxy.java   |  37 +-
 .../java/org/lmdbjava/ByteArrayProxy.java     |  34 +-
 src/main/java/org/lmdbjava/ByteBufProxy.java  |  86 ++-
 .../java/org/lmdbjava/ByteBufferProxy.java    |  83 ++-
 src/main/java/org/lmdbjava/CopyFlagSet.java   |  63 ++
 src/main/java/org/lmdbjava/CopyFlags.java     |  33 +-
 src/main/java/org/lmdbjava/Cursor.java        | 167 ++++-
 .../java/org/lmdbjava/CursorIterable.java     | 131 +++-
 src/main/java/org/lmdbjava/Dbi.java           | 133 +++-
 src/main/java/org/lmdbjava/DbiBuilder.java    | 426 +++++++++++
 src/main/java/org/lmdbjava/DbiFlagSet.java    |  67 ++
 src/main/java/org/lmdbjava/DbiFlags.java      |  66 +-
 .../java/org/lmdbjava/DirectBufferProxy.java  |  67 +-
 src/main/java/org/lmdbjava/Env.java           | 344 +++++++--
 src/main/java/org/lmdbjava/EnvFlagSet.java    |  63 ++
 src/main/java/org/lmdbjava/EnvFlags.java      |  30 +-
 src/main/java/org/lmdbjava/FlagSet.java       | 122 ++++
 src/main/java/org/lmdbjava/Key.java           |  72 ++
 src/main/java/org/lmdbjava/KeyRangeType.java  |  50 +-
 src/main/java/org/lmdbjava/Library.java       |   2 +
 src/main/java/org/lmdbjava/MaskedFlag.java    |  86 +--
 src/main/java/org/lmdbjava/PutFlagSet.java    |  63 ++
 src/main/java/org/lmdbjava/PutFlags.java      |  30 +-
 .../java/org/lmdbjava/RangeComparator.java    |  32 +
 src/main/java/org/lmdbjava/Txn.java           |  13 +-
 src/main/java/org/lmdbjava/TxnFlagSet.java    |  68 ++
 src/main/java/org/lmdbjava/TxnFlags.java      |  31 +-
 .../org/lmdbjava/ByteBufferProxyTest.java     | 117 +++-
 .../lmdbjava/ComparatorIntegerKeyTest.java    | 357 ++++++++++
 .../java/org/lmdbjava/ComparatorTest.java     |  12 +-
 .../java/org/lmdbjava/CopyFlagSetTest.java    |  72 ++
 .../CursorIterableIntegerDupTest.java         | 615 ++++++++++++++++
 .../CursorIterableIntegerKeyTest.java         | 662 ++++++++++++++++++
 .../org/lmdbjava/CursorIterablePerfTest.java  | 201 ++++++
 .../org/lmdbjava/CursorIterableRangeTest.java |   8 +-
 .../java/org/lmdbjava/CursorIterableTest.java | 197 +++++-
 .../java/org/lmdbjava/DbiBuilderTest.java     | 204 ++++++
 .../java/org/lmdbjava/DbiFlagSetTest.java     |  90 +++
 src/test/java/org/lmdbjava/DbiTest.java       |  13 +-
 .../java/org/lmdbjava/EnvFlagSetTest.java     |  91 +++
 src/test/java/org/lmdbjava/KeyRangeTest.java  |   5 +-
 .../java/org/lmdbjava/PutFlagSetTest.java     | 131 ++++
 src/test/java/org/lmdbjava/TestUtils.java     |  87 +++
 .../java/org/lmdbjava/TxnFlagSetTest.java     |  85 +++
 45 files changed, 5335 insertions(+), 370 deletions(-)
 create mode 100644 src/main/java/org/lmdbjava/AbstractFlagSet.java
 create mode 100644 src/main/java/org/lmdbjava/CopyFlagSet.java
 create mode 100644 src/main/java/org/lmdbjava/DbiBuilder.java
 create mode 100644 src/main/java/org/lmdbjava/DbiFlagSet.java
 create mode 100644 src/main/java/org/lmdbjava/EnvFlagSet.java
 create mode 100644 src/main/java/org/lmdbjava/FlagSet.java
 create mode 100644 src/main/java/org/lmdbjava/Key.java
 create mode 100644 src/main/java/org/lmdbjava/PutFlagSet.java
 create mode 100644 src/main/java/org/lmdbjava/RangeComparator.java
 create mode 100644 src/main/java/org/lmdbjava/TxnFlagSet.java
 create mode 100644 src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java
 create mode 100644 src/test/java/org/lmdbjava/CopyFlagSetTest.java
 create mode 100644 src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
 create mode 100644 src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
 create mode 100644 src/test/java/org/lmdbjava/CursorIterablePerfTest.java
 create mode 100644 src/test/java/org/lmdbjava/DbiBuilderTest.java
 create mode 100644 src/test/java/org/lmdbjava/DbiFlagSetTest.java
 create mode 100644 src/test/java/org/lmdbjava/EnvFlagSetTest.java
 create mode 100644 src/test/java/org/lmdbjava/PutFlagSetTest.java
 create mode 100644 src/test/java/org/lmdbjava/TxnFlagSetTest.java

diff --git a/src/main/java/org/lmdbjava/AbstractFlagSet.java b/src/main/java/org/lmdbjava/AbstractFlagSet.java
new file mode 100644
index 00000000..65f84f55
--- /dev/null
+++ b/src/main/java/org/lmdbjava/AbstractFlagSet.java
@@ -0,0 +1,359 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.Iterator;
+import java.util.Objects;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+/** Encapsulates an immutable set of flags and the associated bit mask for the flags in the set. */
+public abstract class AbstractFlagSet<T extends Enum<T> & MaskedFlag> implements FlagSet<T> {
+
+  private final Set<T> flags;
+  private final int mask;
+
+  protected AbstractFlagSet(final EnumSet<T> flags) {
+    Objects.requireNonNull(flags);
+    this.mask = MaskedFlag.mask(flags);
+    this.flags = Collections.unmodifiableSet(Objects.requireNonNull(flags));
+  }
+
+  /**
+   * @return THe combined bit mask for all flags in the set.
+   */
+  @Override
+  public int getMask() {
+    return mask;
+  }
+
+  /**
+   * @return All flags in the set.
+   */
+  @Override
+  public Set<T> getFlags() {
+    return flags;
+  }
+
+  /**
+   * @return True if flag has been set, i.e. is contained in this set.
+   */
+  @Override
+  public boolean isSet(final T flag) {
+    // Probably cheaper to compare the masks than to use EnumSet.contains()
+    return flag != null && MaskedFlag.isSet(mask, flag);
+  }
+
+  /**
+   * @return The number of flags in this set.
+   */
+  @Override
+  public int size() {
+    return flags.size();
+  }
+
+  /**
+   * @return True if this set is empty.
+   */
+  @Override
+  public boolean isEmpty() {
+    return flags.isEmpty();
+  }
+
+  /**
+   * @return The {@link Iterator} for this set.
+   */
+  @Override
+  public Iterator<T> iterator() {
+    return flags.iterator();
+  }
+
+  @Override
+  public boolean equals(Object object) {
+    return FlagSet.equals(this, object);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(flags, mask);
+  }
+
+  @Override
+  public String toString() {
+    return FlagSet.asString(this);
+  }
+
+  // --------------------------------------------------------------------------------
+
+  abstract static class AbstractSingleFlagSet<T extends Enum<T> & MaskedFlag>
+      implements FlagSet<T> {
+
+    private final T flag;
+    // Only holding this for iterator() and getFlags() so make it lazy.
+    private EnumSet<T> enumSet;
+
+    public AbstractSingleFlagSet(final T flag) {
+      this.flag = Objects.requireNonNull(flag);
+    }
+
+    @Override
+    public int getMask() {
+      return flag.getMask();
+    }
+
+    @Override
+    public Set<T> getFlags() {
+      if (enumSet == null) {
+        return initSet();
+      } else {
+        return this.enumSet;
+      }
+    }
+
+    @Override
+    public boolean isSet(final T flag) {
+      return this.flag == flag;
+    }
+
+    @Override
+    public boolean areAnySet(FlagSet<T> flags) {
+      if (flags == null) {
+        return false;
+      } else {
+        return flags.isSet(this.flag);
+      }
+    }
+
+    @Override
+    public int size() {
+      return 1;
+    }
+
+    @Override
+    public boolean isEmpty() {
+      return false;
+    }
+
+    @Override
+    public Iterator<T> iterator() {
+      if (enumSet == null) {
+        return initSet().iterator();
+      } else {
+        return this.enumSet.iterator();
+      }
+    }
+
+    @Override
+    public String toString() {
+      return FlagSet.asString(this);
+    }
+
+    @Override
+    public boolean equals(Object object) {
+      return FlagSet.equals(this, object);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(flag, getFlags());
+    }
+
+    private Set<T> initSet() {
+      final EnumSet<T> set = EnumSet.of(this.flag);
+      this.enumSet = set;
+      return set;
+    }
+  }
+
+  // --------------------------------------------------------------------------------
+
+  static class AbstractEmptyFlagSet<T extends MaskedFlag> implements FlagSet<T> {
+
+    @Override
+    public int getMask() {
+      return MaskedFlag.EMPTY_MASK;
+    }
+
+    @Override
+    public Set<T> getFlags() {
+      return Collections.emptySet();
+    }
+
+    @Override
+    public boolean isSet(final T flag) {
+      return false;
+    }
+
+    @Override
+    public boolean areAnySet(final FlagSet<T> flags) {
+      return false;
+    }
+
+    @Override
+    public int size() {
+      return 0;
+    }
+
+    @Override
+    public boolean isEmpty() {
+      return true;
+    }
+
+    @Override
+    public Iterator<T> iterator() {
+      return Collections.emptyIterator();
+    }
+
+    @Override
+    public String toString() {
+      return FlagSet.asString(this);
+    }
+
+    @Override
+    public boolean equals(Object object) {
+      return FlagSet.equals(this, object);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(getMask(), getFlags());
+    }
+  }
+
+  // --------------------------------------------------------------------------------
+
+  /**
+   * A builder for creating a {@link AbstractFlagSet}.
+   *
+   * @param <E> The type of flag to be held in the {@link AbstractFlagSet}
+   * @param <S> The type of the {@link AbstractFlagSet} implementation.
+   */
+  public static class Builder<E extends Enum<E> & MaskedFlag, S extends FlagSet<E>> {
+
+    final Class<E> type;
+    final EnumSet<E> enumSet;
+    final Function<EnumSet<E>, S> constructor;
+    final Function<E, S> singletonSetConstructor;
+    final Supplier<S> emptySetSupplier;
+
+    protected Builder(
+        final Class<E> type,
+        final Function<EnumSet<E>, S> constructor,
+        final Function<E, S> singletonSetConstructor,
+        final Supplier<S> emptySetSupplier) {
+      this.type = type;
+      this.enumSet = EnumSet.noneOf(type);
+      this.constructor = Objects.requireNonNull(constructor);
+      this.singletonSetConstructor = Objects.requireNonNull(singletonSetConstructor);
+      this.emptySetSupplier = Objects.requireNonNull(emptySetSupplier);
+    }
+
+    /**
+     * Replaces any flags already set in the builder with the contents of the passed flags {@link
+     * Collection}
+     *
+     * @param flags The flags to set in the builder.
+     * @return this builder instance.
+     */
+    public Builder<E, S> withFlags(final Collection<E> flags) {
+      clear();
+      if (flags != null) {
+        for (E flag : flags) {
+          if (flag != null) {
+            enumSet.add(flag);
+          }
+        }
+      }
+      return this;
+    }
+
+    /**
+     * @param flags The flags to set in the builder.
+     * @return this builder instance.
+     */
+    @SafeVarargs
+    public final Builder<E, S> withFlags(final E... flags) {
+      clear();
+      if (flags != null) {
+        for (E flag : flags) {
+          if (flag != null) {
+            if (!type.equals(flag.getClass())) {
+              throw new IllegalArgumentException("Unexpected type " + flag.getClass());
+            }
+            enumSet.add(flag);
+          }
+        }
+      }
+      return this;
+    }
+
+    /**
+     * Sets a single flag in the builder.
+     *
+     * @param flag The flag to set in the builder.
+     * @return this builder instance.
+     */
+    public Builder<E, S> setFlag(final E flag) {
+      if (flag != null) {
+        enumSet.add(flag);
+      }
+      return this;
+    }
+
+    /**
+     * Sets multiple flag in the builder.
+     *
+     * @param flags The flags to set in the builder.
+     * @return this builder instance.
+     */
+    public Builder<E, S> setFlags(final Collection<E> flags) {
+      if (flags != null) {
+        enumSet.addAll(flags);
+      }
+      return this;
+    }
+
+    /**
+     * Clears any flags already set in this {@link Builder}
+     *
+     * @return this builder instance.
+     */
+    public Builder<E, S> clear() {
+      enumSet.clear();
+      return this;
+    }
+
+    /**
+     * Build the {@link DbiFlagSet}
+     *
+     * @return A
+     */
+    public S build() {
+      final int size = enumSet.size();
+      if (size == 0) {
+        return emptySetSupplier.get();
+      } else if (size == 1) {
+        return singletonSetConstructor.apply(enumSet.stream().findFirst().get());
+      } else {
+        return constructor.apply(enumSet);
+      }
+    }
+  }
+}
diff --git a/src/main/java/org/lmdbjava/BufferProxy.java b/src/main/java/org/lmdbjava/BufferProxy.java
index d4503731..a3c339bf 100644
--- a/src/main/java/org/lmdbjava/BufferProxy.java
+++ b/src/main/java/org/lmdbjava/BufferProxy.java
@@ -16,10 +16,6 @@
 package org.lmdbjava;
 
 import static java.lang.Long.BYTES;
-import static org.lmdbjava.DbiFlags.MDB_INTEGERKEY;
-import static org.lmdbjava.DbiFlags.MDB_UNSIGNEDKEY;
-import static org.lmdbjava.MaskedFlag.isSet;
-import static org.lmdbjava.MaskedFlag.mask;
 
 import java.util.Comparator;
 import jnr.ffi.Pointer;
@@ -75,30 +71,22 @@ protected BufferProxy() {}
    * <p>The provided comparator must strictly match the lexicographical order of keys in the native
    * LMDB database.
    *
-   * @param flags for the database
+   * @param dbiFlagSet The {@link DbiFlags} set for the database.
    * @return a comparator that can be used (never null)
    */
-  protected Comparator<T> getComparator(DbiFlags... flags) {
-    final int intFlag = mask(flags);
-
-    return isSet(intFlag, MDB_INTEGERKEY) || isSet(intFlag, MDB_UNSIGNEDKEY)
-        ? getUnsignedComparator()
-        : getSignedComparator();
-  }
+  public abstract Comparator<T> getComparator(final DbiFlagSet dbiFlagSet);
 
   /**
-   * Get a suitable default {@link Comparator} to compare numeric key values as signed.
+   * Get a suitable default {@link Comparator}
    *
-   * @return a comparator that can be used (never null)
-   */
-  protected abstract Comparator<T> getSignedComparator();
-
-  /**
-   * Get a suitable default {@link Comparator} to compare numeric key values as unsigned.
+   * <p>The provided comparator must strictly match the lexicographical order of keys in the native
+   * LMDB database.
    *
    * @return a comparator that can be used (never null)
    */
-  protected abstract Comparator<T> getUnsignedComparator();
+  public Comparator<T> getComparator() {
+    return getComparator(DbiFlagSet.empty());
+  }
 
   /**
    * Called when the <code>MDB_val</code> should be set to reflect the passed buffer. This buffer
@@ -138,4 +126,13 @@ protected Comparator<T> getComparator(DbiFlags... flags) {
   final KeyVal<T> keyVal() {
     return new KeyVal<>(this);
   }
+
+  /**
+   * Create a new {@link Key} to hold pointers for this buffer proxy.
+   *
+   * @return a non-null key holder
+   */
+  final Key<T> key() {
+    return new Key<>(this);
+  }
 }
diff --git a/src/main/java/org/lmdbjava/ByteArrayProxy.java b/src/main/java/org/lmdbjava/ByteArrayProxy.java
index 853521e0..82b7721c 100644
--- a/src/main/java/org/lmdbjava/ByteArrayProxy.java
+++ b/src/main/java/org/lmdbjava/ByteArrayProxy.java
@@ -36,9 +36,6 @@ public final class ByteArrayProxy extends BufferProxy<byte[]> {
 
   private static final MemoryManager MEM_MGR = RUNTIME.getMemoryManager();
 
-  private static final Comparator<byte[]> signedComparator = ByteArrayProxy::compareArraysSigned;
-  private static final Comparator<byte[]> unsignedComparator = ByteArrayProxy::compareArrays;
-
   private ByteArrayProxy() {}
 
   /**
@@ -48,7 +45,7 @@ private ByteArrayProxy() {}
    * @param o2 right operand (required)
    * @return as specified by {@link Comparable} interface
    */
-  public static int compareArrays(final byte[] o1, final byte[] o2) {
+  public static int compareLexicographically(final byte[] o1, final byte[] o2) {
     requireNonNull(o1);
     requireNonNull(o2);
     if (o1 == o2) {
@@ -68,26 +65,6 @@ public static int compareArrays(final byte[] o1, final byte[] o2) {
     return o1.length - o2.length;
   }
 
-  /**
-   * Compare two byte arrays.
-   *
-   * @param b1 left operand (required)
-   * @param b2 right operand (required)
-   * @return as specified by {@link Comparable} interface
-   */
-  public static int compareArraysSigned(final byte[] b1, final byte[] b2) {
-    requireNonNull(b1);
-    requireNonNull(b2);
-
-    if (b1 == b2) return 0;
-
-    for (int i = 0; i < min(b1.length, b2.length); ++i) {
-      if (b1[i] != b2[i]) return b1[i] - b2[i];
-    }
-
-    return b1.length - b2.length;
-  }
-
   @Override
   protected byte[] allocate() {
     return new byte[0];
@@ -104,13 +81,8 @@ protected byte[] getBytes(final byte[] buffer) {
   }
 
   @Override
-  protected Comparator<byte[]> getSignedComparator() {
-    return signedComparator;
-  }
-
-  @Override
-  protected Comparator<byte[]> getUnsignedComparator() {
-    return unsignedComparator;
+  public Comparator<byte[]> getComparator(final DbiFlagSet dbiFlagSet) {
+    return ByteArrayProxy::compareLexicographically;
   }
 
   @Override
diff --git a/src/main/java/org/lmdbjava/ByteBufProxy.java b/src/main/java/org/lmdbjava/ByteBufProxy.java
index 2866e874..bcbb6ebf 100644
--- a/src/main/java/org/lmdbjava/ByteBufProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufProxy.java
@@ -23,6 +23,7 @@
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.PooledByteBufAllocator;
 import java.lang.reflect.Field;
+import java.nio.ByteOrder;
 import java.util.Comparator;
 import jnr.ffi.Pointer;
 
@@ -44,13 +45,6 @@ public final class ByteBufProxy extends BufferProxy<ByteBuf> {
   private static final String FIELD_NAME_ADDRESS = "memoryAddress";
   private static final String FIELD_NAME_LENGTH = "length";
   private static final String NAME = "io.netty.buffer.PooledUnsafeDirectByteBuf";
-  private static final Comparator<ByteBuf> comparator =
-      (o1, o2) -> {
-        requireNonNull(o1);
-        requireNonNull(o2);
-
-        return o1.compareTo(o2);
-      };
   private final long lengthOffset;
   private final long addressOffset;
 
@@ -81,6 +75,71 @@ public ByteBufProxy(final PooledByteBufAllocator allocator) {
     }
   }
 
+  /**
+   * Lexicographically compare two buffers.
+   *
+   * @param o1 left operand (required)
+   * @param o2 right operand (required)
+   * @return as specified by {@link Comparable} interface
+   */
+  public static int compareLexicographically(final ByteBuf o1, final ByteBuf o2) {
+    requireNonNull(o1);
+    requireNonNull(o2);
+    return o1.compareTo(o2);
+  }
+
+  /**
+   * Buffer comparator specifically for 4/8 byte keys that are unsigned ints/longs, i.e. when using
+   * MDB_INTEGER_KEY/MDB_INTEGERDUP. Compares the buffers numerically.
+   *
+   * @param o1 left operand (required)
+   * @param o2 right operand (required)
+   * @return as specified by {@link Comparable} interface
+   */
+  public static int compareAsIntegerKeys(final ByteBuf o1, final ByteBuf o2) {
+    requireNonNull(o1);
+    requireNonNull(o2);
+    // Both buffers should be same length according to LMDB API.
+    // From the LMDB docs for MDB_INTEGER_KEY
+    // numeric keys in native byte order: either unsigned int or size_t. The keys must all be of the
+    // same size.
+    final int len1 = o1.readableBytes();
+    final int len2 = o2.readableBytes();
+    if (len1 != len2) {
+      throw new RuntimeException(
+          "Length mismatch, len1: "
+              + len1
+              + ", len2: "
+              + len2
+              + ". Lengths must be identical and either 4 or 8 bytes.");
+    }
+    if (len1 == 8) {
+      final long lw;
+      final long rw;
+      if (ByteOrder.nativeOrder() == ByteOrder.LITTLE_ENDIAN) {
+        lw = o1.readLongLE();
+        rw = o2.readLongLE();
+      } else {
+        lw = o1.readLong();
+        rw = o2.readLong();
+      }
+      return Long.compareUnsigned(lw, rw);
+    } else if (len1 == 4) {
+      final int lw;
+      final int rw;
+      if (ByteOrder.nativeOrder() == ByteOrder.LITTLE_ENDIAN) {
+        lw = o1.readIntLE();
+        rw = o2.readIntLE();
+      } else {
+        lw = o1.readInt();
+        rw = o2.readInt();
+      }
+      return Integer.compareUnsigned(lw, rw);
+    } else {
+      return compareLexicographically(o1, o2);
+    }
+  }
+
   static Field findField(final String c, final String name) {
     Class<?> clazz;
     try {
@@ -114,13 +173,12 @@ protected ByteBuf allocate() {
   }
 
   @Override
-  protected Comparator<ByteBuf> getSignedComparator() {
-    return comparator;
-  }
-
-  @Override
-  protected Comparator<ByteBuf> getUnsignedComparator() {
-    return comparator;
+  public Comparator<ByteBuf> getComparator(final DbiFlagSet dbiFlagSet) {
+    if (dbiFlagSet.areAnySet(DbiFlagSet.INTEGER_KEY_FLAGS)) {
+      return ByteBufProxy::compareAsIntegerKeys;
+    } else {
+      return ByteBufProxy::compareLexicographically;
+    }
   }
 
   @Override
diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
index 3c80b995..52bfc924 100644
--- a/src/main/java/org/lmdbjava/ByteBufferProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -27,6 +27,7 @@
 import java.lang.reflect.Field;
 import java.nio.Buffer;
 import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
 import java.util.ArrayDeque;
 import java.util.Comparator;
 import jnr.ffi.Pointer;
@@ -57,6 +58,8 @@ public final class ByteBufferProxy {
   /** The safe, reflective {@link ByteBuffer} proxy for this system. Guaranteed to never be null. */
   public static final BufferProxy<ByteBuffer> PROXY_SAFE;
 
+  private static final ByteOrder NATIVE_ORDER = ByteOrder.nativeOrder();
+
   static {
     PROXY_SAFE = new ReflectiveProxy();
     PROXY_OPTIMAL = getProxyOptimal();
@@ -83,6 +86,8 @@ public BufferMustBeDirectException() {
     }
   }
 
+  // --------------------------------------------------------------------------------
+
   /**
    * Provides {@link ByteBuffer} pooling and address resolution for concrete {@link BufferProxy}
    * implementations.
@@ -92,16 +97,6 @@ abstract static class AbstractByteBufferProxy extends BufferProxy<ByteBuffer> {
     protected static final String FIELD_NAME_ADDRESS = "address";
     protected static final String FIELD_NAME_CAPACITY = "capacity";
 
-    private static final Comparator<ByteBuffer> signedComparator =
-        (o1, o2) -> {
-          requireNonNull(o1);
-          requireNonNull(o2);
-
-          return o1.compareTo(o2);
-        };
-    private static final Comparator<ByteBuffer> unsignedComparator =
-        AbstractByteBufferProxy::compareBuff;
-
     /**
      * A thread-safe pool for a given length. If the buffer found is valid (ie not of a negative
      * length) then that buffer is used. If no valid buffer is found, a new buffer is created.
@@ -116,7 +111,7 @@ abstract static class AbstractByteBufferProxy extends BufferProxy<ByteBuffer> {
      * @param o2 right operand (required)
      * @return as specified by {@link Comparable} interface
      */
-    public static int compareBuff(final ByteBuffer o1, final ByteBuffer o2) {
+    public static int compareLexicographically(final ByteBuffer o1, final ByteBuffer o2) {
       requireNonNull(o1);
       requireNonNull(o2);
       final int minLength = Math.min(o1.limit(), o2.limit());
@@ -145,6 +140,55 @@ public static int compareBuff(final ByteBuffer o1, final ByteBuffer o2) {
       return o1.remaining() - o2.remaining();
     }
 
+    /**
+     * Buffer comparator specifically for 4/8 byte keys that are unsigned ints/longs, i.e. when
+     * using MDB_INTEGER_KEY/MDB_INTEGERDUP. Compares the buffers numerically.
+     *
+     * @param o1 left operand (required)
+     * @param o2 right operand (required)
+     * @return as specified by {@link Comparable} interface
+     */
+    public static int compareAsIntegerKeys(final ByteBuffer o1, final ByteBuffer o2) {
+      requireNonNull(o1);
+      requireNonNull(o2);
+      // Both buffers should be same length according to LMDB API.
+      // From the LMDB docs for MDB_INTEGER_KEY
+      // numeric keys in native byte order: either unsigned int or size_t. The keys must all be of
+      // the same size.
+      final int len1 = o1.limit();
+      final int len2 = o2.limit();
+      if (len1 != len2) {
+        throw new RuntimeException(
+            "Length mismatch, len1: "
+                + len1
+                + ", len2: "
+                + len2
+                + ". Lengths must be identical and either 4 or 8 bytes.");
+      }
+      // Keys for MDB_INTEGER_KEY are written in native order so ensure we read them in that order
+      o1.order(NATIVE_ORDER);
+      o2.order(NATIVE_ORDER);
+      // TODO it might be worth the DbiBuilder having a method to capture fixedKeyLength() or -1
+      //  for variable length keys. This can be passed to getComparator(..) so it can return a
+      //  comparator that doesn't need to test the length every time. There may be other benefits
+      //  to the Dbi knowing the key length if it is fixed.
+      if (len1 == 8) {
+        final long lw = o1.getLong(0);
+        final long rw = o2.getLong(0);
+        return Long.compareUnsigned(lw, rw);
+      } else if (len1 == 4) {
+        final int lw = o1.getInt(0);
+        final int rw = o2.getInt(0);
+        return Integer.compareUnsigned(lw, rw);
+      } else {
+        // size_t and int are likely to be 8bytes and 4bytes respectively on 64bit.
+        // If 32bit then would be 4/2 respectively.
+        // Short.compareUnsigned is not available in Java8.
+        // For now just fall back to our standard comparator
+        return compareLexicographically(o1, o2);
+      }
+    }
+
     static Field findField(final Class<?> c, final String name) {
       Class<?> clazz = c;
       do {
@@ -179,13 +223,12 @@ protected final ByteBuffer allocate() {
     }
 
     @Override
-    protected Comparator<ByteBuffer> getSignedComparator() {
-      return signedComparator;
-    }
-
-    @Override
-    protected Comparator<ByteBuffer> getUnsignedComparator() {
-      return unsignedComparator;
+    public Comparator<ByteBuffer> getComparator(final DbiFlagSet dbiFlagSet) {
+      if (dbiFlagSet.areAnySet(DbiFlagSet.INTEGER_KEY_FLAGS)) {
+        return AbstractByteBufferProxy::compareAsIntegerKeys;
+      } else {
+        return AbstractByteBufferProxy::compareLexicographically;
+      }
     }
 
     @Override
@@ -203,6 +246,8 @@ protected byte[] getBytes(final ByteBuffer buffer) {
     }
   }
 
+  // --------------------------------------------------------------------------------
+
   /**
    * A proxy that uses Java reflection to modify byte buffer fields, and official JNR-FFF methods to
    * manipulate native pointers.
@@ -247,6 +292,8 @@ protected ByteBuffer out(final ByteBuffer buffer, final Pointer ptr) {
     }
   }
 
+  // --------------------------------------------------------------------------------
+
   /**
    * A proxy that uses Java's "unsafe" class to directly manipulate byte buffer fields and JNR-FFF
    * allocated memory pointers.
diff --git a/src/main/java/org/lmdbjava/CopyFlagSet.java b/src/main/java/org/lmdbjava/CopyFlagSet.java
new file mode 100644
index 00000000..b80e5b38
--- /dev/null
+++ b/src/main/java/org/lmdbjava/CopyFlagSet.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import java.util.Collection;
+import java.util.EnumSet;
+import java.util.Objects;
+
+public interface CopyFlagSet extends FlagSet<CopyFlags> {
+
+  static CopyFlagSet EMPTY = CopyFlagSetImpl.EMPTY;
+
+  static CopyFlagSet empty() {
+    return CopyFlagSetImpl.EMPTY;
+  }
+
+  static CopyFlagSet of(final CopyFlags dbiFlag) {
+    Objects.requireNonNull(dbiFlag);
+    return dbiFlag;
+  }
+
+  static CopyFlagSet of(final CopyFlags... CopyFlags) {
+    return builder().withFlags(CopyFlags).build();
+  }
+
+  static CopyFlagSet of(final Collection<CopyFlags> CopyFlags) {
+    return builder().withFlags(CopyFlags).build();
+  }
+
+  static AbstractFlagSet.Builder<CopyFlags, CopyFlagSet> builder() {
+    return new AbstractFlagSet.Builder<>(
+        CopyFlags.class, CopyFlagSetImpl::new, copyFlag -> copyFlag, () -> CopyFlagSetImpl.EMPTY);
+  }
+
+  // --------------------------------------------------------------------------------
+
+  class CopyFlagSetImpl extends AbstractFlagSet<CopyFlags> implements CopyFlagSet {
+
+    static final CopyFlagSet EMPTY = new EmptyCopyFlagSet();
+
+    private CopyFlagSetImpl(final EnumSet<CopyFlags> flags) {
+      super(flags);
+    }
+  }
+
+  // --------------------------------------------------------------------------------
+
+  class EmptyCopyFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<CopyFlags>
+      implements CopyFlagSet {}
+}
diff --git a/src/main/java/org/lmdbjava/CopyFlags.java b/src/main/java/org/lmdbjava/CopyFlags.java
index 4365563c..b45dc87c 100644
--- a/src/main/java/org/lmdbjava/CopyFlags.java
+++ b/src/main/java/org/lmdbjava/CopyFlags.java
@@ -15,8 +15,12 @@
  */
 package org.lmdbjava;
 
-/** Flags for use when performing a {@link Env#copy(java.io.File, org.lmdbjava.CopyFlags...)}. */
-public enum CopyFlags implements MaskedFlag {
+import java.io.File;
+import java.util.EnumSet;
+import java.util.Set;
+
+/** Flags for use when performing a {@link Env#copy(File, CopyFlagSet)}. */
+public enum CopyFlags implements MaskedFlag, CopyFlagSet {
 
   /** Compacting copy: Omit free space from copy, and renumber all pages sequentially. */
   MDB_CP_COMPACT(0x01);
@@ -31,4 +35,29 @@ public enum CopyFlags implements MaskedFlag {
   public int getMask() {
     return mask;
   }
+
+  @Override
+  public Set<CopyFlags> getFlags() {
+    return EnumSet.of(this);
+  }
+
+  @Override
+  public boolean isSet(final CopyFlags flag) {
+    return flag != null && mask == flag.getMask();
+  }
+
+  @Override
+  public int size() {
+    return 1;
+  }
+
+  @Override
+  public boolean isEmpty() {
+    return false;
+  }
+
+  @Override
+  public String toString() {
+    return FlagSet.asString(this);
+  }
 }
diff --git a/src/main/java/org/lmdbjava/Cursor.java b/src/main/java/org/lmdbjava/Cursor.java
index f7fcbc41..f29c734f 100644
--- a/src/main/java/org/lmdbjava/Cursor.java
+++ b/src/main/java/org/lmdbjava/Cursor.java
@@ -20,8 +20,6 @@
 import static org.lmdbjava.Dbi.KeyNotFoundException.MDB_NOTFOUND;
 import static org.lmdbjava.Env.SHOULD_CHECK;
 import static org.lmdbjava.Library.LIB;
-import static org.lmdbjava.MaskedFlag.isSet;
-import static org.lmdbjava.MaskedFlag.mask;
 import static org.lmdbjava.PutFlags.MDB_MULTIPLE;
 import static org.lmdbjava.PutFlags.MDB_NODUPDATA;
 import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
@@ -98,22 +96,40 @@ public long count() {
     return longByReference.longValue();
   }
 
+  /**
+   * @deprecated Instead use {@link Cursor#delete(PutFlagSet)}. <hr> Delete current key/data pair.
+   *     <p>This function deletes the key/data pair to which the cursor refers.
+   * @param flags flags (either null or {@link PutFlags#MDB_NODUPDATA}
+   */
+  @Deprecated
+  public void delete(final PutFlags... flags) {
+    delete(PutFlagSet.of(flags));
+  }
+
+  /**
+   * @deprecated Instead use {@link Cursor#delete(PutFlagSet)}. <hr> Delete current key/data pair.
+   *     <p>This function deletes the key/data pair to which the cursor refers.
+   */
+  public void delete() {
+    delete(PutFlagSet.EMPTY);
+  }
+
   /**
    * Delete current key/data pair.
    *
    * <p>This function deletes the key/data pair to which the cursor refers.
    *
-   * @param f flags (either null or {@link PutFlags#MDB_NODUPDATA}
+   * @param flags flags (either null or {@link PutFlags#MDB_NODUPDATA}
    */
-  public void delete(final PutFlags... f) {
+  public void delete(final PutFlagSet flags) {
     if (SHOULD_CHECK) {
       env.checkNotClosed();
       checkNotClosed();
       txn.checkReady();
       txn.checkWritesAllowed();
     }
-    final int flags = mask(true, f);
-    checkRc(LIB.mdb_cursor_del(ptrCursor, flags));
+    final PutFlagSet putFlagSet = flags != null ? flags : PutFlagSet.EMPTY;
+    checkRc(LIB.mdb_cursor_del(ptrCursor, putFlagSet.getMask()));
   }
 
   /**
@@ -203,6 +219,10 @@ public T key() {
     return kv.key();
   }
 
+  KeyVal<T> keyVal() {
+    return kv;
+  }
+
   /**
    * Position at last key/data item.
    *
@@ -230,6 +250,20 @@ public boolean prev() {
     return seek(MDB_PREV);
   }
 
+  /**
+   * @deprecated Use {@link Cursor#put(Object, Object, PutFlagSet)} instead. <hr> Store by cursor.
+   *     <p>This function stores key/data pairs into the database.
+   * @param key key to store
+   * @param val data to store
+   * @param flags options for this operation
+   * @return true if the value was put, false if MDB_NOOVERWRITE or MDB_NODUPDATA were set and the
+   *     key/value existed already.
+   */
+  @Deprecated
+  public boolean put(final T key, final T val, final PutFlags... flags) {
+    return put(key, val, PutFlagSet.of(flags));
+  }
+
   /**
    * Store by cursor.
    *
@@ -237,11 +271,25 @@ public boolean prev() {
    *
    * @param key key to store
    * @param val data to store
-   * @param op options for this operation
    * @return true if the value was put, false if MDB_NOOVERWRITE or MDB_NODUPDATA were set and the
    *     key/value existed already.
    */
-  public boolean put(final T key, final T val, final PutFlags... op) {
+  public boolean put(final T key, final T val) {
+    return put(key, val, PutFlagSet.EMPTY);
+  }
+
+  /**
+   * Store by cursor.
+   *
+   * <p>This function stores key/data pairs into the database.
+   *
+   * @param key key to store
+   * @param val data to store
+   * @param flags options for this operation
+   * @return true if the value was put, false if MDB_NOOVERWRITE or MDB_NODUPDATA were set and the
+   *     key/value existed already.
+   */
+  public boolean put(final T key, final T val, final PutFlagSet flags) {
     if (SHOULD_CHECK) {
       requireNonNull(key);
       requireNonNull(val);
@@ -252,12 +300,13 @@ public boolean put(final T key, final T val, final PutFlags... op) {
     }
     final Pointer transientKey = kv.keyIn(key);
     final Pointer transientVal = kv.valIn(val);
-    final int mask = mask(true, op);
-    final int rc = LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(), mask);
+    final PutFlagSet putFlagSet = flags != null ? flags : PutFlagSet.EMPTY;
+    final int rc =
+        LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(), putFlagSet.getMask());
     if (rc == MDB_KEYEXIST) {
-      if (isSet(mask, MDB_NOOVERWRITE)) {
+      if (putFlagSet.isSet(MDB_NOOVERWRITE)) {
         kv.valOut(); // marked as in,out in LMDB C docs
-      } else if (!isSet(mask, MDB_NODUPDATA)) {
+      } else if (!putFlagSet.isSet(MDB_NODUPDATA)) {
         checkRc(rc);
       }
       return false;
@@ -270,6 +319,39 @@ public boolean put(final T key, final T val, final PutFlags... op) {
     return true;
   }
 
+  /**
+   * @deprecated Use {@link Cursor#put(Object, Object, PutFlagSet)} instead. <hr> Put multiple
+   *     values into the database in one <code>MDB_MULTIPLE</code> operation.
+   *     <p>The database must have been opened with {@link DbiFlags#MDB_DUPFIXED}. The buffer must
+   *     contain fixed-sized values to be inserted. The size of each element is calculated from the
+   *     buffer's size divided by the given element count. For example, to populate 10 X 4 byte
+   *     integers at once, present a buffer of 40 bytes and specify the element as 10.
+   * @param key key to store in the database (not null)
+   * @param val value to store in the database (not null)
+   * @param elements number of elements contained in the passed value buffer
+   * @param flags options for operation (must set <code>MDB_MULTIPLE</code>)
+   */
+  @Deprecated
+  public void putMultiple(final T key, final T val, final int elements, final PutFlags... flags) {
+    putMultiple(key, val, elements, PutFlagSet.of(flags));
+  }
+
+  /**
+   * Put multiple values into the database in one <code>MDB_MULTIPLE</code> operation.
+   *
+   * <p>The database must have been opened with {@link DbiFlags#MDB_DUPFIXED}. The buffer must
+   * contain fixed-sized values to be inserted. The size of each element is calculated from the
+   * buffer's size divided by the given element count. For example, to populate 10 X 4 byte integers
+   * at once, present a buffer of 40 bytes and specify the element as 10.
+   *
+   * @param key key to store in the database (not null)
+   * @param val value to store in the database (not null)
+   * @param elements number of elements contained in the passed value buffer
+   */
+  public void putMultiple(final T key, final T val, final int elements) {
+    putMultiple(key, val, elements, PutFlagSet.EMPTY);
+  }
+
   /**
    * Put multiple values into the database in one <code>MDB_MULTIPLE</code> operation.
    *
@@ -281,9 +363,10 @@ public boolean put(final T key, final T val, final PutFlags... op) {
    * @param key key to store in the database (not null)
    * @param val value to store in the database (not null)
    * @param elements number of elements contained in the passed value buffer
-   * @param op options for operation (must set <code>MDB_MULTIPLE</code>)
+   * @param flags options for operation (must set <code>MDB_MULTIPLE</code>) Either a {@link
+   *     PutFlagSet} or a single {@link PutFlags}.
    */
-  public void putMultiple(final T key, final T val, final int elements, final PutFlags... op) {
+  public void putMultiple(final T key, final T val, final int elements, final PutFlagSet flags) {
     if (SHOULD_CHECK) {
       requireNonNull(txn);
       requireNonNull(key);
@@ -292,13 +375,14 @@ public void putMultiple(final T key, final T val, final int elements, final PutF
       txn.checkReady();
       txn.checkWritesAllowed();
     }
-    final int mask = mask(true, op);
-    if (SHOULD_CHECK && !isSet(mask, MDB_MULTIPLE)) {
+    final PutFlagSet putFlagSet = flags != null ? flags : PutFlagSet.EMPTY;
+    if (SHOULD_CHECK && !putFlagSet.isSet(MDB_MULTIPLE)) {
       throw new IllegalArgumentException("Must set " + MDB_MULTIPLE + " flag");
     }
     final Pointer transientKey = txn.kv().keyIn(key);
     final Pointer dataPtr = txn.kv().valInMulti(val, elements);
-    final int rc = LIB.mdb_cursor_put(ptrCursor, txn.kv().pointerKey(), dataPtr, mask);
+    final int rc =
+        LIB.mdb_cursor_put(ptrCursor, txn.kv().pointerKey(), dataPtr, putFlagSet.getMask());
     checkRc(rc);
     ReferenceUtil.reachabilityFence0(transientKey);
     ReferenceUtil.reachabilityFence0(dataPtr);
@@ -329,21 +413,56 @@ public void renew(final Txn<T> newTxn) {
     this.txn = newTxn;
   }
 
+  /**
+   * @deprecated Use {@link Cursor#reserve(Object, int, PutFlagSet)} instead. <hr> Reserve space for
+   *     data of the given size, but don't copy the given val. Instead, return a pointer to the
+   *     reserved space, which the caller can fill in later - before the next update operation or
+   *     the transaction ends. This saves an extra memcpy if the data is being generated later. LMDB
+   *     does nothing else with this memory, the caller is expected to modify all of the space
+   *     requested.
+   *     <p>This flag must not be specified if the database was opened with MDB_DUPSORT
+   * @param key key to store in the database (not null)
+   * @param size size of the value to be stored in the database (not null)
+   * @param flags options for this operation
+   * @return a buffer that can be used to modify the value
+   */
+  @Deprecated
+  public T reserve(final T key, final int size, final PutFlags... flags) {
+    return reserve(key, size, PutFlagSet.of(flags));
+  }
+
+  /**
+   * Reserve space for data of the given size, but don't copy the given val. Instead, return a
+   * pointer to the reserved space, which the caller can fill in later - before the next update
+   * operation or the transaction ends. This saves an extra {@code memcpy} if the data is being
+   * generated later. LMDB does nothing else with this memory, the caller is expected to modify all
+   * the space requested.
+   *
+   * <p>This flag must not be specified if the database was opened with MDB_DUPSORT
+   *
+   * @param key key to store in the database (not null)
+   * @param size size of the value to be stored in the database (not null)
+   * @return a buffer that can be used to modify the value
+   */
+  public T reserve(final T key, final int size) {
+    return reserve(key, size, PutFlagSet.EMPTY);
+  }
+
   /**
    * Reserve space for data of the given size, but don't copy the given val. Instead, return a
    * pointer to the reserved space, which the caller can fill in later - before the next update
    * operation or the transaction ends. This saves an extra memcpy if the data is being generated
-   * later. LMDB does nothing else with this memory, the caller is expected to modify all of the
-   * space requested.
+   * later. LMDB does nothing else with this memory, the caller is expected to modify all the space
+   * requested.
    *
    * <p>This flag must not be specified if the database was opened with MDB_DUPSORT
    *
    * @param key key to store in the database (not null)
    * @param size size of the value to be stored in the database (not null)
-   * @param op options for this operation
+   * @param flags options for this operation
    * @return a buffer that can be used to modify the value
    */
-  public T reserve(final T key, final int size, final PutFlags... op) {
+  public T reserve(final T key, final int size, final PutFlagSet flags) {
     if (SHOULD_CHECK) {
       requireNonNull(key);
       env.checkNotClosed();
@@ -353,8 +472,10 @@ public T reserve(final T key, final int size, final PutFlags... op) {
     }
     final Pointer transientKey = kv.keyIn(key);
     final Pointer transientVal = kv.valIn(size);
-    final int flags = mask(true, op) | MDB_RESERVE.getMask();
-    checkRc(LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(), flags));
+    final PutFlagSet putFlagSet = flags != null ? flags : PutFlagSet.EMPTY;
+    // This is inconsistent with putMultiple which require MDB_MULTIPLE to be in the set.
+    final int flagsMask = putFlagSet.getMaskWith(MDB_RESERVE);
+    checkRc(LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(), flagsMask));
     kv.valOut();
     ReferenceUtil.reachabilityFence0(transientKey);
     ReferenceUtil.reachabilityFence0(transientVal);
diff --git a/src/main/java/org/lmdbjava/CursorIterable.java b/src/main/java/org/lmdbjava/CursorIterable.java
index 80fd5ef3..5c7a1b3f 100644
--- a/src/main/java/org/lmdbjava/CursorIterable.java
+++ b/src/main/java/org/lmdbjava/CursorIterable.java
@@ -21,10 +21,14 @@
 import static org.lmdbjava.CursorIterable.State.REQUIRES_NEXT_OP;
 import static org.lmdbjava.CursorIterable.State.TERMINATED;
 import static org.lmdbjava.GetOp.MDB_SET_RANGE;
+import static org.lmdbjava.Library.LIB;
 
 import java.util.Comparator;
 import java.util.Iterator;
 import java.util.NoSuchElementException;
+import java.util.Objects;
+import java.util.function.Supplier;
+import jnr.ffi.Pointer;
 import org.lmdbjava.KeyRangeType.CursorOp;
 import org.lmdbjava.KeyRangeType.IteratorOp;
 
@@ -38,7 +42,7 @@
  */
 public final class CursorIterable<T> implements Iterable<CursorIterable.KeyVal<T>>, AutoCloseable {
 
-  private final Comparator<T> comparator;
+  private final RangeComparator rangeComparator;
   private final Cursor<T> cursor;
   private final KeyVal<T> entry;
   private boolean iteratorReturned;
@@ -46,16 +50,32 @@ public final class CursorIterable<T> implements Iterable<CursorIterable.KeyVal<T
   private State state = REQUIRES_INITIAL_OP;
 
   CursorIterable(
-      final Txn<T> txn, final Dbi<T> dbi, final KeyRange<T> range, final Comparator<T> comparator) {
+      final Txn<T> txn,
+      final Dbi<T> dbi,
+      final KeyRange<T> range,
+      final Comparator<T> comparator,
+      final BufferProxy<T> proxy) {
     this.cursor = dbi.openCursor(txn);
     this.range = range;
-    this.comparator = comparator;
     this.entry = new KeyVal<>();
+
+    if (comparator != null) {
+      // User supplied Java-side comparator so use that
+      this.rangeComparator = new JavaRangeComparator<>(range, comparator, cursor::key);
+    } else {
+      // No Java-side comparator, so call down to LMDB to do the comparison
+      this.rangeComparator = new LmdbRangeComparator<>(txn, dbi, cursor, range, proxy);
+    }
   }
 
   @Override
   public void close() {
     cursor.close();
+    try {
+      rangeComparator.close();
+    } catch (Exception e) {
+      throw new RuntimeException(e);
+    }
   }
 
   /**
@@ -127,7 +147,7 @@ private void executeCursorOp(final CursorOp op) {
             // We need to ensure we move to the last matching key if using DUPSORT, see issue 267
             boolean loop = true;
             while (loop) {
-              if (comparator.compare(cursor.key(), range.getStart()) <= 0) {
+              if (rangeComparator.compareToStartKey() <= 0) {
                 found = cursor.next();
                 if (!found) {
                   // We got to the end so move last.
@@ -153,8 +173,7 @@ private void executeCursorOp(final CursorOp op) {
   }
 
   private void executeIteratorOp() {
-    final IteratorOp op =
-        range.getType().iteratorOp(range.getStart(), range.getStop(), entry.key(), comparator);
+    final IteratorOp op = range.getType().iteratorOp(entry.key(), rangeComparator);
     switch (op) {
       case CALL_NEXT_OP:
         executeCursorOp(range.getType().nextOp());
@@ -243,4 +262,104 @@ enum State {
     RELEASED,
     TERMINATED
   }
+
+  // --------------------------------------------------------------------------------
+
+  static class JavaRangeComparator<T> implements RangeComparator {
+
+    private final Comparator<T> comparator;
+    private final Supplier<T> currentKeySupplier;
+    private final T start;
+    private final T stop;
+
+    JavaRangeComparator(
+        final KeyRange<T> range,
+        final Comparator<T> comparator,
+        final Supplier<T> currentKeySupplier) {
+      this.comparator = comparator;
+      this.currentKeySupplier = currentKeySupplier;
+      this.start = range.getStart();
+      this.stop = range.getStop();
+    }
+
+    @Override
+    public int compareToStartKey() {
+      return comparator.compare(currentKeySupplier.get(), start);
+    }
+
+    @Override
+    public int compareToStopKey() {
+      return comparator.compare(currentKeySupplier.get(), stop);
+    }
+
+    @Override
+    public void close() throws Exception {
+      // Nothing to close
+    }
+  }
+
+  // --------------------------------------------------------------------------------
+
+  /**
+   * Calls down to mdb_cmp to make use of the comparator that LMDB uses for insertion order. Has a
+   * very slight overhead as compared to {@link JavaRangeComparator}.
+   */
+  private static class LmdbRangeComparator<T> implements RangeComparator {
+
+    private final Pointer txnPointer;
+    private final Pointer dbiPointer;
+    private final Pointer cursorKeyPointer;
+    private final Key<T> startKey;
+    private final Key<T> stopKey;
+    private final Pointer startKeyPointer;
+    private final Pointer stopKeyPointer;
+
+    public LmdbRangeComparator(
+        final Txn<T> txn,
+        final Dbi<T> dbi,
+        final Cursor<T> cursor,
+        final KeyRange<T> range,
+        final BufferProxy<T> proxy) {
+      txnPointer = Objects.requireNonNull(txn).pointer();
+      dbiPointer = Objects.requireNonNull(dbi).pointer();
+      cursorKeyPointer = Objects.requireNonNull(cursor).keyVal().pointerKey();
+      // Allocate buffers for use with the start/stop keys if required.
+      // Saves us copying bytes on each comparison
+      Objects.requireNonNull(range);
+      startKey = createKey(range.getStart(), proxy);
+      stopKey = createKey(range.getStop(), proxy);
+      startKeyPointer = startKey != null ? startKey.pointer() : null;
+      stopKeyPointer = stopKey != null ? stopKey.pointer() : null;
+    }
+
+    @Override
+    public int compareToStartKey() {
+      return LIB.mdb_cmp(txnPointer, dbiPointer, cursorKeyPointer, startKeyPointer);
+    }
+
+    @Override
+    public int compareToStopKey() {
+      return LIB.mdb_cmp(txnPointer, dbiPointer, cursorKeyPointer, stopKeyPointer);
+    }
+
+    @Override
+    public void close() {
+      if (startKey != null) {
+        startKey.close();
+      }
+      if (stopKey != null) {
+        stopKey.close();
+      }
+    }
+
+    private Key<T> createKey(final T keyBuffer, final BufferProxy<T> proxy) {
+      if (keyBuffer != null) {
+        final Key<T> key = proxy.key();
+        key.keyIn(keyBuffer);
+        return key;
+      } else {
+        return null;
+      }
+    }
+  }
 }
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index 5449c172..43fb335a 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -31,6 +31,7 @@
 import static org.lmdbjava.PutFlags.MDB_RESERVE;
 import static org.lmdbjava.ResultCodeMapper.checkRc;
 
+import java.nio.charset.Charset;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Comparator;
@@ -48,12 +49,15 @@
  */
 public final class Dbi<T> {
 
-  private final ComparatorCallback ccb;
+  private final ComparatorCallback callbackComparator;
   private boolean cleaned;
+  // Used for CursorIterable KeyRange testing and/or native callbacks
   private final Comparator<T> comparator;
   private final Env<T> env;
   private final byte[] name;
   private final Pointer ptr;
+  private final BufferProxy<T> proxy;
+  private final DbiFlagSet dbiFlagSet;
 
   Dbi(
       final Env<T> env,
@@ -62,24 +66,34 @@ public final class Dbi<T> {
       final Comparator<T> comparator,
       final boolean nativeCb,
       final BufferProxy<T> proxy,
-      final DbiFlags... flags) {
+      final DbiFlagSet dbiFlagSet) {
     if (SHOULD_CHECK) {
       requireNonNull(txn);
       txn.checkReady();
     }
     this.env = env;
     this.name = name == null ? null : Arrays.copyOf(name, name.length);
-    if (comparator == null) {
-      this.comparator = proxy.getComparator(flags);
-    } else {
-      this.comparator = comparator;
-    }
-    final int flagsMask = mask(true, flags);
+    this.proxy = proxy;
+    this.comparator = comparator;
+    this.dbiFlagSet = dbiFlagSet;
     final Pointer dbiPtr = allocateDirect(RUNTIME, ADDRESS);
-    checkRc(LIB.mdb_dbi_open(txn.pointer(), name, flagsMask, dbiPtr));
+    checkRc(LIB.mdb_dbi_open(txn.pointer(), name, dbiFlagSet.getMask(), dbiPtr));
     ptr = dbiPtr.getPointer(0);
     if (nativeCb) {
-      this.ccb =
+      requireNonNull(comparator, "comparator cannot be null if nativeCb is set");
+      // LMDB will call back to this comparator for insertion/iteration order
+      //      if (dbiFlagSet.areAnySet(DbiFlagSet.INTEGER_KEY_FLAGS)) {
+      //        this.callbackComparator =
+      //            (keyA, keyB) -> {
+      //              final T compKeyA  = proxy.out(proxy.allocate(), keyA);
+      //              final T compKeyB = proxy.out(proxy.allocate(), keyB);
+      //              final int result = this.comparator.compare(compKeyA, compKeyB);
+      //              proxy.deallocate(compKeyA);
+      //              proxy.deallocate(compKeyB);
+      //              return result;
+      //            };
+      //      } else {
+      this.callbackComparator =
           (keyA, keyB) -> {
             final T compKeyA = proxy.out(proxy.allocate(), keyA);
             final T compKeyB = proxy.out(proxy.allocate(), keyB);
@@ -88,12 +102,17 @@ public final class Dbi<T> {
             proxy.deallocate(compKeyB);
             return result;
           };
-      LIB.mdb_set_compare(txn.pointer(), ptr, ccb);
+      //      }
+      LIB.mdb_set_compare(txn.pointer(), ptr, callbackComparator);
     } else {
-      ccb = null;
+      callbackComparator = null;
     }
   }
 
+  Pointer pointer() {
+    return ptr;
+  }
+
   /**
    * Close the database handle (normally unnecessary; use with caution).
    *
@@ -254,6 +273,30 @@ public byte[] getName() {
     return name == null ? null : Arrays.copyOf(name, name.length);
   }
 
+  public String getNameAsString() {
+    return getNameAsString(Env.DEFAULT_NAME_CHARSET);
+  }
+
+  /**
+   * Obtains the name of this database, using the supplied {@link Charset}.
+   *
+   * @return The name of the database. If this is the unnamed database an empty string will be
+   *     returned.
+   * @throws RuntimeException if the name can't be decoded.
+   */
+  public String getNameAsString(final Charset charset) {
+    if (name == null) {
+      return "";
+    } else {
+      // Assume a UTF8 encoding as we don't know, thus swallow if it fails
+      try {
+        return new String(name, requireNonNull(charset));
+      } catch (Exception e) {
+        throw new RuntimeException("Unable to decode database name using charset " + charset);
+      }
+    }
+  }
+
   /**
    * Iterate the database from the first item and forwards.
    *
@@ -278,7 +321,7 @@ public CursorIterable<T> iterate(final Txn<T> txn, final KeyRange<T> range) {
       env.checkNotClosed();
       txn.checkReady();
     }
-    return new CursorIterable<>(txn, this, range, comparator);
+    return new CursorIterable<>(txn, this, range, comparator, proxy);
   }
 
   /**
@@ -288,6 +331,7 @@ public CursorIterable<T> iterate(final Txn<T> txn, final KeyRange<T> range) {
    * @return the list of flags this Dbi was created with
    */
   public List<DbiFlags> listFlags(final Txn<T> txn) {
+    // TODO we could just return what is in dbiFlagSet, rather than hitting LMDB.
     if (SHOULD_CHECK) {
       env.checkNotClosed();
     }
@@ -337,15 +381,48 @@ public Cursor<T> openCursor(final Txn<T> txn) {
    *
    * @param key key to store in the database (not null)
    * @param val value to store in the database (not null)
-   * @see #put(org.lmdbjava.Txn, java.lang.Object, java.lang.Object, org.lmdbjava.PutFlags...)
+   * @see #put(Txn, Object, Object, PutFlagSet)
    */
   public void put(final T key, final T val) {
     try (Txn<T> txn = env.txnWrite()) {
-      put(txn, key, val);
+      put(txn, key, val, PutFlagSet.EMPTY);
       txn.commit();
     }
   }
 
+  /**
+   * @deprecated Use {@link Dbi#put(Txn, Object, Object, PutFlagSet)} instead, with a statically
+   *     held {@link PutFlagSet}. <hr>
+   *     <p>Store a key/value pair in the database.
+   *     <p>This function stores key/data pairs in the database. The default behavior is to enter
+   *     the new key/data pair, replacing any previously existing key if duplicates are disallowed,
+   *     or adding a duplicate data item if duplicates are allowed ({@link DbiFlags#MDB_DUPSORT}).
+   * @param txn transaction handle (not null; not committed; must be R-W)
+   * @param key key to store in the database (not null)
+   * @param val value to store in the database (not null)
+   * @param flags Special options for this operation
+   * @return true if the value was put, false if MDB_NOOVERWRITE or MDB_NODUPDATA were set and the
+   *     key/value existed already.
+   */
+  @Deprecated
+  public boolean put(final Txn<T> txn, final T key, final T val, final PutFlags... flags) {
+    return put(txn, key, val, PutFlagSet.of(flags));
+  }
+
+  /**
+   * Store a key/value pair in the database.
+   *
+   * @param txn transaction handle (not null; not committed; must be R-W)
+   * @param key key to store in the database (not null)
+   * @param val value to store in the database (not null)
+   * @return true if the value was put, false if MDB_NOOVERWRITE or MDB_NODUPDATA were set and the
+   *     key/value existed already.
+   * @see #put(Txn, Object, Object, PutFlagSet)
+   */
+  public boolean put(final Txn<T> txn, final T key, final T val) {
+    return put(txn, key, val, PutFlagSet.EMPTY);
+  }
+
   /**
    * Store a key/value pair in the database.
    *
@@ -356,11 +433,11 @@ public void put(final T key, final T val) {
    * @param txn transaction handle (not null; not committed; must be R-W)
    * @param key key to store in the database (not null)
    * @param val value to store in the database (not null)
-   * @param flags Special options for this operation
+   * @param flags Special options for this operation.
    * @return true if the value was put, false if MDB_NOOVERWRITE or MDB_NODUPDATA were set and the
    *     key/value existed already.
    */
-  public boolean put(final Txn<T> txn, final T key, final T val, final PutFlags... flags) {
+  public boolean put(final Txn<T> txn, final T key, final T val, final PutFlagSet flags) {
     if (SHOULD_CHECK) {
       requireNonNull(txn);
       requireNonNull(key);
@@ -369,15 +446,16 @@ public boolean put(final Txn<T> txn, final T key, final T val, final PutFlags...
       txn.checkReady();
       txn.checkWritesAllowed();
     }
+    final PutFlagSet flagSet = flags != null ? flags : PutFlagSet.empty();
     final Pointer transientKey = txn.kv().keyIn(key);
     final Pointer transientVal = txn.kv().valIn(val);
-    final int mask = mask(true, flags);
     final int rc =
-        LIB.mdb_put(txn.pointer(), ptr, txn.kv().pointerKey(), txn.kv().pointerVal(), mask);
+        LIB.mdb_put(
+            txn.pointer(), ptr, txn.kv().pointerKey(), txn.kv().pointerVal(), flagSet.getMask());
     if (rc == MDB_KEYEXIST) {
-      if (isSet(mask, MDB_NOOVERWRITE)) {
+      if (flagSet.isSet(MDB_NOOVERWRITE)) {
         txn.kv().valOut(); // marked as in,out in LMDB C docs
-      } else if (!isSet(mask, MDB_NODUPDATA)) {
+      } else if (!flagSet.isSet(MDB_NODUPDATA)) {
         checkRc(rc);
       }
       return false;
@@ -415,7 +493,7 @@ public T reserve(final Txn<T> txn, final T key, final int size, final PutFlags..
     }
     final Pointer transientKey = txn.kv().keyIn(key);
     final Pointer transientVal = txn.kv().valIn(size);
-    final int flags = mask(true, op) | MDB_RESERVE.getMask();
+    final int flags = mask(op) | MDB_RESERVE.getMask();
     checkRc(LIB.mdb_put(txn.pointer(), ptr, txn.kv().pointerKey(), txn.kv().pointerVal(), flags));
     txn.kv().valOut(); // marked as in,out in LMDB C docs
     ReferenceUtil.reachabilityFence0(transientKey);
@@ -454,6 +532,17 @@ private void clean() {
     cleaned = true;
   }
 
+  @Override
+  public String toString() {
+    String name;
+    try {
+      name = getNameAsString();
+    } catch (Exception e) {
+      name = "?";
+    }
+    return "Dbi{" + "name='" + name + "', dbiFlagSet=" + dbiFlagSet + '}';
+  }
+
   /** The specified DBI was changed unexpectedly. */
   public static final class BadDbiException extends LmdbNativeException {
 
diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
new file mode 100644
index 00000000..bf318f75
--- /dev/null
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -0,0 +1,426 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.Objects;
+
+/**
+ * Staged builder for building a {@link Dbi}
+ *
+ * @param <T> buffer type
+ */
+public class DbiBuilder<T> {
+
+  private final Env<T> env;
+  private final BufferProxy<T> proxy;
+  private final boolean readOnly;
+  private byte[] name;
+
+  DbiBuilder(final Env<T> env, final BufferProxy<T> proxy, final boolean readOnly) {
+    this.env = Objects.requireNonNull(env);
+    this.proxy = Objects.requireNonNull(proxy);
+    this.readOnly = readOnly;
+  }
+
+  /**
+   * Create the {@link Dbi} with the passed name.
+   *
+   * <p>The name will be converted into bytes using {@link StandardCharsets#UTF_8}.
+   *
+   * @param name The name of the database or null for the unnamed database (see also {@link
+   *     DbiBuilder#withoutDbName()})
+   * @return The next builder stage.
+   */
+  public DbiBuilderStage2<T> setDbName(final String name) {
+    // Null name is allowed so no null check
+    final byte[] nameBytes = name == null ? null : name.getBytes(Env.DEFAULT_NAME_CHARSET);
+    return setDbName(nameBytes);
+  }
+
+  /**
+   * Create the {@link Dbi} with the passed name in byte[] form.
+   *
+   * @param name The name of the database in byte form.
+   * @return The next builder stage.
+   */
+  public DbiBuilderStage2<T> setDbName(final byte[] name) {
+    // Null name is allowed so no null check
+    this.name = name;
+    return new DbiBuilderStage2<>(this);
+  }
+
+  /**
+   * Create the {@link Dbi} without a name.
+   *
+   * <p>Equivalent to passing null to {@link DbiBuilder#setDbName(String)} or {@link
+   * DbiBuilder#setDbName(byte[])}.
+   *
+   * <p>Note: The 'unnamed database' is used by LMDB to store the names of named databases, with the
+   * database name being the key. Use of the unnamed database is intended for simple applications
+   * with only one database.
+   *
+   * @return The next builder stage.
+   */
+  public DbiBuilderStage2<T> withoutDbName() {
+    return setDbName((byte[]) null);
+  }
+
+  // --------------------------------------------------------------------------------
+
+  /**
+   * Intermediate builder stage for constructing a {@link Dbi}.
+   *
+   * @param <T> buffer type
+   */
+  public static class DbiBuilderStage2<T> {
+
+    private final DbiBuilder<T> dbiBuilder;
+
+    private ComparatorFactory<T> comparatorFactory;
+    private ComparatorType comparatorType;
+
+    private DbiBuilderStage2(final DbiBuilder<T> dbiBuilder) {
+      this.dbiBuilder = dbiBuilder;
+    }
+
+    /**
+     * This is the <strong>default</strong> choice when it comes to choosing a comparator. If you
+     * are not sure of the implications of the other methods then use this one as it is likely what
+     * you want and also probably the most performant.
+     *
+     * <p>With this option, {@link CursorIterable} will make use of the LmdbJava's default Java-side
+     * comparators when comparing iteration keys to the start/stop keys. LMDB will use its own
+     * comparator for controlling insertion order in the database. The two comparators are
+     * functionally identical.
+     *
+     * <p>This option may be slightly more performant than when using {@link
+     * DbiBuilderStage2#withNativeComparator()} which calls down to LMDB for ALL comparison
+     * operations.
+     *
+     * <p>If you do not intend to use {@link CursorIterable} then it doesn't matter whether you
+     * choose {@link DbiBuilderStage2#withNativeComparator()}, {@link
+     * DbiBuilderStage2#withDefaultComparator()} or {@link
+     * DbiBuilderStage2#withIteratorComparator(ComparatorFactory)} as these comparators will never
+     * be used.
+     *
+     * @return The next builder stage.
+     */
+    public DbiBuilderStage3<T> withDefaultComparator() {
+      this.comparatorType = ComparatorType.DEFAULT;
+      return new DbiBuilderStage3<>(this);
+    }
+
+    /**
+     * With this option, {@link CursorIterable} will call down to LMDB's {@code mdb_cmp} method when
+     * comparing iteration keys to start/stop keys. This ensures LmdbJava is comparing start/stop
+     * keys using the same comparator that is used for insertion order into the db.
+     *
+     * <p>This option may be slightly less performant than when using {@link
+     * DbiBuilderStage2#withDefaultComparator()} as it needs to call down to LMDB to perform the
+     * comparisons, however it guarantees that {@link CursorIterable} key comparison matches LMDB
+     * key comparison.
+     *
+     * <p>If you do not intend to use {@link CursorIterable} then it doesn't matter whether you
+     * choose {@link DbiBuilderStage2#withNativeComparator()}, {@link
+     * DbiBuilderStage2#withDefaultComparator()} or {@link
+     * DbiBuilderStage2#withIteratorComparator(ComparatorFactory)} as these comparators will never
+     * be used.
+     *
+     * @return The next builder stage.
+     */
+    public DbiBuilderStage3<T> withNativeComparator() {
+      this.comparatorType = ComparatorType.NATIVE;
+      return new DbiBuilderStage3<>(this);
+    }
+
+    /**
+     * Provide a java-side {@link Comparator} that LMDB will call back to for <strong>all</strong>
+     * comparison operations. Therefore, it will be called by LMDB to manage database
+     * insertion/iteration order. It will also be used for {@link CursorIterable} start/stop key
+     * comparisons.
+     *
+     * <p>It can be useful if you need to sort your database using some other method, e.g. signed
+     * keys or case-insensitive order. Note, if you need keys stored in reverse order, see {@link
+     * DbiFlags#MDB_REVERSEKEY} and {@link DbiFlags#MDB_REVERSEDUP}.
+     *
+     * <p>As this requires LMDB to call back to java, this will be less performant than using LMDB's
+     * default comparators, but allows for total control over the order in which entries are stored
+     * in the database.
+     *
+     * @param comparatorFactory A factory to create a comparator. {@link
+     *     ComparatorFactory#create(DbiFlagSet)} will be called once during the initialisation of
+     *     the {@link Dbi}. It must not return null.
+     * @return The next builder stage.
+     */
+    public DbiBuilderStage3<T> withCallbackComparator(
+        final ComparatorFactory<T> comparatorFactory) {
+      this.comparatorFactory = Objects.requireNonNull(comparatorFactory);
+      this.comparatorType = ComparatorType.CALLBACK;
+      return new DbiBuilderStage3<>(this);
+    }
+
+    /**
+     * <hr>
+     *
+     * <p><strong>WARNING</strong>: Only use this if you fully understand the risks and
+     * implications. <hr>
+     *
+     * <p>With this option, {@link CursorIterable} will make use of the passed comparator for
+     * comparing iteration keys to start/stop keys. It has <strong>NO</strong> bearing on the
+     * insert/iteration order of the database (which is controlled by LMDB's own comparators).
+     *
+     * <p>It is <strong>vital</strong> that this comparator is functionally identical to the one
+     * used internally in LMDB for insertion/iteration order, else you will see unexpected behaviour
+     * when using {@link CursorIterable}.
+     *
+     * <p>If you do not intend to use {@link CursorIterable} then it doesn't matter whether you
+     * choose {@link DbiBuilderStage2#withNativeComparator()}, {@link
+     * DbiBuilderStage2#withDefaultComparator()} or {@link
+     * DbiBuilderStage2#withIteratorComparator(ComparatorFactory)} as these comparators will never
+     * be used.
+     *
+     * @param comparatorFactory The comparator to use with {@link CursorIterable}. {@link
+     *     ComparatorFactory#create(DbiFlagSet)} will be called once during the initialisation of
+     *     the {@link Dbi}. It must not return null.
+     * @return The next builder stage.
+     */
+    public DbiBuilderStage3<T> withIteratorComparator(
+        final ComparatorFactory<T> comparatorFactory) {
+      this.comparatorFactory = Objects.requireNonNull(comparatorFactory);
+      this.comparatorType = ComparatorType.ITERATOR;
+      return new DbiBuilderStage3<>(this);
+    }
+  }
+
+  // --------------------------------------------------------------------------------
+
+  /**
+   * Final stage builder for constructing a {@link Dbi}.
+   *
+   * @param <T> buffer type
+   */
+  public static class DbiBuilderStage3<T> {
+
+    private final DbiBuilderStage2<T> dbiBuilderStage2;
+    private final AbstractFlagSet.Builder<DbiFlags, DbiFlagSet> flagSetBuilder =
+        DbiFlagSet.builder();
+    private Txn<T> txn = null;
+
+    private DbiBuilderStage3(DbiBuilderStage2<T> dbiBuilderStage2) {
+      this.dbiBuilderStage2 = dbiBuilderStage2;
+    }
+
+    /**
+     * Apply all the dbi flags supplied in dbiFlags.
+     *
+     * <p>Clears all flags currently set by previous calls to {@link
+     * DbiBuilderStage3#setDbiFlags(Collection)}, {@link DbiBuilderStage3#setDbiFlags(DbiFlags...)}
+     * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
+     *
+     * @param dbiFlags to open the database with. A null {@link Collection} will just clear all set
+     *     flags. Null items are ignored.
+     */
+    public DbiBuilderStage3<T> setDbiFlags(final Collection<DbiFlags> dbiFlags) {
+      flagSetBuilder.clear();
+      if (dbiFlags != null) {
+        dbiFlags.stream().filter(Objects::nonNull).forEach(dbiFlags::add);
+      }
+      return this;
+    }
+
+    /**
+     * Apply all the dbi flags supplied in dbiFlags.
+     *
+     * <p>Clears all flags currently set by previous calls to {@link
+     * DbiBuilderStage3#setDbiFlags(Collection)}, {@link DbiBuilderStage3#setDbiFlags(DbiFlags...)}
+     * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
+     *
+     * @param dbiFlags to open the database with. A null array will just clear all set flags. Null
+     *     items are ignored.
+     */
+    public DbiBuilderStage3<T> setDbiFlags(final DbiFlags... dbiFlags) {
+      flagSetBuilder.clear();
+      if (dbiFlags != null) {
+        Arrays.stream(dbiFlags).filter(Objects::nonNull).forEach(this.flagSetBuilder::setFlag);
+      }
+      return this;
+    }
+
+    /**
+     * Apply all the dbi flags supplied in dbiFlags.
+     *
+     * <p>Clears all flags currently set by previous calls to {@link
+     * DbiBuilderStage3#setDbiFlags(Collection)}, {@link DbiBuilderStage3#setDbiFlags(DbiFlags...)}
+     * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
+     *
+     * @param dbiFlagSet to open the database with. A null value will just clear all set flags.
+     */
+    public DbiBuilderStage3<T> setDbiFlags(final DbiFlagSet dbiFlagSet) {
+      flagSetBuilder.clear();
+      if (dbiFlagSet != null) {
+        this.flagSetBuilder.withFlags(dbiFlagSet.getFlags());
+      }
+      return this;
+    }
+
+    /**
+     * Adds a dbiFlag to those flags already added to this builder by {@link
+     * DbiBuilderStage3#setDbiFlags(DbiFlags...)}, {@link DbiBuilderStage3#setDbiFlags(Collection)}
+     * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
+     *
+     * @param dbiFlag to add to any existing flags. A null value is a no-op.
+     * @return this builder instance.
+     */
+    public DbiBuilderStage3<T> addDbiFlag(final DbiFlags dbiFlag) {
+      this.flagSetBuilder.setFlag(dbiFlag);
+      return this;
+    }
+
+    /**
+     * Adds a dbiFlag to those flags already added to this builder by {@link
+     * DbiBuilderStage3#setDbiFlags(DbiFlags...)}, {@link DbiBuilderStage3#setDbiFlags(Collection)}
+     * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
+     *
+     * @param dbiFlagSet to add to any existing flags. A null value is a no-op.
+     * @return this builder instance.
+     */
+    public DbiBuilderStage3<T> addDbiFlags(final DbiFlagSet dbiFlagSet) {
+      if (dbiFlagSet != null) {
+        flagSetBuilder.setFlags(dbiFlagSet.getFlags());
+      }
+      return this;
+    }
+
+    /**
+     * Use the supplied transaction to open the {@link Dbi}.
+     *
+     * <p>The caller MUST commit the transaction after calling {@link DbiBuilderStage3#open()}, in
+     * order to retain the <code>Dbi</code> in the <code>Env</code>.
+     *
+     * <p>If you don't call this method to supply a {@link Txn}, a {@link Txn} will be opened for
+     * the purpose of creating and opening the {@link Dbi}, then closed. Therefore, if you already
+     * have a transaction open, you should supply that to avoid one blocking the other.
+     *
+     * @param txn transaction to use (required; not closed). If the {@link Env} was opened with the
+     *     {@link EnvFlags#MDB_RDONLY_ENV} flag, the {@link Txn} can be read-only, else it needs to
+     *     be a read/write {@link Txn}.
+     * @return this builder instance.
+     */
+    public DbiBuilderStage3<T> setTxn(final Txn<T> txn) {
+      this.txn = Objects.requireNonNull(txn);
+      return this;
+    }
+
+    /**
+     * Construct and open the {@link Dbi}.
+     *
+     * <p>If a {@link Txn} was supplied to the builder, it is the callers responsibility to commit
+     * and close the txn upon return from this method, else the created DB won't be retained.
+     *
+     * @return A newly constructed and opened {@link Dbi}.
+     */
+    public Dbi<T> open() {
+      final DbiBuilder<T> dbiBuilder = dbiBuilderStage2.dbiBuilder;
+      if (txn != null) {
+        return open(txn, dbiBuilder);
+      } else {
+        try (final Txn<T> txn = getTxn(dbiBuilder)) {
+          final Dbi<T> dbi = open(txn, dbiBuilder);
+          // even RO Txns require a commit to retain Dbi in Env
+          txn.commit();
+          return dbi;
+        }
+      }
+    }
+
+    private Txn<T> getTxn(final DbiBuilder<T> dbiBuilder) {
+      return dbiBuilder.readOnly ? dbiBuilder.env.txnRead() : dbiBuilder.env.txnWrite();
+    }
+
+    private Comparator<T> getComparator(
+        final DbiBuilder<T> dbiBuilder,
+        final ComparatorType comparatorType,
+        final DbiFlagSet dbiFlagSet) {
+      Comparator<T> comparator = null;
+      switch (comparatorType) {
+        case DEFAULT:
+          // Get the appropriate default CursorIterable comparator based on the DbiFlags,
+          // e.g. MDB_INTEGERKEY may benefit from an optimised comparator.
+          comparator = dbiBuilder.proxy.getComparator(dbiFlagSet);
+          break;
+        case CALLBACK:
+        case ITERATOR:
+          comparator =
+              Objects.requireNonNull(
+                  dbiBuilderStage2.comparatorFactory.create(dbiFlagSet),
+                  () -> "comparatorFactory returned null");
+          break;
+        case NATIVE:
+          break;
+        default:
+          throw new IllegalStateException("Unexpected comparatorType " + comparatorType);
+      }
+      return comparator;
+    }
+
+    private Dbi<T> open(final Txn<T> txn, final DbiBuilder<T> dbiBuilder) {
+      final DbiFlagSet dbiFlagSet = flagSetBuilder.build();
+      final ComparatorType comparatorType = dbiBuilderStage2.comparatorType;
+      final Comparator<T> comparator = getComparator(dbiBuilder, comparatorType, dbiFlagSet);
+      final boolean useNativeCallback = comparatorType == ComparatorType.CALLBACK;
+      return new Dbi<>(
+          dbiBuilder.env,
+          txn,
+          dbiBuilder.name,
+          comparator,
+          useNativeCallback,
+          dbiBuilder.proxy,
+          dbiFlagSet);
+    }
+  }
+
+  // --------------------------------------------------------------------------------
+
+  private enum ComparatorType {
+    /**
+     * Default Java comparator for {@link CursorIterable} KeyRange testing, LMDB comparator for
+     * insertion/iteration order.
+     */
+    DEFAULT,
+    /** Use LMDB native comparator for everything. */
+    NATIVE,
+    /** Use the supplied custom Java-side comparator for everything. */
+    CALLBACK,
+    /**
+     * Use the supplied custom Java-side comparator for {@link CursorIterable} KeyRange testing,
+     * LMDB comparator for insertion/iteration order.
+     */
+    ITERATOR,
+    ;
+  }
+
+  // --------------------------------------------------------------------------------
+
+  @FunctionalInterface
+  public interface ComparatorFactory<T> {
+
+    Comparator<T> create(final DbiFlagSet dbiFlagSet);
+  }
+}
diff --git a/src/main/java/org/lmdbjava/DbiFlagSet.java b/src/main/java/org/lmdbjava/DbiFlagSet.java
new file mode 100644
index 00000000..6fcdfd37
--- /dev/null
+++ b/src/main/java/org/lmdbjava/DbiFlagSet.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import java.util.Collection;
+import java.util.EnumSet;
+import java.util.Objects;
+
+public interface DbiFlagSet extends FlagSet<DbiFlags> {
+
+  /** An immutable empty {@link DbiFlagSet}. */
+  DbiFlagSet EMPTY = DbiFlagSetImpl.EMPTY;
+
+  /** The set of {@link DbiFlags} that indicate unsigned integer keys are being used. */
+  DbiFlagSet INTEGER_KEY_FLAGS = DbiFlagSet.of(DbiFlags.MDB_INTEGERKEY, DbiFlags.MDB_INTEGERDUP);
+
+  static DbiFlagSet empty() {
+    return DbiFlagSetImpl.EMPTY;
+  }
+
+  static DbiFlagSet of(final DbiFlags dbiFlag) {
+    Objects.requireNonNull(dbiFlag);
+    return dbiFlag;
+  }
+
+  static DbiFlagSet of(final DbiFlags... DbiFlags) {
+    return builder().withFlags(DbiFlags).build();
+  }
+
+  static DbiFlagSet of(final Collection<DbiFlags> DbiFlags) {
+    return builder().withFlags(DbiFlags).build();
+  }
+
+  static AbstractFlagSet.Builder<DbiFlags, DbiFlagSet> builder() {
+    return new AbstractFlagSet.Builder<>(
+        DbiFlags.class, DbiFlagSetImpl::new, dbiFlag -> dbiFlag, () -> DbiFlagSetImpl.EMPTY);
+  }
+
+  // --------------------------------------------------------------------------------
+
+  class DbiFlagSetImpl extends AbstractFlagSet<DbiFlags> implements DbiFlagSet {
+
+    static final DbiFlagSet EMPTY = new EmptyDbiFlagSet();
+
+    private DbiFlagSetImpl(final EnumSet<DbiFlags> flags) {
+      super(flags);
+    }
+  }
+
+  // --------------------------------------------------------------------------------
+
+  class EmptyDbiFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<DbiFlags>
+      implements DbiFlagSet {}
+}
diff --git a/src/main/java/org/lmdbjava/DbiFlags.java b/src/main/java/org/lmdbjava/DbiFlags.java
index 123ec9fd..f8ccbe20 100644
--- a/src/main/java/org/lmdbjava/DbiFlags.java
+++ b/src/main/java/org/lmdbjava/DbiFlags.java
@@ -15,8 +15,11 @@
  */
 package org.lmdbjava;
 
+import java.util.EnumSet;
+import java.util.Set;
+
 /** Flags for use when opening a {@link Dbi}. */
-public enum DbiFlags implements MaskedFlag {
+public enum DbiFlags implements MaskedFlag, DbiFlagSet {
 
   /**
    * Use reverse string keys.
@@ -29,13 +32,26 @@ public enum DbiFlags implements MaskedFlag {
    * Use sorted duplicates.
    *
    * <p>Duplicate keys may be used in the database. Or, from another perspective, keys may have
-   * multiple data items, stored in sorted order. By default keys must be unique and may have only a
-   * single data item.
+   * multiple data items, stored in sorted order. By default, keys must be unique and may have only
+   * a single data item.
+   *
+   * <p>
    */
   MDB_DUPSORT(0x04),
   /**
-   * Numeric keys in native byte order: either unsigned int or size_t. The keys must all be of the
-   * same size.
+   * Numeric keys in native byte order: either unsigned int or size_t. <strong>The keys must all be
+   * of the same size.</strong>
+   *
+   * <p>This is an optimisation that is available when your keys are 4 or 8 byte unsigned numeric
+   * values. There are performance benefits for both ordered and un-ordered puts as compared to not
+   * using this flag.
+   *
+   * <p>When writing the key to the buffer you must write it in native order and subsequently read
+   * any keys retrieved from LMDB (via cursor or get method) also using native order.
+   *
+   * <p>For more information, see <a
+   * href="https://github.com/lmdbjava/lmdbjava/wiki/Keys#numeric-keys">Numeric Keys</a> in the
+   * LmdbJava wiki.
    */
   MDB_INTEGERKEY(0x08),
   /**
@@ -55,14 +71,6 @@ public enum DbiFlags implements MaskedFlag {
    * #MDB_INTEGERKEY} keys.
    */
   MDB_INTEGERDUP(0x20),
-  /**
-   * Compare the <b>numeric</b> keys in native byte order and as unsigned.
-   *
-   * <p>This option is applied only to {@link java.nio.ByteBuffer}, {@link org.agrona.DirectBuffer}
-   * and byte array keys. {@link io.netty.buffer.ByteBuf} keys are always compared in native byte
-   * order and as unsigned.
-   */
-  MDB_UNSIGNEDKEY(0x30, false),
   /**
    * With {@link #MDB_DUPSORT}, use reverse string dups.
    *
@@ -78,15 +86,9 @@ public enum DbiFlags implements MaskedFlag {
   MDB_CREATE(0x4_0000);
 
   private final int mask;
-  private final boolean propagatedToLmdb;
-
-  DbiFlags(final int mask, final boolean propagatedToLmdb) {
-    this.mask = mask;
-    this.propagatedToLmdb = propagatedToLmdb;
-  }
 
   DbiFlags(final int mask) {
-    this(mask, true);
+    this.mask = mask;
   }
 
   @Override
@@ -95,7 +97,27 @@ public int getMask() {
   }
 
   @Override
-  public boolean isPropagatedToLmdb() {
-    return propagatedToLmdb;
+  public Set<DbiFlags> getFlags() {
+    return EnumSet.of(this);
+  }
+
+  @Override
+  public boolean isSet(final DbiFlags flag) {
+    return flag != null && mask == flag.getMask();
+  }
+
+  @Override
+  public int size() {
+    return 1;
+  }
+
+  @Override
+  public boolean isEmpty() {
+    return false;
+  }
+
+  @Override
+  public String toString() {
+    return FlagSet.asString(this);
   }
 }
diff --git a/src/main/java/org/lmdbjava/DirectBufferProxy.java b/src/main/java/org/lmdbjava/DirectBufferProxy.java
index 524b81b8..af918943 100644
--- a/src/main/java/org/lmdbjava/DirectBufferProxy.java
+++ b/src/main/java/org/lmdbjava/DirectBufferProxy.java
@@ -22,6 +22,7 @@
 import static org.lmdbjava.UnsafeAccess.UNSAFE;
 
 import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
 import java.util.ArrayDeque;
 import java.util.Comparator;
 import jnr.ffi.Pointer;
@@ -35,14 +36,6 @@
  * <p>This class requires {@link UnsafeAccess} and Agrona must be in the classpath.
  */
 public final class DirectBufferProxy extends BufferProxy<DirectBuffer> {
-  private static final Comparator<DirectBuffer> signedComparator =
-      (o1, o2) -> {
-        requireNonNull(o1);
-        requireNonNull(o2);
-
-        return o1.compareTo(o2);
-      };
-  private static final Comparator<DirectBuffer> unsignedComparator = DirectBufferProxy::compareBuff;
 
   /**
    * The {@link MutableDirectBuffer} proxy. Guaranteed to never be null, although a class
@@ -58,6 +51,8 @@ public final class DirectBufferProxy extends BufferProxy<DirectBuffer> {
   private static final ThreadLocal<ArrayDeque<DirectBuffer>> BUFFERS =
       withInitial(() -> new ArrayDeque<>(16));
 
+  private static final ByteOrder NATIVE_ORDER = ByteOrder.nativeOrder();
+
   private DirectBufferProxy() {}
 
   /**
@@ -67,7 +62,7 @@ private DirectBufferProxy() {}
    * @param o2 right operand (required)
    * @return as specified by {@link Comparable} interface
    */
-  public static int compareBuff(final DirectBuffer o1, final DirectBuffer o2) {
+  public static int compareLexicographically(final DirectBuffer o1, final DirectBuffer o2) {
     requireNonNull(o1);
     requireNonNull(o2);
 
@@ -95,6 +90,47 @@ public static int compareBuff(final DirectBuffer o1, final DirectBuffer o2) {
     return o1.capacity() - o2.capacity();
   }
 
+  /**
+   * Buffer comparator specifically for 4/8 byte keys that are unsigned ints/longs, i.e. when using
+   * MDB_INTEGER_KEY/MDB_INTEGERDUP. Compares the buffers numerically.
+   *
+   * <p>Both buffer must have 4 or 8 bytes remaining
+   *
+   * @param o1 left operand (required)
+   * @param o2 right operand (required)
+   * @return as specified by {@link Comparable} interface
+   */
+  public static int compareAsIntegerKeys(final DirectBuffer o1, final DirectBuffer o2) {
+    requireNonNull(o1);
+    requireNonNull(o2);
+    // Both buffers should be same len
+    final int len1 = o1.capacity();
+    final int len2 = o2.capacity();
+    if (len1 != len2) {
+      throw new RuntimeException(
+          "Length mismatch, len1: "
+              + len1
+              + ", len2: "
+              + len2
+              + ". Lengths must be identical and either 4 or 8 bytes.");
+    }
+    if (len1 == 8) {
+      final long lw = o1.getLong(0, NATIVE_ORDER);
+      final long rw = o2.getLong(0, NATIVE_ORDER);
+      return Long.compareUnsigned(lw, rw);
+    } else if (len1 == 4) {
+      final int lw = o1.getInt(0, NATIVE_ORDER);
+      final int rw = o2.getInt(0, NATIVE_ORDER);
+      return Integer.compareUnsigned(lw, rw);
+    } else {
+      // size_t and int are likely to be 8bytes and 4bytes respectively on 64bit.
+      // If 32bit then would be 4/2 respectively.
+      // Short.compareUnsigned is not available in Java8.
+      // For now just fall back to our standard comparator
+      return compareLexicographically(o1, o2);
+    }
+  }
+
   @Override
   protected DirectBuffer allocate() {
     final ArrayDeque<DirectBuffer> q = BUFFERS.get();
@@ -109,13 +145,12 @@ protected DirectBuffer allocate() {
   }
 
   @Override
-  protected Comparator<DirectBuffer> getSignedComparator() {
-    return signedComparator;
-  }
-
-  @Override
-  protected Comparator<DirectBuffer> getUnsignedComparator() {
-    return unsignedComparator;
+  public Comparator<DirectBuffer> getComparator(final DbiFlagSet dbiFlagSet) {
+    if (dbiFlagSet.areAnySet(DbiFlagSet.INTEGER_KEY_FLAGS)) {
+      return DirectBufferProxy::compareAsIntegerKeys;
+    } else {
+      return DirectBufferProxy::compareLexicographically;
+    }
   }
 
   @Override
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 3db16119..480ee8b7 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -23,17 +23,20 @@
 import static org.lmdbjava.EnvFlags.MDB_RDONLY_ENV;
 import static org.lmdbjava.Library.LIB;
 import static org.lmdbjava.Library.RUNTIME;
-import static org.lmdbjava.MaskedFlag.isSet;
-import static org.lmdbjava.MaskedFlag.mask;
 import static org.lmdbjava.ResultCodeMapper.checkRc;
-import static org.lmdbjava.TxnFlags.MDB_RDONLY_TXN;
 
 import java.io.File;
 import java.nio.ByteBuffer;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Path;
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.List;
+import java.util.Objects;
 import jnr.ffi.Pointer;
 import jnr.ffi.byref.IntByReference;
 import jnr.ffi.byref.PointerByReference;
@@ -50,6 +53,8 @@ public final class Env<T> implements AutoCloseable {
   /** Java system property name that can be set to disable optional checks. */
   public static final String DISABLE_CHECKS_PROP = "lmdbjava.disable.checks";
 
+  public static final Charset DEFAULT_NAME_CHARSET = StandardCharsets.UTF_8;
+
   /**
    * Indicates whether optional checks should be applied in LmdbJava. Optional checks are only
    * disabled in critical paths (see package-level JavaDocs). Non-critical paths have optional
@@ -98,14 +103,15 @@ public static <T> Builder<T> create(final BufferProxy<T> proxy) {
   }
 
   /**
-   * Opens an environment with a single default database in 0664 mode using the {@link
-   * ByteBufferProxy#PROXY_OPTIMAL}.
-   *
+   * @deprecated Instead use {@link Env#create()} or {@link Env#create(BufferProxy)}
+   *     <p>Opens an environment with a single default database in 0664 mode using the {@link
+   *     ByteBufferProxy#PROXY_OPTIMAL}.
    * @param path file system destination
    * @param size size in megabytes
    * @param flags the flags for this new environment
    * @return env the environment (never null)
    */
+  @Deprecated
   public static Env<ByteBuffer> open(final File path, final int size, final EnvFlags... flags) {
     return new Builder<>(PROXY_OPTIMAL).setMapSize(size * 1_024L * 1_024L).open(path, flags);
   }
@@ -124,6 +130,27 @@ public void close() {
     LIB.mdb_env_close(ptr);
   }
 
+  /**
+   * Copies an LMDB environment to the specified destination path.
+   *
+   * <p>This function may be used to make a backup of an existing environment. No lockfile is
+   * created, since it gets recreated at need.
+   *
+   * <p>If this environment was created using {@link EnvFlags#MDB_NOSUBDIR}, the destination path
+   * must be a directory that exists but contains no files. If {@link EnvFlags#MDB_NOSUBDIR} was
+   * used, the destination path must not exist, but it must be possible to create a file at the
+   * provided path.
+   *
+   * <p>Note: This call can trigger significant file size growth if run in parallel with write
+   * transactions, because it employs a read-only transaction. See long-lived transactions under
+   * "Caveats" in the LMDB native documentation.
+   *
+   * @param path writable destination path as described above
+   */
+  public void copy(final File path) {
+    copy(path, CopyFlagSet.EMPTY);
+  }
+
   /**
    * Copies an LMDB environment to the specified destination path.
    *
@@ -142,11 +169,10 @@ public void close() {
    * @param path writable destination path as described above
    * @param flags special options for this copy
    */
-  public void copy(final File path, final CopyFlags... flags) {
+  public void copy(final File path, final CopyFlagSet flags) {
     requireNonNull(path);
     validatePath(path);
-    final int flagsMask = mask(true, flags);
-    checkRc(LIB.mdb_env_copy2(ptr, path.getAbsolutePath(), flagsMask));
+    checkRc(LIB.mdb_env_copy2(ptr, path.getAbsolutePath(), flags.getMask()));
   }
 
   /**
@@ -242,27 +268,44 @@ public boolean isReadOnly() {
   }
 
   /**
-   * Convenience method that opens a {@link Dbi} with a UTF-8 database name and default {@link
-   * Comparator} that is not invoked from native code.
+   * Open (and optionally creates, if {@link DbiFlags#MDB_CREATE} is set) a {@link Dbi} using a
+   * builder.
    *
+   * @return A new builder instance for creating/opening a {@link Dbi}.
+   */
+  public DbiBuilder<T> buildDbi() {
+    return new DbiBuilder<>(this, proxy, readOnly);
+  }
+
+  /**
    * @param name name of the database (or null if no name is required)
    * @param flags to open the database with
    * @return a database that is ready to use
+   * @deprecated Instead use {@link Env#buildDbi()} Convenience method that opens a {@link Dbi} with
+   *     a UTF-8 database name and default {@link Comparator} that is not invoked from native code.
    */
+  @Deprecated()
   public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
     final byte[] nameBytes = name == null ? null : name.getBytes(UTF_8);
     return openDbi(nameBytes, null, false, flags);
   }
 
   /**
-   * Convenience method that opens a {@link Dbi} with a UTF-8 database name and associated {@link
-   * Comparator} that is not invoked from native code.
-   *
    * @param name name of the database (or null if no name is required)
-   * @param comparator custom comparator callback (or null to use default)
+   * @param comparator custom comparator for cursor start/stop key comparisons. If null, LMDB's
+   *     comparator will be used.
    * @param flags to open the database with
    * @return a database that is ready to use
+   * @deprecated Instead use {@link Env#buildDbi()} Convenience method that opens a {@link Dbi} with
+   *     a UTF-8 database name and associated {@link Comparator} for use by {@link CursorIterable}
+   *     when comparing start/stop keys.
+   *     <p>It is very important that the passed comparator behaves in the same way as the
+   *     comparator LMDB uses for its insertion order (for the type of data that will be stored in
+   *     the database), or you fully understand the implications of them behaving differently.
+   *     LMDB's comparator is unsigned lexicographical, unless {@link DbiFlags#MDB_INTEGERKEY} is
+   *     used.
    */
+  @Deprecated()
   public Dbi<T> openDbi(
       final String name, final Comparator<T> comparator, final DbiFlags... flags) {
     final byte[] nameBytes = name == null ? null : name.getBytes(UTF_8);
@@ -270,15 +313,19 @@ public Dbi<T> openDbi(
   }
 
   /**
-   * Convenience method that opens a {@link Dbi} with a UTF-8 database name and associated {@link
-   * Comparator} that may be invoked from native code if specified.
-   *
    * @param name name of the database (or null if no name is required)
-   * @param comparator custom comparator callback (or null to use default)
-   * @param nativeCb whether native code calls back to the Java comparator
+   * @param comparator custom comparator for cursor start/stop key comparisons and optionally for
+   *     LMDB to call back to. If null, LMDB's comparator will be used.
+   * @param nativeCb whether LMDB native code calls back to the Java comparator
    * @param flags to open the database with
    * @return a database that is ready to use
+   * @deprecated Instead use {@link Env#buildDbi()} Convenience method that opens a {@link Dbi} with
+   *     a UTF-8 database name and associated {@link Comparator}. The comparator will be used by
+   *     {@link CursorIterable} when comparing start/stop keys as a minimum. If nativeCb is {@code
+   *     true}, this comparator will also be called by LMDB to determine insertion/iteration order.
+   *     Calling back to a java comparator may significantly impact performance.
    */
+  @Deprecated()
   public Dbi<T> openDbi(
       final String name,
       final Comparator<T> comparator,
@@ -289,44 +336,43 @@ public Dbi<T> openDbi(
   }
 
   /**
-   * Convenience method that opens a {@link Dbi} with a default {@link Comparator} that is not
-   * invoked from native code.
-   *
    * @param name name of the database (or null if no name is required)
    * @param flags to open the database with
    * @return a database that is ready to use
+   * @deprecated Instead use {@link Env#buildDbi()} <hr> Convenience method that opens a {@link Dbi}
+   *     with a default {@link Comparator} that is not invoked from native code.
    */
+  @Deprecated()
   public Dbi<T> openDbi(final byte[] name, final DbiFlags... flags) {
     return openDbi(name, null, false, flags);
   }
 
   /**
-   * Convenience method that opens a {@link Dbi} with an associated {@link Comparator} that is not
-   * invoked from native code.
-   *
    * @param name name of the database (or null if no name is required)
    * @param comparator custom comparator callback (or null to use LMDB default)
    * @param flags to open the database with
    * @return a database that is ready to use
+   * @deprecated Instead use {@link Env#buildDbi()} <hr> Convenience method that opens a {@link Dbi}
+   *     with an associated {@link Comparator} that is not invoked from native code.
    */
+  @Deprecated()
   public Dbi<T> openDbi(
       final byte[] name, final Comparator<T> comparator, final DbiFlags... flags) {
     return openDbi(name, comparator, false, flags);
   }
 
   /**
-   * Convenience method that opens a {@link Dbi} with an associated {@link Comparator} that may be
-   * invoked from native code if specified.
-   *
-   * <p>This method will automatically commit the private transaction before returning. This ensures
-   * the <code>Dbi</code> is available in the <code>Env</code>.
-   *
    * @param name name of the database (or null if no name is required)
    * @param comparator custom comparator callback (or null to use LMDB default)
    * @param nativeCb whether native code calls back to the Java comparator
    * @param flags to open the database with
    * @return a database that is ready to use
+   * @deprecated Instead use {@link Env#buildDbi()} <hr> Convenience method that opens a {@link Dbi}
+   *     with an associated {@link Comparator} that may be invoked from native code if specified.
+   *     <p>This method will automatically commit the private transaction before returning. This
+   *     ensures the <code>Dbi</code> is available in the <code>Env</code>.
    */
+  @Deprecated()
   public Dbi<T> openDbi(
       final byte[] name,
       final Comparator<T> comparator,
@@ -340,39 +386,40 @@ public Dbi<T> openDbi(
   }
 
   /**
-   * Open the {@link Dbi} using the passed {@link Txn}.
-   *
-   * <p>The caller must commit the transaction after this method returns in order to retain the
-   * <code>Dbi</code> in the <code>Env</code>.
-   *
-   * <p>A {@link Comparator} may be provided when calling this method. Such comparator is primarily
-   * used by {@link CursorIterable} instances. A secondary (but uncommon) use of the comparator is
-   * to act as a callback from the native library if <code>nativeCb</code> is <code>true</code>.
-   * This is usually avoided due to the overhead of native code calling back into Java. It is
-   * instead highly recommended to set the correct {@link DbiFlags} to allow the native library to
-   * correctly order the intended keys.
-   *
-   * <p>A default comparator will be provided if <code>null</code> is passed as the comparator. If a
-   * custom comparator is provided, it must strictly match the lexicographical order of keys in the
-   * native LMDB database.
-   *
-   * <p>This method (and its overloaded convenience variants) must not be called from concurrent
-   * threads.
-   *
    * @param txn transaction to use (required; not closed)
    * @param name name of the database (or null if no name is required)
    * @param comparator custom comparator callback (or null to use LMDB default)
-   * @param nativeCb whether native code should call back to the comparator
+   * @param nativeCb whether native LMDB code should call back to the Java comparator
    * @param flags to open the database with
    * @return a database that is ready to use
+   * @deprecated Instead use {@link Env#buildDbi()} Open the {@link Dbi} using the passed {@link
+   *     Txn}.
+   *     <p>The caller must commit the transaction after this method returns in order to retain the
+   *     <code>Dbi</code> in the <code>Env</code>.
+   *     <p>A {@link Comparator} may be provided when calling this method. Such comparator is
+   *     primarily used by {@link CursorIterable} instances. A secondary (but uncommon) use of the
+   *     comparator is to act as a callback from the native library if <code>nativeCb</code> is
+   *     <code>true</code>. This is usually avoided due to the overhead of native code calling back
+   *     into Java. It is instead highly recommended to set the correct {@link DbiFlags} to allow
+   *     the native library to correctly order the intended keys.
+   *     <p>A default comparator will be provided if <code>null</code> is passed as the comparator.
+   *     If a custom comparator is provided, it must strictly match the lexicographical order of
+   *     keys in the native LMDB database.
+   *     <p>This method (and its overloaded convenience variants) must not be called from concurrent
+   *     threads.
    */
+  @Deprecated()
   public Dbi<T> openDbi(
       final Txn<T> txn,
       final byte[] name,
       final Comparator<T> comparator,
       final boolean nativeCb,
       final DbiFlags... flags) {
-    return new Dbi<>(this, txn, name, comparator, nativeCb, proxy, flags);
+
+    if (nativeCb && comparator == null) {
+      throw new IllegalArgumentException("Is nativeCb is true, you must supply a comparator");
+    }
+    return new Dbi<>(this, txn, name, comparator, nativeCb, proxy, DbiFlagSet.of(flags));
   }
 
   /**
@@ -410,16 +457,40 @@ public void sync(final boolean force) {
   }
 
   /**
-   * Obtain a transaction with the requested parent and flags.
-   *
    * @param parent parent transaction (may be null if no parent)
    * @param flags applicable flags (eg for a reusable, read-only transaction)
    * @return a transaction (never null)
+   * @deprecated Instead use {@link Env#txn(Txn, TxnFlagSet)}
+   *     <p>Obtain a transaction with the requested parent and flags.
    */
+  @Deprecated
   public Txn<T> txn(final Txn<T> parent, final TxnFlags... flags) {
-    if (closed) {
-      throw new AlreadyClosedException();
-    }
+    checkNotClosed();
+    return new Txn<>(this, parent, proxy, TxnFlagSet.of(flags));
+  }
+
+  /**
+   * Obtain a transaction with the requested parent and flags.
+   *
+   * @param parent parent transaction (may be null if no parent)
+   * @return a transaction (never null)
+   */
+  public Txn<T> txn(final Txn<T> parent) {
+    checkNotClosed();
+    return new Txn<>(this, parent, proxy, TxnFlagSet.EMPTY);
+  }
+
+  /**
+   * Obtain a transaction with the requested parent and flags.
+   *
+   * @param parent parent transaction (may be null if no parent)
+   * @param flags applicable flags (e.g. for a reusable, read-only transaction). If the set of flags
+   *     is used frequently it is recommended to hold a static instance of the {@link TxnFlagSet}
+   *     for re-use.
+   * @return a transaction (never null)
+   */
+  public Txn<T> txn(final Txn<T> parent, final TxnFlagSet flags) {
+    checkNotClosed();
     return new Txn<>(this, parent, proxy, flags);
   }
 
@@ -429,7 +500,8 @@ public Txn<T> txn(final Txn<T> parent, final TxnFlags... flags) {
    * @return a read-only transaction
    */
   public Txn<T> txnRead() {
-    return txn(null, MDB_RDONLY_TXN);
+    checkNotClosed();
+    return new Txn<>(this, null, proxy, TxnFlags.MDB_RDONLY_TXN);
   }
 
   /**
@@ -438,7 +510,8 @@ public Txn<T> txnRead() {
    * @return a read-write transaction
    */
   public Txn<T> txnWrite() {
-    return txn(null);
+    checkNotClosed();
+    return new Txn<>(this, null, proxy, TxnFlagSet.EMPTY);
   }
 
   Pointer pointer() {
@@ -507,6 +580,8 @@ public AlreadyOpenException() {
     }
   }
 
+  // --------------------------------------------------------------------------------
+
   /**
    * Builder for configuring and opening Env.
    *
@@ -520,6 +595,8 @@ public static final class Builder<T> {
     private int maxReaders = MAX_READERS_DEFAULT;
     private boolean opened;
     private final BufferProxy<T> proxy;
+    private int mode = 0664;
+    private AbstractFlagSet.Builder<EnvFlags, EnvFlagSet> flagSetBuilder = EnvFlagSet.builder();
 
     Builder(final BufferProxy<T> proxy) {
       requireNonNull(proxy);
@@ -533,8 +610,50 @@ public static final class Builder<T> {
      * @param mode Unix permissions to set on created files and semaphores
      * @param flags the flags for this new environment
      * @return an environment ready for use
+     * @deprecated Instead use {@link Builder#open(Path)}, {@link Builder#setFilePermissions(int)}
+     *     and {@link Builder#setEnvFlags(EnvFlags...)}.
      */
+    @Deprecated
     public Env<T> open(final File path, final int mode, final EnvFlags... flags) {
+      setFilePermissions(mode);
+      setEnvFlags(flags);
+      return open(requireNonNull(path).toPath());
+    }
+
+    /**
+     * Opens the environment.
+     *
+     * @param path file system destination
+     * @return an environment ready for use
+     * @deprecated Instead use {@link Builder#open(Path)}
+     */
+    @Deprecated
+    public Env<T> open(final File path) {
+      return open(requireNonNull(path).toPath());
+    }
+
+    /**
+     * Opens the environment with 0664 mode.
+     *
+     * @param path file system destination
+     * @param flags the flags for this new environment
+     * @return an environment ready for use
+     * @deprecated Instead use {@link Builder#open(Path)} and {@link
+     *     Builder#setEnvFlags(EnvFlags...)}.
+     */
+    @Deprecated
+    public Env<T> open(final File path, final EnvFlags... flags) {
+      setEnvFlags(flags);
+      return open(requireNonNull(path).toPath());
+    }
+
+    /**
+     * Opens the environment.
+     *
+     * @param path file system destination
+     * @return an environment ready for use
+     */
+    public Env<T> open(final Path path) {
       requireNonNull(path);
       if (opened) {
         throw new AlreadyOpenException();
@@ -547,10 +666,10 @@ public Env<T> open(final File path, final int mode, final EnvFlags... flags) {
         checkRc(LIB.mdb_env_set_mapsize(ptr, mapSize));
         checkRc(LIB.mdb_env_set_maxdbs(ptr, maxDbs));
         checkRc(LIB.mdb_env_set_maxreaders(ptr, maxReaders));
-        final int flagsMask = mask(true, flags);
-        final boolean readOnly = isSet(flagsMask, MDB_RDONLY_ENV);
-        final boolean noSubDir = isSet(flagsMask, MDB_NOSUBDIR);
-        checkRc(LIB.mdb_env_open(ptr, path.getAbsolutePath(), flagsMask, mode));
+        final EnvFlagSet flags = flagSetBuilder.build();
+        final boolean readOnly = flags.isSet(MDB_RDONLY_ENV);
+        final boolean noSubDir = flags.isSet(MDB_NOSUBDIR);
+        checkRc(LIB.mdb_env_open(ptr, path.toAbsolutePath().toString(), flags.getMask(), mode));
         return new Env<>(proxy, ptr, readOnly, noSubDir);
       } catch (final LmdbNativeException e) {
         LIB.mdb_env_close(ptr);
@@ -559,18 +678,7 @@ public Env<T> open(final File path, final int mode, final EnvFlags... flags) {
     }
 
     /**
-     * Opens the environment with 0664 mode.
-     *
-     * @param path file system destination
-     * @param flags the flags for this new environment
-     * @return an environment ready for use
-     */
-    public Env<T> open(final File path, final EnvFlags... flags) {
-      return open(path, 0664, flags);
-    }
-
-    /**
-     * Sets the map size.
+     * Sets the map size in bytes.
      *
      * @param mapSize new limit in bytes
      * @return the builder
@@ -613,6 +721,90 @@ public Builder<T> setMaxReaders(final int readers) {
       this.maxReaders = readers;
       return this;
     }
+
+    /**
+     * Sets the Unix file permissions to use on created files and semaphores, e.g. {@code 0664}. If
+     * this method is not called, the default of {@code 0664} will be used.
+     *
+     * @param mode Unix permissions to set on created files and semaphores
+     * @return the builder
+     */
+    public Builder<T> setFilePermissions(final int mode) {
+      if (opened) {
+        throw new AlreadyOpenException();
+      }
+      this.mode = mode;
+      return this;
+    }
+
+    /**
+     * Sets all the flags used to open this {@link Env}.
+     *
+     * @param envFlags The flags to use. Clears any existing flags. A null value results in no flags
+     *     being set.
+     * @return this builder instance.
+     */
+    public Builder<T> setEnvFlags(final Collection<EnvFlags> envFlags) {
+      flagSetBuilder.clear();
+      if (envFlags != null) {
+        envFlags.stream().filter(Objects::nonNull).forEach(envFlags::add);
+      }
+      return this;
+    }
+
+    /**
+     * Sets all the flags used to open this {@link Env}.
+     *
+     * @param envFlags The flags to use. Clears any existing flags. A null value results in no flags
+     *     being set.
+     * @return this builder instance.
+     */
+    public Builder<T> setEnvFlags(final EnvFlags... envFlags) {
+      flagSetBuilder.clear();
+      if (envFlags != null) {
+        Arrays.stream(envFlags).filter(Objects::nonNull).forEach(this.flagSetBuilder::setFlag);
+      }
+      return this;
+    }
+
+    /**
+     * Sets all the flags used to open this {@link Env}.
+     *
+     * @param envFlagSet The flags to use. Clears any existing flags. A null value results in no
+     *     flags being set.
+     * @return this builder instance.
+     */
+    public Builder<T> setEnvFlags(final EnvFlagSet envFlagSet) {
+      flagSetBuilder.clear();
+      if (envFlagSet != null) {
+        this.flagSetBuilder.withFlags(envFlagSet.getFlags());
+      }
+      return this;
+    }
+
+    /**
+     * Adds a single {@link EnvFlags} to any existing flags.
+     *
+     * @param dbiFlag The flag to add to any existing flags. A null value is a no-op.
+     * @return this builder instance.
+     */
+    public Builder<T> addEnvFlag(final EnvFlags dbiFlag) {
+      this.flagSetBuilder.setFlag(dbiFlag);
+      return this;
+    }
+
+    /**
+     * Adds a set of {@link EnvFlags} to any existing flags.
+     *
+     * @param dbiFlagSet The set of flags to add to any existing flags. A null value is a no-op.
+     * @return this builder instance.
+     */
+    public Builder<T> addEnvFlags(final EnvFlagSet dbiFlagSet) {
+      if (dbiFlagSet != null) {
+        flagSetBuilder.setFlags(dbiFlagSet.getFlags());
+      }
+      return this;
+    }
   }
 
   /** File is not a valid LMDB file. */
diff --git a/src/main/java/org/lmdbjava/EnvFlagSet.java b/src/main/java/org/lmdbjava/EnvFlagSet.java
new file mode 100644
index 00000000..2ee90e11
--- /dev/null
+++ b/src/main/java/org/lmdbjava/EnvFlagSet.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import java.util.Collection;
+import java.util.EnumSet;
+import java.util.Objects;
+
+public interface EnvFlagSet extends FlagSet<EnvFlags> {
+
+  EnvFlagSet EMPTY = EnvFlagSetImpl.EMPTY;
+
+  static EnvFlagSet empty() {
+    return EnvFlagSetImpl.EMPTY;
+  }
+
+  static EnvFlagSet of(final EnvFlags envFlag) {
+    Objects.requireNonNull(envFlag);
+    return envFlag;
+  }
+
+  static EnvFlagSet of(final EnvFlags... EnvFlags) {
+    return builder().withFlags(EnvFlags).build();
+  }
+
+  static EnvFlagSet of(final Collection<EnvFlags> EnvFlags) {
+    return builder().withFlags(EnvFlags).build();
+  }
+
+  static AbstractFlagSet.Builder<EnvFlags, EnvFlagSet> builder() {
+    return new AbstractFlagSet.Builder<>(
+        EnvFlags.class, EnvFlagSetImpl::new, envFlag -> envFlag, () -> EnvFlagSetImpl.EMPTY);
+  }
+
+  // --------------------------------------------------------------------------------
+
+  class EnvFlagSetImpl extends AbstractFlagSet<EnvFlags> implements EnvFlagSet {
+
+    static final EnvFlagSet EMPTY = new EmptyEnvFlagSet();
+
+    private EnvFlagSetImpl(final EnumSet<EnvFlags> flags) {
+      super(flags);
+    }
+  }
+
+  // --------------------------------------------------------------------------------
+
+  class EmptyEnvFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<EnvFlags>
+      implements EnvFlagSet {}
+}
diff --git a/src/main/java/org/lmdbjava/EnvFlags.java b/src/main/java/org/lmdbjava/EnvFlags.java
index 4ce555a8..7fb4a29b 100644
--- a/src/main/java/org/lmdbjava/EnvFlags.java
+++ b/src/main/java/org/lmdbjava/EnvFlags.java
@@ -15,8 +15,11 @@
  */
 package org.lmdbjava;
 
+import java.util.EnumSet;
+import java.util.Set;
+
 /** Flags for use when opening the {@link Env}. */
-public enum EnvFlags implements MaskedFlag {
+public enum EnvFlags implements MaskedFlag, EnvFlagSet {
 
   /**
    * Mmap at a fixed address (experimental).
@@ -144,4 +147,29 @@ public enum EnvFlags implements MaskedFlag {
   public int getMask() {
     return mask;
   }
+
+  @Override
+  public Set<EnvFlags> getFlags() {
+    return EnumSet.of(this);
+  }
+
+  @Override
+  public boolean isSet(final EnvFlags flag) {
+    return flag != null && mask == flag.getMask();
+  }
+
+  @Override
+  public int size() {
+    return 1;
+  }
+
+  @Override
+  public boolean isEmpty() {
+    return false;
+  }
+
+  @Override
+  public String toString() {
+    return FlagSet.asString(this);
+  }
 }
diff --git a/src/main/java/org/lmdbjava/FlagSet.java b/src/main/java/org/lmdbjava/FlagSet.java
new file mode 100644
index 00000000..184694e2
--- /dev/null
+++ b/src/main/java/org/lmdbjava/FlagSet.java
@@ -0,0 +1,122 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+/**
+ * A set of flags, each with a bit mask value. Flags can be combined in a set such that the set has
+ * a combined bit mask value.
+ *
+ * @param <T>
+ */
+public interface FlagSet<T extends MaskedFlag> extends Iterable<T> {
+
+  /**
+   * @return The combined mask for this flagSet.
+   */
+  int getMask();
+
+  /**
+   * @return The result of combining the mask of this {@link FlagSet} with the mask of the other
+   *     {@link FlagSet}.
+   */
+  default int getMaskWith(final FlagSet<T> other) {
+    if (other != null) {
+      return MaskedFlag.mask(getMask(), other.getMask());
+    } else {
+      return getMask();
+    }
+  }
+
+  /**
+   * @return The set of flags in this {@link FlagSet}.
+   */
+  Set<T> getFlags();
+
+  /**
+   * @return True if flag is non-null and included in this {@link FlagSet}.
+   */
+  boolean isSet(T flag);
+
+  /**
+   * @return True if at least one of flags are included in thie {@link FlagSet}
+   */
+  default boolean areAnySet(final FlagSet<T> flags) {
+    if (flags == null) {
+      return false;
+    } else {
+      for (final T flag : flags) {
+        if (isSet(flag)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  /**
+   * @return The size of this {@link FlagSet}
+   */
+  default int size() {
+    return getFlags().size();
+  }
+
+  /**
+   * @return True if this {@link FlagSet} is empty.
+   */
+  default boolean isEmpty() {
+    return getFlags().isEmpty();
+  }
+
+  /**
+   * @return The {@link Iterator} (in no particular order) for the flags in this {@link FlagSet}.
+   */
+  default Iterator<T> iterator() {
+    return getFlags().iterator();
+  }
+
+  /** Convert this {@link FlagSet} to a string for use in toString methods. */
+  static <T extends MaskedFlag> String asString(final FlagSet<T> flagSet) {
+    Objects.requireNonNull(flagSet);
+    final String flagsStr =
+        flagSet.getFlags().stream()
+            .sorted(Comparator.comparing(MaskedFlag::getMask))
+            .map(MaskedFlag::name)
+            .collect(Collectors.joining(", "));
+    return "FlagSet{" + "flags=[" + flagsStr + "], mask=" + flagSet.getMask() + '}';
+  }
+
+  static boolean equals(final FlagSet<?> flagSet, final Object other) {
+    if (other instanceof FlagSet) {
+      final FlagSet<?> flagSet2 = (FlagSet<?>) other;
+      if (flagSet == flagSet2) {
+        return true;
+      } else if (flagSet == null) {
+        return false;
+      } else {
+        return flagSet.getMask() == flagSet2.getMask()
+            && Objects.equals(flagSet.getFlags(), flagSet2.getFlags());
+      }
+    } else {
+      return false;
+    }
+  }
+}
diff --git a/src/main/java/org/lmdbjava/Key.java b/src/main/java/org/lmdbjava/Key.java
new file mode 100644
index 00000000..ac25f65d
--- /dev/null
+++ b/src/main/java/org/lmdbjava/Key.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import static java.util.Objects.requireNonNull;
+import static org.lmdbjava.BufferProxy.MDB_VAL_STRUCT_SIZE;
+import static org.lmdbjava.Library.RUNTIME;
+
+import jnr.ffi.Pointer;
+import jnr.ffi.provider.MemoryManager;
+
+/**
+ * Represents off-heap memory holding a key only.
+ *
+ * @param <T> buffer type
+ */
+final class Key<T> implements AutoCloseable {
+
+  private static final MemoryManager MEM_MGR = RUNTIME.getMemoryManager();
+  private boolean closed;
+  private T k;
+  private final BufferProxy<T> proxy;
+  private final Pointer ptrKey;
+  private final long ptrKeyAddr;
+
+  Key(final BufferProxy<T> proxy) {
+    requireNonNull(proxy);
+    this.proxy = proxy;
+    this.k = proxy.allocate();
+    ptrKey = MEM_MGR.allocateTemporary(MDB_VAL_STRUCT_SIZE, false);
+    ptrKeyAddr = ptrKey.address();
+  }
+
+  @Override
+  public void close() {
+    if (closed) {
+      return;
+    }
+    closed = true;
+    proxy.deallocate(k);
+  }
+
+  T key() {
+    return k;
+  }
+
+  void keyIn(final T key) {
+    proxy.in(key, ptrKey);
+  }
+
+  T keyOut() {
+    k = proxy.out(k, ptrKey);
+    return k;
+  }
+
+  Pointer pointer() {
+    return ptrKey;
+  }
+}
diff --git a/src/main/java/org/lmdbjava/KeyRangeType.java b/src/main/java/org/lmdbjava/KeyRangeType.java
index 0514cbf2..4cb1cc9b 100644
--- a/src/main/java/org/lmdbjava/KeyRangeType.java
+++ b/src/main/java/org/lmdbjava/KeyRangeType.java
@@ -345,15 +345,13 @@ CursorOp initialOp() {
    *
    * @param <T> buffer type
    * @param <C> comparator for the buffers
-   * @param start start buffer
-   * @param stop stop buffer
    * @param buffer current key returned by LMDB (may be null)
-   * @param c comparator (required)
+   * @param rangeComparator comparator (required)
    * @return response to this key
    */
   <T, C extends Comparator<T>> IteratorOp iteratorOp(
-      final T start, final T stop, final T buffer, final C c) {
-    requireNonNull(c, "Comparator required");
+      final T buffer, final RangeComparator rangeComparator) {
+    requireNonNull(rangeComparator, "Comparator required");
     if (buffer == null) {
       return TERMINATE;
     }
@@ -363,55 +361,55 @@ <T, C extends Comparator<T>> IteratorOp iteratorOp(
       case FORWARD_AT_LEAST:
         return RELEASE;
       case FORWARD_AT_MOST:
-        return c.compare(buffer, stop) > 0 ? TERMINATE : RELEASE;
+        return rangeComparator.compareToStopKey() > 0 ? TERMINATE : RELEASE;
       case FORWARD_CLOSED:
-        return c.compare(buffer, stop) > 0 ? TERMINATE : RELEASE;
+        return rangeComparator.compareToStopKey() > 0 ? TERMINATE : RELEASE;
       case FORWARD_CLOSED_OPEN:
-        return c.compare(buffer, stop) >= 0 ? TERMINATE : RELEASE;
+        return rangeComparator.compareToStopKey() >= 0 ? TERMINATE : RELEASE;
       case FORWARD_GREATER_THAN:
-        return c.compare(buffer, start) == 0 ? CALL_NEXT_OP : RELEASE;
+        return rangeComparator.compareToStartKey() == 0 ? CALL_NEXT_OP : RELEASE;
       case FORWARD_LESS_THAN:
-        return c.compare(buffer, stop) >= 0 ? TERMINATE : RELEASE;
+        return rangeComparator.compareToStopKey() >= 0 ? TERMINATE : RELEASE;
       case FORWARD_OPEN:
-        if (c.compare(buffer, start) == 0) {
+        if (rangeComparator.compareToStartKey() == 0) {
           return CALL_NEXT_OP;
         }
-        return c.compare(buffer, stop) >= 0 ? TERMINATE : RELEASE;
+        return rangeComparator.compareToStopKey() >= 0 ? TERMINATE : RELEASE;
       case FORWARD_OPEN_CLOSED:
-        if (c.compare(buffer, start) == 0) {
+        if (rangeComparator.compareToStartKey() == 0) {
           return CALL_NEXT_OP;
         }
-        return c.compare(buffer, stop) > 0 ? TERMINATE : RELEASE;
+        return rangeComparator.compareToStopKey() > 0 ? TERMINATE : RELEASE;
       case BACKWARD_ALL:
         return RELEASE;
       case BACKWARD_AT_LEAST:
-        return c.compare(buffer, start) > 0 ? CALL_NEXT_OP : RELEASE; // rewind
+        return rangeComparator.compareToStartKey() > 0 ? CALL_NEXT_OP : RELEASE; // rewind
       case BACKWARD_AT_MOST:
-        return c.compare(buffer, stop) >= 0 ? RELEASE : TERMINATE;
+        return rangeComparator.compareToStopKey() >= 0 ? RELEASE : TERMINATE;
       case BACKWARD_CLOSED:
-        if (c.compare(buffer, start) > 0) {
+        if (rangeComparator.compareToStartKey() > 0) {
           return CALL_NEXT_OP; // rewind
         }
-        return c.compare(buffer, stop) >= 0 ? RELEASE : TERMINATE;
+        return rangeComparator.compareToStopKey() >= 0 ? RELEASE : TERMINATE;
       case BACKWARD_CLOSED_OPEN:
-        if (c.compare(buffer, start) > 0) {
+        if (rangeComparator.compareToStartKey() > 0) {
           return CALL_NEXT_OP; // rewind
         }
-        return c.compare(buffer, stop) > 0 ? RELEASE : TERMINATE;
+        return rangeComparator.compareToStopKey() > 0 ? RELEASE : TERMINATE;
       case BACKWARD_GREATER_THAN:
-        return c.compare(buffer, start) >= 0 ? CALL_NEXT_OP : RELEASE;
+        return rangeComparator.compareToStartKey() >= 0 ? CALL_NEXT_OP : RELEASE;
       case BACKWARD_LESS_THAN:
-        return c.compare(buffer, stop) > 0 ? RELEASE : TERMINATE;
+        return rangeComparator.compareToStopKey() > 0 ? RELEASE : TERMINATE;
       case BACKWARD_OPEN:
-        if (c.compare(buffer, start) >= 0) {
+        if (rangeComparator.compareToStartKey() >= 0) {
           return CALL_NEXT_OP; // rewind
         }
-        return c.compare(buffer, stop) > 0 ? RELEASE : TERMINATE;
+        return rangeComparator.compareToStopKey() > 0 ? RELEASE : TERMINATE;
       case BACKWARD_OPEN_CLOSED:
-        if (c.compare(buffer, start) >= 0) {
+        if (rangeComparator.compareToStartKey() >= 0) {
           return CALL_NEXT_OP; // rewind
         }
-        return c.compare(buffer, stop) >= 0 ? RELEASE : TERMINATE;
+        return rangeComparator.compareToStopKey() >= 0 ? RELEASE : TERMINATE;
       default:
         throw new IllegalStateException("Invalid type");
     }
diff --git a/src/main/java/org/lmdbjava/Library.java b/src/main/java/org/lmdbjava/Library.java
index ef9b9b35..6d8122d2 100644
--- a/src/main/java/org/lmdbjava/Library.java
+++ b/src/main/java/org/lmdbjava/Library.java
@@ -235,6 +235,8 @@ public interface Lmdb {
 
     void mdb_txn_reset(@In Pointer txn);
 
+    int mdb_cmp(@In Pointer txn, @In Pointer dbi, @In Pointer key1, @In Pointer key2);
+
     Pointer mdb_version(IntByReference major, IntByReference minor, IntByReference patch);
   }
 }
diff --git a/src/main/java/org/lmdbjava/MaskedFlag.java b/src/main/java/org/lmdbjava/MaskedFlag.java
index 87deb3c9..400f2f30 100644
--- a/src/main/java/org/lmdbjava/MaskedFlag.java
+++ b/src/main/java/org/lmdbjava/MaskedFlag.java
@@ -17,13 +17,13 @@
 
 import static java.util.Objects.requireNonNull;
 
-import java.util.Objects;
-import java.util.function.Predicate;
-import java.util.stream.Stream;
+import java.util.Collection;
 
 /** Indicates an enum that can provide integers for each of its values. */
 public interface MaskedFlag {
 
+  int EMPTY_MASK = 0;
+
   /**
    * Obtains the integer value for this enum which can be included in a mask.
    *
@@ -32,13 +32,9 @@ public interface MaskedFlag {
   int getMask();
 
   /**
-   * Indicates if the flag must be propagated to the underlying C code of LMDB or not.
-   *
-   * @return the boolean value indicating the propagation
+   * @return The name of the flag.
    */
-  default boolean isPropagatedToLmdb() {
-    return true;
-  }
+  String name();
 
   /**
    * Fetch the integer mask for all presented flags.
@@ -49,67 +45,45 @@ default boolean isPropagatedToLmdb() {
    */
   @SafeVarargs
   static <M extends MaskedFlag> int mask(final M... flags) {
-    return mask(false, flags);
+    if (flags == null || flags.length == 0) {
+      return EMPTY_MASK;
+    } else {
+      int result = EMPTY_MASK;
+      for (MaskedFlag flag : flags) {
+        if (flag == null) {
+          continue;
+        }
+        result |= flag.getMask();
+      }
+      return result;
+    }
   }
 
-  /**
-   * Fetch the integer mask for all presented flags.
-   *
-   * @param <M> flag type
-   * @param flags to mask (null or empty returns zero)
-   * @return the integer mask for use in C
-   */
-  static <M extends MaskedFlag> int mask(final Stream<M> flags) {
-    return mask(false, flags);
+  /** Combine the two masks into a single mask value, i.e. when combining two {@link FlagSet}s. */
+  static <M extends MaskedFlag> int mask(final int mask1, final int mask2) {
+    return mask1 | mask2;
   }
 
   /**
    * Fetch the integer mask for the presented flags.
    *
    * @param <M> flag type
-   * @param onlyPropagatedToLmdb if to include only the flags which are also propagate to the C code
-   *     or all of them
    * @param flags to mask (null or empty returns zero)
    * @return the integer mask for use in C
    */
-  @SafeVarargs
-  static <M extends MaskedFlag> int mask(final boolean onlyPropagatedToLmdb, final M... flags) {
-    if (flags == null || flags.length == 0) {
-      return 0;
-    }
-
-    int result = 0;
-    for (final M flag : flags) {
-      if (flag == null) {
-        continue;
-      }
-      if (!onlyPropagatedToLmdb || flag.isPropagatedToLmdb()) {
+  static <M extends MaskedFlag> int mask(final Collection<M> flags) {
+    if (flags == null || flags.isEmpty()) {
+      return EMPTY_MASK;
+    } else {
+      int result = EMPTY_MASK;
+      for (MaskedFlag flag : flags) {
+        if (flag == null) {
+          continue;
+        }
         result |= flag.getMask();
       }
+      return result;
     }
-    return result;
-  }
-
-  /**
-   * Fetch the integer mask for all presented flags.
-   *
-   * @param <M> flag type
-   * @param onlyPropagatedToLmdb if to include only the flags which are also propagate to the C code
-   *     or all of them
-   * @param flags to mask
-   * @return the integer mask for use in C
-   */
-  static <M extends MaskedFlag> int mask(
-      final boolean onlyPropagatedToLmdb, final Stream<M> flags) {
-    final Predicate<M> filter = onlyPropagatedToLmdb ? MaskedFlag::isPropagatedToLmdb : f -> true;
-
-    return flags == null
-        ? 0
-        : flags
-            .filter(Objects::nonNull)
-            .filter(filter)
-            .map(M::getMask)
-            .reduce(0, (f1, f2) -> f1 | f2);
   }
 
   /**
diff --git a/src/main/java/org/lmdbjava/PutFlagSet.java b/src/main/java/org/lmdbjava/PutFlagSet.java
new file mode 100644
index 00000000..be34f654
--- /dev/null
+++ b/src/main/java/org/lmdbjava/PutFlagSet.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import java.util.Collection;
+import java.util.EnumSet;
+import java.util.Objects;
+
+public interface PutFlagSet extends FlagSet<PutFlags> {
+
+  PutFlagSet EMPTY = PutFlagSetImpl.EMPTY;
+
+  static PutFlagSet empty() {
+    return PutFlagSetImpl.EMPTY;
+  }
+
+  static PutFlagSet of(final PutFlags putFlag) {
+    Objects.requireNonNull(putFlag);
+    return putFlag;
+  }
+
+  static PutFlagSet of(final PutFlags... putFlags) {
+    return builder().withFlags(putFlags).build();
+  }
+
+  static PutFlagSet of(final Collection<PutFlags> putFlags) {
+    return builder().withFlags(putFlags).build();
+  }
+
+  static AbstractFlagSet.Builder<PutFlags, PutFlagSet> builder() {
+    return new AbstractFlagSet.Builder<>(
+        PutFlags.class, PutFlagSetImpl::new, putFlag -> putFlag, EmptyPutFlagSet::new);
+  }
+
+  // --------------------------------------------------------------------------------
+
+  class PutFlagSetImpl extends AbstractFlagSet<PutFlags> implements PutFlagSet {
+
+    public static final PutFlagSet EMPTY = new EmptyPutFlagSet();
+
+    private PutFlagSetImpl(final EnumSet<PutFlags> flags) {
+      super(flags);
+    }
+  }
+
+  // --------------------------------------------------------------------------------
+
+  class EmptyPutFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<PutFlags>
+      implements PutFlagSet {}
+}
diff --git a/src/main/java/org/lmdbjava/PutFlags.java b/src/main/java/org/lmdbjava/PutFlags.java
index 809103de..03fa916a 100644
--- a/src/main/java/org/lmdbjava/PutFlags.java
+++ b/src/main/java/org/lmdbjava/PutFlags.java
@@ -15,8 +15,11 @@
  */
 package org.lmdbjava;
 
+import java.util.EnumSet;
+import java.util.Set;
+
 /** Flags for use when performing a "put". */
-public enum PutFlags implements MaskedFlag {
+public enum PutFlags implements MaskedFlag, PutFlagSet {
 
   /** For put: Don't write if the key already exists. */
   MDB_NOOVERWRITE(0x10),
@@ -49,4 +52,29 @@ public enum PutFlags implements MaskedFlag {
   public int getMask() {
     return mask;
   }
+
+  @Override
+  public Set<PutFlags> getFlags() {
+    return EnumSet.of(this);
+  }
+
+  @Override
+  public boolean isSet(PutFlags flag) {
+    return flag != null && mask == flag.getMask();
+  }
+
+  @Override
+  public int size() {
+    return 1;
+  }
+
+  @Override
+  public boolean isEmpty() {
+    return false;
+  }
+
+  @Override
+  public String toString() {
+    return FlagSet.asString(this);
+  }
 }
diff --git a/src/main/java/org/lmdbjava/RangeComparator.java b/src/main/java/org/lmdbjava/RangeComparator.java
new file mode 100644
index 00000000..f2626a59
--- /dev/null
+++ b/src/main/java/org/lmdbjava/RangeComparator.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+/** For comparing a cursor's current key against a {@link KeyRange}'s start/stop key. */
+interface RangeComparator extends AutoCloseable {
+
+  /**
+   * Compare the cursor's current key to the range start key. Equivalent to compareTo(currentKey,
+   * startKey)
+   */
+  int compareToStartKey();
+
+  /**
+   * Compare the cursor's current key to the range stop key. Equivalent to compareTo(currentKey,
+   * stopKey)
+   */
+  int compareToStopKey();
+}
diff --git a/src/main/java/org/lmdbjava/Txn.java b/src/main/java/org/lmdbjava/Txn.java
index 05e8ce06..432b47a8 100644
--- a/src/main/java/org/lmdbjava/Txn.java
+++ b/src/main/java/org/lmdbjava/Txn.java
@@ -20,8 +20,6 @@
 import static org.lmdbjava.Env.SHOULD_CHECK;
 import static org.lmdbjava.Library.LIB;
 import static org.lmdbjava.Library.RUNTIME;
-import static org.lmdbjava.MaskedFlag.isSet;
-import static org.lmdbjava.MaskedFlag.mask;
 import static org.lmdbjava.ResultCodeMapper.checkRc;
 import static org.lmdbjava.Txn.State.DONE;
 import static org.lmdbjava.Txn.State.READY;
@@ -44,13 +42,14 @@ public final class Txn<T> implements AutoCloseable {
   private final Pointer ptr;
   private final boolean readOnly;
   private final Env<T> env;
+  private final TxnFlagSet flags;
   private State state;
 
-  Txn(final Env<T> env, final Txn<T> parent, final BufferProxy<T> proxy, final TxnFlags... flags) {
+  Txn(final Env<T> env, final Txn<T> parent, final BufferProxy<T> proxy, final TxnFlagSet flags) {
+    this.flags = flags != null ? flags : TxnFlagSet.EMPTY;
     this.proxy = proxy;
     this.keyVal = proxy.keyVal();
-    final int flagsMask = mask(true, flags);
-    this.readOnly = isSet(flagsMask, MDB_RDONLY_TXN);
+    this.readOnly = this.flags.isSet(MDB_RDONLY_TXN);
     if (env.isReadOnly() && !this.readOnly) {
       throw new EnvIsReadOnly();
     }
@@ -61,7 +60,7 @@ public final class Txn<T> implements AutoCloseable {
     }
     final Pointer txnPtr = allocateDirect(RUNTIME, ADDRESS);
     final Pointer txnParentPtr = parent == null ? null : parent.ptr;
-    checkRc(LIB.mdb_txn_begin(env.pointer(), txnParentPtr, flagsMask, txnPtr));
+    checkRc(LIB.mdb_txn_begin(env.pointer(), txnParentPtr, this.flags.getMask(), txnPtr));
     ptr = txnPtr.getPointer(0);
 
     state = READY;
@@ -164,7 +163,7 @@ public void renew() {
   }
 
   /**
-   * Aborts this read-only transaction and resets the transaction handle so it can be reused upon
+   * Aborts this read-only transaction and resets the transaction handle, so it can be reused upon
    * calling {@link #renew()}.
    */
   public void reset() {
diff --git a/src/main/java/org/lmdbjava/TxnFlagSet.java b/src/main/java/org/lmdbjava/TxnFlagSet.java
new file mode 100644
index 00000000..8cfe61f9
--- /dev/null
+++ b/src/main/java/org/lmdbjava/TxnFlagSet.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import java.util.EnumSet;
+import java.util.Objects;
+
+public interface TxnFlagSet extends FlagSet<TxnFlags> {
+
+  TxnFlagSet EMPTY = TxnFlagSetImpl.EMPTY;
+
+  static TxnFlagSet empty() {
+    return TxnFlagSetImpl.EMPTY;
+  }
+
+  static TxnFlagSet of(final TxnFlags putFlag) {
+    Objects.requireNonNull(putFlag);
+    return new SingleTxnFlagSet(putFlag);
+  }
+
+  static TxnFlagSet of(final TxnFlags... TxnFlags) {
+    return builder().withFlags(TxnFlags).build();
+  }
+
+  static AbstractFlagSet.Builder<TxnFlags, TxnFlagSet> builder() {
+    return new AbstractFlagSet.Builder<>(
+        TxnFlags.class, TxnFlagSetImpl::new, SingleTxnFlagSet::new, () -> TxnFlagSetImpl.EMPTY);
+  }
+
+  // --------------------------------------------------------------------------------
+
+  class TxnFlagSetImpl extends AbstractFlagSet<TxnFlags> implements TxnFlagSet {
+
+    static final TxnFlagSet EMPTY = new EmptyTxnFlagSet();
+
+    private TxnFlagSetImpl(final EnumSet<TxnFlags> flags) {
+      super(flags);
+    }
+  }
+
+  // --------------------------------------------------------------------------------
+
+  class SingleTxnFlagSet extends AbstractFlagSet.AbstractSingleFlagSet<TxnFlags>
+      implements TxnFlagSet {
+
+    SingleTxnFlagSet(final TxnFlags flag) {
+      super(flag);
+    }
+  }
+
+  // --------------------------------------------------------------------------------
+
+  class EmptyTxnFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<TxnFlags>
+      implements TxnFlagSet {}
+}
diff --git a/src/main/java/org/lmdbjava/TxnFlags.java b/src/main/java/org/lmdbjava/TxnFlags.java
index 26caf6f1..94112957 100644
--- a/src/main/java/org/lmdbjava/TxnFlags.java
+++ b/src/main/java/org/lmdbjava/TxnFlags.java
@@ -15,8 +15,12 @@
  */
 package org.lmdbjava;
 
+import java.util.EnumSet;
+import java.util.Set;
+
 /** Flags for use when creating a {@link Txn}. */
-public enum TxnFlags implements MaskedFlag {
+public enum TxnFlags implements MaskedFlag, TxnFlagSet {
+
   /** Read only. */
   MDB_RDONLY_TXN(0x2_0000);
 
@@ -30,4 +34,29 @@ public enum TxnFlags implements MaskedFlag {
   public int getMask() {
     return mask;
   }
+
+  @Override
+  public Set<TxnFlags> getFlags() {
+    return EnumSet.of(this);
+  }
+
+  @Override
+  public boolean isSet(final TxnFlags flag) {
+    return flag != null && mask == flag.getMask();
+  }
+
+  @Override
+  public int size() {
+    return 1;
+  }
+
+  @Override
+  public boolean isEmpty() {
+    return false;
+  }
+
+  @Override
+  public String toString() {
+    return FlagSet.asString(this);
+  }
 }
diff --git a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
index d5638fe2..332598fe 100644
--- a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
+++ b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
@@ -36,9 +36,18 @@
 
 import java.lang.reflect.Field;
 import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
 import java.nio.file.Path;
+import java.time.Duration;
+import java.time.Instant;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.Random;
+import java.util.Set;
 import jnr.ffi.Pointer;
 import jnr.ffi.provider.MemoryManager;
+import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.Test;
 import org.lmdbjava.ByteBufferProxy.BufferMustBeDirectException;
 import org.lmdbjava.Env.ReadersFullException;
@@ -54,8 +63,13 @@ void buffersMustBeDirect() {
             () -> {
               try (final TempDir tempDir = new TempDir()) {
                 final Path dir = tempDir.createTempDir();
-                try (final Env<ByteBuffer> env = create().setMaxReaders(1).open(dir.toFile())) {
-                  final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+                try (Env<ByteBuffer> env = create().setMaxReaders(1).open(dir)) {
+                  final Dbi<ByteBuffer> db =
+                      env.buildDbi()
+                          .setDbName(DB_1)
+                          .withDefaultComparator()
+                          .setDbiFlags(MDB_CREATE)
+                          .open();
                   final ByteBuffer key = allocate(100);
                   key.putInt(1).flip();
                   final ByteBuffer val = allocate(100);
@@ -132,6 +146,105 @@ void unsafeIsDefault() {
     assertThat(v.getClass().getSimpleName()).startsWith("Unsafe");
   }
 
+  /**
+   * For 100 rounds of 5,000,000 comparisons compareAsIntegerKeys: PT1.600525631S
+   * compareLexicographically: PT3.381935001S
+   */
+  @Test
+  public void comparatorPerformance() {
+    final Random random = new Random();
+    final ByteBuffer buffer1 = ByteBuffer.allocateDirect(Long.BYTES);
+    final ByteBuffer buffer2 = ByteBuffer.allocateDirect(Long.BYTES);
+    buffer1.limit(Long.BYTES);
+    buffer2.limit(Long.BYTES);
+    final long[] values = random.longs(5_000_000).toArray();
+
+    Instant time = Instant.now();
+    int x = 0;
+    for (int rounds = 0; rounds < 100; rounds++) {
+      for (int i = 1; i < values.length; i++) {
+        buffer1.order(ByteOrder.nativeOrder()).putLong(0, values[i - 1]);
+        buffer2.order(ByteOrder.nativeOrder()).putLong(0, values[i]);
+        final int result =
+            ByteBufferProxy.AbstractByteBufferProxy.compareAsIntegerKeys(buffer1, buffer2);
+        x += result;
+      }
+    }
+    System.out.println("compareAsIntegerKeys: " + Duration.between(time, Instant.now()));
+
+    time = Instant.now();
+    x = 0;
+    for (int rounds = 0; rounds < 100; rounds++) {
+      for (int i = 1; i < values.length; i++) {
+        buffer1.order(BIG_ENDIAN).putLong(0, values[i - 1]);
+        buffer2.order(BIG_ENDIAN).putLong(0, values[i]);
+        final int result =
+            ByteBufferProxy.AbstractByteBufferProxy.compareLexicographically(buffer1, buffer2);
+        x += result;
+      }
+    }
+    System.out.println("compareLexicographically: " + Duration.between(time, Instant.now()));
+  }
+
+  @Test
+  public void verifyComparators() {
+    final Random random = new Random(203948);
+    final ByteBuffer buffer1native =
+        ByteBuffer.allocateDirect(Long.BYTES).order(ByteOrder.nativeOrder());
+    final ByteBuffer buffer2native =
+        ByteBuffer.allocateDirect(Long.BYTES).order(ByteOrder.nativeOrder());
+    final ByteBuffer buffer1be = ByteBuffer.allocateDirect(Long.BYTES).order(BIG_ENDIAN);
+    final ByteBuffer buffer2be = ByteBuffer.allocateDirect(Long.BYTES).order(BIG_ENDIAN);
+    buffer1native.limit(Long.BYTES);
+    buffer2native.limit(Long.BYTES);
+    buffer1be.limit(Long.BYTES);
+    buffer2be.limit(Long.BYTES);
+    final long[] values = random.longs().filter(i -> i >= 0).limit(5_000_000).toArray();
+    //    System.out.println("stats: " + Arrays.stream(values)
+    //        .summaryStatistics()
+    //        .toString());
+
+    final LinkedHashMap<String, Comparator<ByteBuffer>> comparators = new LinkedHashMap<>();
+    comparators.put(
+        "compareAsIntegerKeys", ByteBufferProxy.AbstractByteBufferProxy::compareAsIntegerKeys);
+    comparators.put(
+        "compareLexicographically",
+        ByteBufferProxy.AbstractByteBufferProxy::compareLexicographically);
+
+    final LinkedHashMap<String, Integer> results = new LinkedHashMap<>(comparators.size());
+    final Set<Integer> uniqueResults = new HashSet<>(comparators.size());
+
+    for (int i = 1; i < values.length; i++) {
+      final long val1 = values[i - 1];
+      final long val2 = values[i];
+      buffer1native.putLong(0, val1);
+      buffer2native.putLong(0, val2);
+      buffer1be.putLong(0, val1);
+      buffer2be.putLong(0, val2);
+      uniqueResults.clear();
+
+      // Make sure all comparators give the same result for the same inputs
+      comparators.forEach(
+          (name, comparator) -> {
+            final int result;
+            // IntegerKey comparator expects keys to have been written in native order so need
+            // different buffers.
+            if (name.equals("compareAsIntegerKeys")) {
+              result = comparator.compare(buffer1native, buffer2native);
+            } else {
+              result = comparator.compare(buffer1be, buffer2be);
+            }
+            results.put(name, result);
+            uniqueResults.add(result);
+          });
+
+      if (uniqueResults.size() != 1) {
+        Assertions.fail(
+            "Comparator mismatch for values: " + val1 + " and " + val2 + ". Results: " + results);
+      }
+    }
+  }
+
   private void checkInOut(final BufferProxy<ByteBuffer> v) {
     // allocate a buffer larger than max key size
     final ByteBuffer b = allocateDirect(1_000);
diff --git a/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java b/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java
new file mode 100644
index 00000000..00c0ce28
--- /dev/null
+++ b/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java
@@ -0,0 +1,357 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.lmdbjava;
+
+import static io.netty.buffer.PooledByteBufAllocator.DEFAULT;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.lmdbjava.ByteBufProxy.PROXY_NETTY;
+import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
+import static org.lmdbjava.ComparatorTest.ComparatorResult.EQUAL_TO;
+import static org.lmdbjava.ComparatorTest.ComparatorResult.GREATER_THAN;
+import static org.lmdbjava.ComparatorTest.ComparatorResult.LESS_THAN;
+import static org.lmdbjava.ComparatorTest.ComparatorResult.get;
+import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
+
+import io.netty.buffer.ByteBuf;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.Comparator;
+import java.util.Random;
+import java.util.stream.Stream;
+import org.agrona.DirectBuffer;
+import org.agrona.concurrent.UnsafeBuffer;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+/** Tests comparator functions are consistent across buffers. */
+public final class ComparatorIntegerKeyTest {
+
+  static Stream<Arguments> comparatorProvider() {
+    return Stream.of(
+        Arguments.argumentSet("LongRunner", new DirectBufferRunner()),
+        Arguments.argumentSet("DirectBufferRunner", new DirectBufferRunner()),
+        Arguments.argumentSet("ByteBufferRunner", new ByteBufferRunner()),
+        Arguments.argumentSet("NettyRunner", new NettyRunner()));
+  }
+
+  private static byte[] buffer(final int... bytes) {
+    final byte[] array = new byte[bytes.length];
+    for (int i = 0; i < bytes.length; i++) {
+      array[i] = (byte) bytes[i];
+    }
+    return array;
+  }
+
+  @ParameterizedTest
+  @MethodSource("comparatorProvider")
+  void testLong(final ComparatorRunner comparator) {
+
+    assertThat(get(comparator.compare(0L, 0L))).isEqualTo(EQUAL_TO);
+    assertThat(get(comparator.compare(Long.MAX_VALUE, Long.MAX_VALUE))).isEqualTo(EQUAL_TO);
+
+    assertThat(get(comparator.compare(0L, 1L))).isEqualTo(LESS_THAN);
+    assertThat(get(comparator.compare(0L, Long.MAX_VALUE))).isEqualTo(LESS_THAN);
+    assertThat(get(comparator.compare(0L, 10L))).isEqualTo(LESS_THAN);
+    assertThat(get(comparator.compare(10L, 100L))).isEqualTo(LESS_THAN);
+    assertThat(get(comparator.compare(10L, 100L))).isEqualTo(LESS_THAN);
+    assertThat(get(comparator.compare(10L, 1000L))).isEqualTo(LESS_THAN);
+
+    assertThat(get(comparator.compare(1L, 0L))).isEqualTo(GREATER_THAN);
+    assertThat(get(comparator.compare(Long.MAX_VALUE, 0L))).isEqualTo(GREATER_THAN);
+  }
+
+  @ParameterizedTest
+  @MethodSource("comparatorProvider")
+  void testInt(final ComparatorRunner comparator) {
+
+    assertThat(get(comparator.compare(0, 0))).isEqualTo(EQUAL_TO);
+    assertThat(get(comparator.compare(Integer.MAX_VALUE, Integer.MAX_VALUE))).isEqualTo(EQUAL_TO);
+
+    assertThat(get(comparator.compare(0, 1))).isEqualTo(LESS_THAN);
+    assertThat(get(comparator.compare(0, Integer.MAX_VALUE))).isEqualTo(LESS_THAN);
+    assertThat(get(comparator.compare(0, 10))).isEqualTo(LESS_THAN);
+    assertThat(get(comparator.compare(10, 100))).isEqualTo(LESS_THAN);
+    assertThat(get(comparator.compare(10, 100))).isEqualTo(LESS_THAN);
+    assertThat(get(comparator.compare(10, 1000))).isEqualTo(LESS_THAN);
+
+    assertThat(get(comparator.compare(1, 0))).isEqualTo(GREATER_THAN);
+    assertThat(get(comparator.compare(Integer.MAX_VALUE, 0))).isEqualTo(GREATER_THAN);
+  }
+
+  @ParameterizedTest
+  @MethodSource("comparatorProvider")
+  void testRandomLong(final ComparatorRunner runner) {
+    final Random random = new Random(3239480);
+
+    // 5mil random longs to compare
+    final long[] values = random.longs().filter(i -> i >= 0).limit(5_000_000).toArray();
+
+    for (int i = 1; i < values.length; i++) {
+      final long long1 = values[i - 1];
+      final long long2 = values[i];
+      // Make sure the comparator under test gives the same outcome as just comparing two longs
+      final ComparatorTest.ComparatorResult result = get(runner.compare(long1, long2));
+      final ComparatorTest.ComparatorResult expectedResult = get(Long.compare(long1, long2));
+
+      assertThat(result)
+          .withFailMessage(
+              () ->
+                  "Compare mismatch - long1: "
+                      + long1
+                      + ", long2: "
+                      + long2
+                      + ", expected: "
+                      + expectedResult
+                      + ", actual: "
+                      + result)
+          .isEqualTo(expectedResult);
+
+      final ComparatorTest.ComparatorResult result2 = get(runner.compare(long2, long1));
+      final ComparatorTest.ComparatorResult expectedResult2 = expectedResult.opposite();
+
+      assertThat(result)
+          .withFailMessage(
+              () ->
+                  "Compare mismatch for - long2: "
+                      + long2
+                      + ", long1: "
+                      + long1
+                      + ", expected2: "
+                      + expectedResult2
+                      + ", actual2: "
+                      + result2)
+          .isEqualTo(expectedResult);
+    }
+  }
+
+  @ParameterizedTest
+  @MethodSource("comparatorProvider")
+  void testRandomInt(final ComparatorRunner runner) {
+    final Random random = new Random(3239480);
+
+    // 5mil random ints to compare
+    final int[] values = random.ints().filter(i -> i >= 0).limit(5_000_000).toArray();
+
+    for (int i = 1; i < values.length; i++) {
+      final int int1 = values[i - 1];
+      final int int2 = values[i];
+      // Make sure the comparator under test gives the same outcome as just comparing two ints
+      final ComparatorTest.ComparatorResult result = get(runner.compare(int1, int2));
+      final ComparatorTest.ComparatorResult expectedResult = get(Integer.compare(int1, int2));
+
+      assertThat(result)
+          .withFailMessage(
+              () ->
+                  "Compare mismatch for - int1: "
+                      + int1
+                      + ", int2: "
+                      + int2
+                      + ", expected: "
+                      + expectedResult
+                      + ", actual: "
+                      + result)
+          .isEqualTo(expectedResult);
+
+      final ComparatorTest.ComparatorResult result2 = get(runner.compare(int2, int1));
+      final ComparatorTest.ComparatorResult expectedResult2 = expectedResult.opposite();
+
+      assertThat(result)
+          .withFailMessage(
+              () ->
+                  "Compare mismatch for - int2: "
+                      + int2
+                      + ", int1: "
+                      + int1
+                      + ", expected2: "
+                      + expectedResult2
+                      + ", actual2: "
+                      + result2)
+          .isEqualTo(expectedResult);
+    }
+  }
+
+  // --------------------------------------------------------------------------------
+
+  /** Tests {@link ByteBufferProxy}. */
+  private static final class ByteBufferRunner implements ComparatorRunner {
+
+    private static final Comparator<ByteBuffer> COMPARATOR =
+        PROXY_OPTIMAL.getComparator(DbiFlags.MDB_INTEGERKEY);
+
+    @Override
+    public int compare(long long1, long long2) {
+      // Convert arrays to buffers that are larger than the array, with
+      // limit set at the array length. One buffer bigger than the other.
+      ByteBuffer o1b = longToBuffer(long1, Long.BYTES * 3);
+      ByteBuffer o2b = longToBuffer(long2, Long.BYTES * 2);
+      final int result = COMPARATOR.compare(o1b, o2b);
+
+      // Now swap which buffer is bigger
+      o1b = longToBuffer(long1, Long.BYTES * 2);
+      o2b = longToBuffer(long2, Long.BYTES * 3);
+      final int result2 = COMPARATOR.compare(o1b, o2b);
+
+      assertThat(result2).isEqualTo(result);
+
+      // Now try with buffers sized to the array.
+      o1b = longToBuffer(long1, Long.BYTES);
+      o2b = longToBuffer(long2, Long.BYTES);
+      final int result3 = COMPARATOR.compare(o1b, o2b);
+
+      assertThat(result3).isEqualTo(result);
+      return result;
+    }
+
+    @Override
+    public int compare(int int1, int int2) {
+      // Convert arrays to buffers that are larger than the array, with
+      // limit set at the array length. One buffer bigger than the other.
+      ByteBuffer o1b = intToBuffer(int1, Integer.BYTES * 3);
+      ByteBuffer o2b = intToBuffer(int2, Integer.BYTES * 2);
+      final int result = COMPARATOR.compare(o1b, o2b);
+
+      // Now swap which buffer is bigger
+      o1b = intToBuffer(int1, Integer.BYTES * 2);
+      o2b = intToBuffer(int2, Integer.BYTES * 3);
+      final int result2 = COMPARATOR.compare(o1b, o2b);
+
+      assertThat(result2).isEqualTo(result);
+
+      // Now try with buffers sized to the array.
+      o1b = intToBuffer(int1, Integer.BYTES);
+      o2b = intToBuffer(int2, Integer.BYTES);
+      final int result3 = COMPARATOR.compare(o1b, o2b);
+
+      assertThat(result3).isEqualTo(result);
+      return result;
+    }
+
+    private ByteBuffer longToBuffer(final long val, final int bufferCapacity) {
+      final ByteBuffer byteBuffer = ByteBuffer.allocate(bufferCapacity);
+      byteBuffer.order(ByteOrder.nativeOrder());
+      byteBuffer.putLong(0, val);
+      byteBuffer.limit(Long.BYTES);
+      byteBuffer.position(0);
+      return byteBuffer;
+    }
+
+    private ByteBuffer intToBuffer(final int val, final int bufferCapacity) {
+      final ByteBuffer byteBuffer = ByteBuffer.allocate(bufferCapacity);
+      byteBuffer.order(ByteOrder.nativeOrder());
+      byteBuffer.putInt(0, val);
+      byteBuffer.limit(Integer.BYTES);
+      byteBuffer.position(0);
+      return byteBuffer;
+    }
+  }
+
+  // --------------------------------------------------------------------------------
+
+  /** Tests {@link DirectBufferProxy}. */
+  private static final class DirectBufferRunner implements ComparatorRunner {
+    private static final Comparator<DirectBuffer> COMPARATOR =
+        PROXY_DB.getComparator(DbiFlags.MDB_INTEGERKEY);
+
+    @Override
+    public int compare(long long1, long long2) {
+      final UnsafeBuffer o1b = new UnsafeBuffer(new byte[Long.BYTES]);
+      final UnsafeBuffer o2b = new UnsafeBuffer(new byte[Long.BYTES]);
+      o1b.putLong(0, long1, ByteOrder.nativeOrder());
+      o2b.putLong(0, long2, ByteOrder.nativeOrder());
+      return COMPARATOR.compare(o1b, o2b);
+    }
+
+    @Override
+    public int compare(int int1, int int2) {
+      final UnsafeBuffer o1b = new UnsafeBuffer(new byte[Integer.BYTES]);
+      final UnsafeBuffer o2b = new UnsafeBuffer(new byte[Integer.BYTES]);
+      o1b.putInt(0, int1, ByteOrder.nativeOrder());
+      o2b.putInt(0, int2, ByteOrder.nativeOrder());
+      return COMPARATOR.compare(o1b, o2b);
+    }
+  }
+
+  /** Tests {@link ByteBufProxy}. */
+  private static final class NettyRunner implements ComparatorRunner {
+
+    private static final Comparator<ByteBuf> COMPARATOR =
+        PROXY_NETTY.getComparator(DbiFlags.MDB_INTEGERKEY);
+
+    @Override
+    public int compare(long long1, long long2) {
+      final ByteBuf o1b = DEFAULT.directBuffer(Long.BYTES);
+      final ByteBuf o2b = DEFAULT.directBuffer(Long.BYTES);
+      if (ByteOrder.nativeOrder() == ByteOrder.LITTLE_ENDIAN) {
+        o1b.writeLongLE(long1);
+        o2b.writeLongLE(long2);
+      } else {
+        o1b.writeLong(long1);
+        o2b.writeLong(long2);
+      }
+      o1b.resetReaderIndex();
+      o2b.resetReaderIndex();
+      final int res = COMPARATOR.compare(o1b, o2b);
+      o1b.release();
+      o2b.release();
+      return res;
+    }
+
+    @Override
+    public int compare(int int1, int int2) {
+      final ByteBuf o1b = DEFAULT.directBuffer(Integer.BYTES);
+      final ByteBuf o2b = DEFAULT.directBuffer(Integer.BYTES);
+      if (ByteOrder.nativeOrder() == ByteOrder.LITTLE_ENDIAN) {
+        o1b.writeIntLE(int1);
+        o2b.writeIntLE(int2);
+      } else {
+        o1b.writeInt(int1);
+        o2b.writeInt(int2);
+      }
+      o1b.resetReaderIndex();
+      o2b.resetReaderIndex();
+      final int res = COMPARATOR.compare(o1b, o2b);
+      o1b.release();
+      o2b.release();
+      return res;
+    }
+  }
+
+  // --------------------------------------------------------------------------------
+
+  /** Interface that can test a {@link BufferProxy} <code>compare</code> method. */
+  private interface ComparatorRunner {
+
+    /**
+     * Write the two longs to a buffer using native order and compare the resulting buffers.
+     *
+     * @param long1 lhs value
+     * @param long2 rhs value
+     * @return as per {@link Comparable}
+     */
+    int compare(final long long1, final long long2);
+
+    /**
+     * Write the two int to a buffer using native order and compare the resulting buffers.
+     *
+     * @param int1 lhs value
+     * @param int2 rhs value
+     * @return as per {@link Comparable}
+     */
+    int compare(final int int1, final int int2);
+  }
+}
diff --git a/src/test/java/org/lmdbjava/ComparatorTest.java b/src/test/java/org/lmdbjava/ComparatorTest.java
index 2fabb3da..f255ec2a 100644
--- a/src/test/java/org/lmdbjava/ComparatorTest.java
+++ b/src/test/java/org/lmdbjava/ComparatorTest.java
@@ -150,7 +150,7 @@ private static final class UnsignedByteArrayRunner implements ComparatorRunner {
 
     @Override
     public int compare(final byte[] o1, final byte[] o2) {
-      final Comparator<byte[]> c = PROXY_BA.getUnsignedComparator();
+      final Comparator<byte[]> c = PROXY_BA.getComparator();
       return c.compare(o1, o2);
     }
   }
@@ -269,6 +269,16 @@ static ComparatorResult get(final int comparatorResult) {
       }
       return comparatorResult < 0 ? LESS_THAN : GREATER_THAN;
     }
+
+    ComparatorResult opposite() {
+      if (this == LESS_THAN) {
+        return GREATER_THAN;
+      } else if (this == GREATER_THAN) {
+        return LESS_THAN;
+      } else {
+        return EQUAL_TO;
+      }
+    }
   }
 
   /** Interface that can test a {@link BufferProxy} <code>compare</code> method. */
diff --git a/src/test/java/org/lmdbjava/CopyFlagSetTest.java b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
new file mode 100644
index 00000000..922554d7
--- /dev/null
+++ b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.Collections;
+import java.util.HashSet;
+import org.junit.jupiter.api.Test;
+
+public class CopyFlagSetTest {
+
+  @Test
+  public void testEmpty() {
+    final CopyFlagSet copyFlagSet = CopyFlagSet.empty();
+    assertThat(copyFlagSet.getMask()).isEqualTo(0);
+    assertThat(copyFlagSet.size()).isEqualTo(0);
+    assertThat(copyFlagSet.isEmpty()).isEqualTo(true);
+    assertThat(copyFlagSet.isSet(CopyFlags.MDB_CP_COMPACT)).isEqualTo(false);
+    final CopyFlagSet copyFlagSet2 = CopyFlagSet.builder().build();
+    assertThat(copyFlagSet).isEqualTo(copyFlagSet2);
+    assertThat(copyFlagSet).isNotEqualTo(CopyFlagSet.of(CopyFlags.MDB_CP_COMPACT));
+    assertThat(copyFlagSet)
+        .isNotEqualTo(CopyFlagSet.builder().setFlag(CopyFlags.MDB_CP_COMPACT).build());
+  }
+
+  @Test
+  public void testOf() {
+    final CopyFlags copyFlag = CopyFlags.MDB_CP_COMPACT;
+    final CopyFlagSet copyFlagSet = CopyFlagSet.of(copyFlag);
+    assertThat(copyFlagSet.getMask()).isEqualTo(MaskedFlag.mask(copyFlag));
+    assertThat(copyFlagSet.size()).isEqualTo(1);
+    for (CopyFlags flag : copyFlagSet) {
+      assertThat(copyFlagSet.isSet(flag)).isEqualTo(true);
+    }
+
+    final CopyFlagSet copyFlagSet2 = CopyFlagSet.builder().setFlag(copyFlag).build();
+    assertThat(copyFlagSet).isEqualTo(copyFlagSet2);
+  }
+
+  @Test
+  public void testBuilder() {
+    final CopyFlags copyFlag1 = CopyFlags.MDB_CP_COMPACT;
+    final CopyFlagSet copyFlagSet = CopyFlagSet.builder().setFlag(copyFlag1).build();
+    assertThat(copyFlagSet.getMask()).isEqualTo(MaskedFlag.mask(copyFlag1));
+    assertThat(copyFlagSet.size()).isEqualTo(1);
+    assertThat(copyFlagSet.isSet(CopyFlags.MDB_CP_COMPACT)).isEqualTo(true);
+    for (CopyFlags flag : copyFlagSet) {
+      assertThat(copyFlagSet.isSet(flag)).isEqualTo(true);
+    }
+    final CopyFlagSet copyFlagSet2 = CopyFlagSet.builder().withFlags(copyFlag1).build();
+    final CopyFlagSet copyFlagSet3 =
+        CopyFlagSet.builder()
+            .withFlags(new HashSet<>(Collections.singletonList(copyFlag1)))
+            .build();
+    assertThat(copyFlagSet).isEqualTo(copyFlagSet2);
+    assertThat(copyFlagSet).isEqualTo(copyFlagSet3);
+  }
+}
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
new file mode 100644
index 00000000..5765ac52
--- /dev/null
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
@@ -0,0 +1,615 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.lmdbjava.DbiFlags.MDB_CREATE;
+import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
+import static org.lmdbjava.DbiFlags.MDB_INTEGERDUP;
+import static org.lmdbjava.Env.create;
+import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
+import static org.lmdbjava.KeyRange.all;
+import static org.lmdbjava.KeyRange.allBackward;
+import static org.lmdbjava.KeyRange.atLeast;
+import static org.lmdbjava.KeyRange.atLeastBackward;
+import static org.lmdbjava.KeyRange.atMost;
+import static org.lmdbjava.KeyRange.atMostBackward;
+import static org.lmdbjava.KeyRange.closed;
+import static org.lmdbjava.KeyRange.closedBackward;
+import static org.lmdbjava.KeyRange.closedOpen;
+import static org.lmdbjava.KeyRange.closedOpenBackward;
+import static org.lmdbjava.KeyRange.greaterThan;
+import static org.lmdbjava.KeyRange.greaterThanBackward;
+import static org.lmdbjava.KeyRange.lessThan;
+import static org.lmdbjava.KeyRange.lessThanBackward;
+import static org.lmdbjava.KeyRange.open;
+import static org.lmdbjava.KeyRange.openBackward;
+import static org.lmdbjava.KeyRange.openClosed;
+import static org.lmdbjava.KeyRange.openClosedBackward;
+import static org.lmdbjava.TestUtils.DB_1;
+import static org.lmdbjava.TestUtils.DB_2;
+import static org.lmdbjava.TestUtils.DB_3;
+import static org.lmdbjava.TestUtils.DB_4;
+import static org.lmdbjava.TestUtils.POSIX_MODE;
+import static org.lmdbjava.TestUtils.bb;
+import static org.lmdbjava.TestUtils.bbNative;
+import static org.lmdbjava.TestUtils.getNativeInt;
+import static org.lmdbjava.TestUtils.getNativeIntOrLong;
+
+import com.google.common.primitives.UnsignedBytes;
+import java.nio.ByteBuffer;
+import java.util.AbstractMap;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.Deque;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.params.Parameter;
+import org.junit.jupiter.params.ParameterizedClass;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.ArgumentsProvider;
+import org.junit.jupiter.params.provider.ArgumentsSource;
+import org.junit.jupiter.params.support.ParameterDeclarations;
+import org.lmdbjava.CursorIterable.KeyVal;
+
+/**
+ * Test {@link CursorIterable} using {@link DbiFlags#MDB_INTEGERKEY} to ensure that comparators work
+ * with native order integer keys.
+ */
+@Disabled // Waiting for the merge of stroomdev66's cursor tests
+@ParameterizedClass(name = "{index}: dbi: {0}")
+@ArgumentsSource(CursorIterableTest.MyArgumentProvider.class)
+public final class CursorIterableIntegerDupTest {
+
+  private static final DbiFlagSet DBI_FLAGS =
+      DbiFlagSet.of(MDB_CREATE, MDB_INTEGERDUP, MDB_DUPSORT);
+  private static final BufferProxy<ByteBuffer> BUFFER_PROXY = ByteBufferProxy.PROXY_OPTIMAL;
+  private static final List<Map.Entry<Integer, Integer>> INPUT_DATA;
+
+  static {
+    // 2 => 21
+    // 2 => 22
+    // 3 => 31
+    // ...
+    // 9 => 92
+    INPUT_DATA = new ArrayList<>();
+    for (int i = 2; i <= 9; i++) {
+      final int val1 = (i * 10) + 1;
+      final int val2 = (i * 10) + 2;
+      INPUT_DATA.add(new AbstractMap.SimpleEntry<>(i, val1));
+      INPUT_DATA.add(new AbstractMap.SimpleEntry<>(i, val2));
+    }
+  }
+
+  private TempDir tempDir;
+  private Env<ByteBuffer> env;
+  private Deque<Map.Entry<Integer, Integer>> expectedEntriesDeque;
+
+  @Parameter public DbiFactory dbiFactory;
+
+  @BeforeEach
+  public void before() {
+    tempDir = new TempDir();
+    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
+    env =
+        create(bufferProxy)
+            .setMapSize(KIBIBYTES.toBytes(256))
+            .setMaxReaders(1)
+            .setMaxDbs(3)
+            .setFilePermissions(POSIX_MODE)
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(tempDir.createTempFile());
+
+    populateExpectedEntriesDeque();
+  }
+
+  @AfterEach
+  public void after() {
+    env.close();
+    tempDir.cleanup();
+  }
+
+  @Test
+  public void allBackwardTest() {
+    verify(allBackward(), 8, 6, 4, 2);
+  }
+
+  @Test
+  public void allTest() {
+    verify(all(), 2, 4, 6, 8);
+  }
+
+  @Test
+  public void atLeastBackwardTest() {
+    verify(atLeastBackward(bbNative(5)), 4, 2);
+    verify(atLeastBackward(bbNative(6)), 6, 4, 2);
+    verify(atLeastBackward(bbNative(9)), 8, 6, 4, 2);
+  }
+
+  @Test
+  public void atLeastTest() {
+    verify(atLeast(bbNative(5)), 6, 8);
+    verify(atLeast(bbNative(6)), 6, 8);
+  }
+
+  @Test
+  public void atMostBackwardTest() {
+    verify(atMostBackward(bbNative(5)), 8, 6);
+    verify(atMostBackward(bbNative(6)), 8, 6);
+  }
+
+  @Test
+  public void atMostTest() {
+    verify(atMost(bbNative(5)), 2, 4);
+    verify(atMost(bbNative(6)), 2, 4, 6);
+  }
+
+  private void populateExpectedEntriesDeque() {
+    expectedEntriesDeque = new LinkedList<>();
+    expectedEntriesDeque.addAll(INPUT_DATA);
+  }
+
+  private void populateDatabase(final Dbi<ByteBuffer> dbi) {
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      final Cursor<ByteBuffer> c = dbi.openCursor(txn);
+      for (Map.Entry<Integer, Integer> entry : INPUT_DATA) {
+        c.put(bbNative(entry.getKey()), bb(entry.getValue()));
+      }
+      txn.commit();
+    }
+
+    try (Txn<ByteBuffer> txn = env.txnRead();
+        CursorIterable<ByteBuffer> c = dbi.iterate(txn)) {
+
+      //      for (final KeyVal<ByteBuffer> kv : c) {
+      //        System.out.print(getNativeInt(kv.key()) + " => " + kv.val().getInt());
+      //        System.out.print(", ");
+      //      }
+      //      System.out.println();
+    }
+  }
+
+  private int[] rangeInc(final int fromInc, final int toInc) {
+    int idx = 0;
+    if (fromInc <= toInc) {
+      // Forwards
+      final int[] arr = new int[toInc - fromInc + 1];
+      for (int i = fromInc; i <= toInc; i++) {
+        arr[idx++] = i;
+      }
+      return arr;
+    } else {
+      // Backwards
+      final int[] arr = new int[fromInc - toInc + 1];
+      for (int i = fromInc; i >= toInc; i--) {
+        arr[idx++] = i;
+      }
+      return arr;
+    }
+  }
+
+  @Test
+  public void closedBackwardTest() {
+    verify(closedBackward(bbNative(7), bbNative(3)), rangeInc(7, 3));
+    verify(closedBackward(bbNative(6), bbNative(2)), rangeInc(6, 2));
+    verify(closedBackward(bbNative(9), bbNative(3)), rangeInc(9, 3));
+  }
+
+  @Test
+  public void closedOpenBackwardTest() {
+    verify(closedOpenBackward(bbNative(8), bbNative(3)), rangeInc(8, 4));
+    verify(closedOpenBackward(bbNative(7), bbNative(2)), rangeInc(7, 3));
+    verify(closedOpenBackward(bbNative(9), bbNative(3)), rangeInc(9, 4));
+  }
+
+  @Test
+  public void closedOpenTest() {
+    verify(closedOpen(bbNative(3), bbNative(8)), rangeInc(3, 7));
+    verify(closedOpen(bbNative(2), bbNative(6)), rangeInc(2, 5));
+  }
+
+  @Test
+  public void closedTest() {
+    verify(closed(bbNative(3), bbNative(7)), rangeInc(3, 7));
+    verify(closed(bbNative(2), bbNative(6)), rangeInc(2, 6));
+    verify(closed(bbNative(1), bbNative(7)), rangeInc(2, 7));
+  }
+
+  @Test
+  public void greaterThanBackwardTest() {
+    verify(greaterThanBackward(bbNative(6)), rangeInc(5, 2));
+    verify(greaterThanBackward(bbNative(7)), rangeInc(6, 2));
+    verify(greaterThanBackward(bbNative(9)), rangeInc(8, 2));
+  }
+
+  @Test
+  public void greaterThanTest() {
+    verify(greaterThan(bbNative(4)), rangeInc(5, 9));
+    verify(greaterThan(bbNative(3)), rangeInc(4, 9));
+  }
+
+  public void iterableOnlyReturnedOnce() {
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead();
+                  CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+                c.iterator(); // ok
+                c.iterator(); // fails
+              }
+            })
+        .isInstanceOf(IllegalStateException.class);
+  }
+
+  @Test
+  public void iterate() {
+    populateExpectedEntriesDeque();
+    final Dbi<ByteBuffer> db = getDb();
+    try (Txn<ByteBuffer> txn = env.txnRead();
+        CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+
+      for (final KeyVal<ByteBuffer> kv : c) {
+        final Map.Entry<Integer, Integer> entry = expectedEntriesDeque.pollFirst();
+        //        System.out.println(entry.getKey() + " => " + entry.getValue());
+        assertThat(getNativeInt(kv.key())).isEqualTo(entry.getKey());
+        assertThat(kv.val().getInt()).isEqualTo(entry.getValue());
+      }
+    }
+  }
+
+  public void iteratorOnlyReturnedOnce() {
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead();
+                  CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+                c.iterator(); // ok
+                c.iterator(); // fails
+              }
+            })
+        .isInstanceOf(IllegalStateException.class);
+  }
+
+  @Test
+  public void lessThanBackwardTest() {
+    verify(lessThanBackward(bbNative(5)), 8, 6);
+    verify(lessThanBackward(bbNative(2)), 8, 6, 4);
+  }
+
+  @Test
+  public void lessThanTest() {
+    verify(lessThan(bbNative(5)), 2, 4);
+    verify(lessThan(bbNative(8)), 2, 4, 6);
+  }
+
+  public void nextThrowsNoSuchElementExceptionIfNoMoreElements() {
+    Assertions.assertThatThrownBy(
+            () -> {
+              populateExpectedEntriesDeque();
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead();
+                  CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+                final Iterator<KeyVal<ByteBuffer>> i = c.iterator();
+                while (i.hasNext()) {
+                  final KeyVal<ByteBuffer> kv = i.next();
+                  assertThat(getNativeInt(kv.key()))
+                      .isEqualTo(expectedEntriesDeque.pollFirst().getKey());
+                  assertThat(kv.val().getInt())
+                      .isEqualTo(expectedEntriesDeque.pollFirst().getValue());
+                }
+                assertThat(i.hasNext()).isEqualTo(false);
+                i.next();
+              }
+            })
+        .isInstanceOf(NoSuchElementException.class);
+  }
+
+  @Test
+  public void openBackwardTest() {
+    verify(openBackward(bbNative(7), bbNative(2)), 6, 4);
+    verify(openBackward(bbNative(8), bbNative(1)), 6, 4, 2);
+    verify(openBackward(bbNative(9), bbNative(4)), 8, 6);
+  }
+
+  @Test
+  public void openClosedBackwardTest() {
+    verify(openClosedBackward(bbNative(7), bbNative(2)), 6, 4, 2);
+    verify(openClosedBackward(bbNative(8), bbNative(4)), 6, 4);
+    verify(openClosedBackward(bbNative(9), bbNative(4)), 8, 6, 4);
+  }
+
+  @Test
+  public void openClosedBackwardTestWithGuava() {
+    final Comparator<byte[]> guava = UnsignedBytes.lexicographicalComparator();
+    final Comparator<ByteBuffer> comparator =
+        (bb1, bb2) -> {
+          final byte[] array1 = new byte[bb1.remaining()];
+          final byte[] array2 = new byte[bb2.remaining()];
+          bb1.mark();
+          bb2.mark();
+          bb1.get(array1);
+          bb2.get(array2);
+          bb1.reset();
+          bb2.reset();
+          return guava.compare(array1, array2);
+        };
+    final Dbi<ByteBuffer> guavaDbi = env.openDbi(DB_1, comparator, MDB_CREATE);
+    populateDatabase(guavaDbi);
+    verify(openClosedBackward(bbNative(7), bbNative(2)), guavaDbi, 6, 4, 2);
+    verify(openClosedBackward(bbNative(8), bbNative(4)), guavaDbi, 6, 4);
+  }
+
+  @Test
+  public void openClosedTest() {
+    verify(openClosed(bbNative(3), bbNative(8)), 4, 6, 8);
+    verify(openClosed(bbNative(2), bbNative(6)), 4, 6);
+  }
+
+  @Test
+  public void openTest() {
+    verify(open(bbNative(3), bbNative(7)), 4, 6);
+    verify(open(bbNative(2), bbNative(8)), 4, 6);
+  }
+
+  @Test
+  public void removeOddElements() {
+    final Dbi<ByteBuffer> db = getDb();
+    verify(db, all(), 2, 4, 6, 8);
+    int idx = -1;
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn)) {
+        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+        while (c.hasNext()) {
+          c.next();
+          idx++;
+          if (idx % 2 == 0) {
+            c.remove();
+          }
+        }
+      }
+      txn.commit();
+    }
+    verify(db, all(), 4, 8);
+  }
+
+  public void nextWithClosedEnvTest() {
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+                  env.close();
+                  c.next();
+                }
+              }
+            })
+        .isInstanceOf(Env.AlreadyClosedException.class);
+  }
+
+  public void removeWithClosedEnvTest() {
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnWrite()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+                  final KeyVal<ByteBuffer> keyVal = c.next();
+                  assertThat(keyVal).isNotNull();
+                  env.close();
+                  c.remove();
+                }
+              }
+            })
+        .isInstanceOf(Env.AlreadyClosedException.class);
+  }
+
+  public void hasNextWithClosedEnvTest() {
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+                  env.close();
+                  c.hasNext();
+                }
+              }
+            })
+        .isInstanceOf(Env.AlreadyClosedException.class);
+  }
+
+  public void forEachRemainingWithClosedEnvTest() {
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+                  env.close();
+                  c.forEachRemaining(keyVal -> {});
+                }
+              }
+            })
+        .isInstanceOf(Env.AlreadyClosedException.class);
+  }
+
+  private void verify(final KeyRange<ByteBuffer> range, final int... expectedKeys) {
+    // Verify using all comparator types
+    final Dbi<ByteBuffer> db = getDb();
+    verify(range, db, expectedKeys);
+  }
+
+  private void verify(
+      final Dbi<ByteBuffer> dbi, final KeyRange<ByteBuffer> range, final int... expectedKeys) {
+    verify(range, dbi, expectedKeys);
+  }
+
+  private void verify(
+      final KeyRange<ByteBuffer> range, final Dbi<ByteBuffer> dbi, final int... expectedKeys) {
+    final boolean isForward = range.getType().isDirectionForward();
+
+    final List<Integer> expectedValues =
+        Arrays.stream(expectedKeys)
+            .boxed()
+            .flatMap(
+                key -> {
+                  final int base = key * 10;
+                  return isForward ? Stream.of(base + 1, base + 2) : Stream.of(base + 2, base + 1);
+                })
+            .collect(Collectors.toList());
+
+    final List<Integer> results = new ArrayList<>();
+    //    System.out.println(rangeToString(range) + ", expected: " + expectedValues);
+
+    try (Txn<ByteBuffer> txn = env.txnRead();
+        CursorIterable<ByteBuffer> c = dbi.iterate(txn, range)) {
+      for (final KeyVal<ByteBuffer> kv : c) {
+        final int key = getNativeInt(kv.key());
+        final int val = kv.val().getInt();
+        //        System.out.println(key + " => " + val);
+        results.add(val);
+        assertThat(val)
+            .satisfiesAnyOf(
+                v -> assertThat(v).isEqualTo((key * 10) + 1),
+                v -> assertThat(v).isEqualTo((key * 10) + 2));
+      }
+    }
+
+    assertThat(results).hasSize(expectedValues.size());
+    for (int idx = 0; idx < results.size(); idx++) {
+      assertThat(results.get(idx)).isEqualTo(expectedValues.get(idx));
+    }
+  }
+
+  private String rangeToString(final KeyRange<ByteBuffer> range) {
+    final ByteBuffer start = range.getStart();
+    final ByteBuffer stop = range.getStop();
+    return range.getType()
+        + " start: "
+        + (start != null ? getNativeInt(start) : "")
+        + " stop: "
+        + (stop != null ? getNativeInt(stop) : "");
+  }
+
+  private Dbi<ByteBuffer> getDb() {
+    final Dbi<ByteBuffer> dbi = dbiFactory.factory.apply(env);
+    populateDatabase(dbi);
+    return dbi;
+  }
+
+  // --------------------------------------------------------------------------------
+
+  private static class DbiFactory {
+    private final String name;
+    private final Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory;
+
+    private DbiFactory(String name, Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory) {
+      this.name = name;
+      this.factory = factory;
+    }
+
+    @Override
+    public String toString() {
+      return name;
+    }
+  }
+
+  // --------------------------------------------------------------------------------
+
+  static class MyArgumentProvider implements ArgumentsProvider {
+
+    @Override
+    public Stream<? extends Arguments> provideArguments(
+        ParameterDeclarations parameters, ExtensionContext context) throws Exception {
+      final DbiFactory defaultComparatorDb =
+          new DbiFactory(
+              "defaultComparator",
+              env ->
+                  env.buildDbi()
+                      .setDbName(DB_1)
+                      .withDefaultComparator()
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      final DbiFactory nativeComparatorDb =
+          new DbiFactory(
+              "nativeComparator",
+              env ->
+                  env.buildDbi()
+                      .setDbName(DB_2)
+                      .withNativeComparator()
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      final DbiFactory callbackComparatorDb =
+          new DbiFactory(
+              "callbackComparator",
+              env ->
+                  env.buildDbi()
+                      .setDbName(DB_3)
+                      .withCallbackComparator(MyArgumentProvider::buildComparator)
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      final DbiFactory iteratorComparatorDb =
+          new DbiFactory(
+              "iteratorComparator",
+              env ->
+                  env.buildDbi()
+                      .setDbName(DB_4)
+                      .withIteratorComparator(MyArgumentProvider::buildComparator)
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      return Stream.of(
+              defaultComparatorDb, nativeComparatorDb, callbackComparatorDb, iteratorComparatorDb)
+          .map(Arguments::of);
+    }
+
+    private static Comparator<ByteBuffer> buildComparator(final DbiFlagSet dbiFlagSet) {
+      final Comparator<ByteBuffer> baseComparator = BUFFER_PROXY.getComparator(DBI_FLAGS);
+      return (o1, o2) -> {
+        if (o1.remaining() != o2.remaining()) {
+          // Make sure LMDB is always giving us consistent key lengths.
+          Assertions.fail(
+              "o1: "
+                  + o1
+                  + " "
+                  + getNativeIntOrLong(o1)
+                  + ", o2: "
+                  + o2
+                  + " "
+                  + getNativeIntOrLong(o2));
+        }
+        return baseComparator.compare(o1, o2);
+      };
+    }
+  }
+}
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
new file mode 100644
index 00000000..e8f039cf
--- /dev/null
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
@@ -0,0 +1,662 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
+import static java.util.Arrays.asList;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.lmdbjava.DbiFlags.MDB_CREATE;
+import static org.lmdbjava.DbiFlags.MDB_INTEGERKEY;
+import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
+import static org.lmdbjava.KeyRange.all;
+import static org.lmdbjava.KeyRange.allBackward;
+import static org.lmdbjava.KeyRange.atLeast;
+import static org.lmdbjava.KeyRange.atLeastBackward;
+import static org.lmdbjava.KeyRange.atMost;
+import static org.lmdbjava.KeyRange.atMostBackward;
+import static org.lmdbjava.KeyRange.closed;
+import static org.lmdbjava.KeyRange.closedBackward;
+import static org.lmdbjava.KeyRange.closedOpen;
+import static org.lmdbjava.KeyRange.closedOpenBackward;
+import static org.lmdbjava.KeyRange.greaterThan;
+import static org.lmdbjava.KeyRange.greaterThanBackward;
+import static org.lmdbjava.KeyRange.lessThan;
+import static org.lmdbjava.KeyRange.lessThanBackward;
+import static org.lmdbjava.KeyRange.open;
+import static org.lmdbjava.KeyRange.openBackward;
+import static org.lmdbjava.KeyRange.openClosed;
+import static org.lmdbjava.KeyRange.openClosedBackward;
+import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
+import static org.lmdbjava.TestUtils.DB_1;
+import static org.lmdbjava.TestUtils.DB_2;
+import static org.lmdbjava.TestUtils.DB_3;
+import static org.lmdbjava.TestUtils.DB_4;
+import static org.lmdbjava.TestUtils.bb;
+import static org.lmdbjava.TestUtils.bbNative;
+import static org.lmdbjava.TestUtils.getNativeInt;
+import static org.lmdbjava.TestUtils.getNativeIntOrLong;
+import static org.lmdbjava.TestUtils.getNativeLong;
+import static org.lmdbjava.TestUtils.getString;
+
+import com.google.common.primitives.UnsignedBytes;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.AbstractMap;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.Deque;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.params.Parameter;
+import org.junit.jupiter.params.ParameterizedClass;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.ArgumentsProvider;
+import org.junit.jupiter.params.provider.ArgumentsSource;
+import org.junit.jupiter.params.support.ParameterDeclarations;
+import org.lmdbjava.CursorIterable.KeyVal;
+
+/**
+ * Test {@link CursorIterable} using {@link DbiFlags#MDB_INTEGERKEY} to ensure that comparators work
+ * with native order integer keys.
+ */
+@ParameterizedClass(name = "{index}: dbi: {0}")
+@ArgumentsSource(CursorIterableIntegerKeyTest.MyArgumentProvider.class)
+public final class CursorIterableIntegerKeyTest {
+
+  private static final DbiFlagSet DBI_FLAGS = DbiFlagSet.of(MDB_CREATE, MDB_INTEGERKEY);
+  private static final BufferProxy<ByteBuffer> BUFFER_PROXY = ByteBufferProxy.PROXY_OPTIMAL;
+
+  private TempDir tempDir;
+  private Env<ByteBuffer> env;
+  private Deque<Integer> list;
+
+  @Parameter public DbiFactory dbiFactory;
+
+  @BeforeEach
+  public void before() {
+    tempDir = new TempDir();
+    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
+    env =
+        Env.create(bufferProxy)
+            .setMapSize(KIBIBYTES.toBytes(256))
+            .setMaxReaders(1)
+            .setMaxDbs(3)
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(tempDir.createTempFile());
+
+    populateTestDataList();
+  }
+
+  @AfterEach
+  public void after() {
+    env.close();
+    tempDir.cleanup();
+  }
+
+  @Test
+  public void testNumericOrderLong() {
+    final Dbi<ByteBuffer> dbi = dbiFactory.factory.apply(env);
+
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      final Cursor<ByteBuffer> c = dbi.openCursor(txn);
+      long i = 1;
+      while (true) {
+        //        System.out.println("putting " + i);
+        c.put(bbNative(i), bb(i + "-long"));
+        final long i2 = i * 10;
+        if (i2 < i) {
+          // Overflowed
+          break;
+        }
+        i = i2;
+      }
+      txn.commit();
+    }
+
+    final List<Map.Entry<Long, String>> entries = new ArrayList<>();
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      try (CursorIterable<ByteBuffer> iterable = dbi.iterate(txn)) {
+        for (KeyVal<ByteBuffer> keyVal : iterable) {
+          assertThat(keyVal.key().remaining()).isEqualTo(Long.BYTES);
+          final String val = getString(keyVal.val());
+          final long key = getNativeLong(keyVal.key());
+          entries.add(new AbstractMap.SimpleEntry<>(key, val));
+          //          System.out.println(val);
+        }
+      }
+    }
+
+    final List<Long> dbKeys = entries.stream().map(Map.Entry::getKey).collect(Collectors.toList());
+    final List<Long> dbKeysSorted =
+        entries.stream().map(Map.Entry::getKey).sorted().collect(Collectors.toList());
+    for (int i = 0; i < dbKeys.size(); i++) {
+      final long dbKey1 = dbKeys.get(i);
+      final long dbKey2 = dbKeysSorted.get(i);
+      assertThat(dbKey1).isEqualTo(dbKey2);
+    }
+  }
+
+  @Test
+  public void testNumericOrderInt() {
+    final Dbi<ByteBuffer> dbi = dbiFactory.factory.apply(env);
+
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      final Cursor<ByteBuffer> c = dbi.openCursor(txn);
+      int i = 1;
+      while (true) {
+        //        System.out.println("putting " + i);
+        c.put(bbNative(i), bb(i + "-int"));
+        final int i2 = i * 10;
+        if (i2 < i) {
+          // Overflowed
+          break;
+        }
+        i = i2;
+      }
+      txn.commit();
+    }
+
+    final List<Map.Entry<Integer, String>> entries = new ArrayList<>();
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      try (CursorIterable<ByteBuffer> iterable = dbi.iterate(txn)) {
+        for (KeyVal<ByteBuffer> keyVal : iterable) {
+          assertThat(keyVal.key().remaining()).isEqualTo(Integer.BYTES);
+          final String val = getString(keyVal.val());
+          final int key = TestUtils.getNativeInt(keyVal.key());
+          entries.add(new AbstractMap.SimpleEntry<>(key, val));
+          //          System.out.println(val);
+        }
+      }
+    }
+
+    final List<Integer> dbKeys =
+        entries.stream().map(Map.Entry::getKey).collect(Collectors.toList());
+    final List<Integer> dbKeysSorted =
+        entries.stream().map(Map.Entry::getKey).sorted().collect(Collectors.toList());
+    for (int i = 0; i < dbKeys.size(); i++) {
+      final long dbKey1 = dbKeys.get(i);
+      final long dbKey2 = dbKeysSorted.get(i);
+      assertThat(dbKey1).isEqualTo(dbKey2);
+    }
+  }
+
+  @Test
+  public void testIntegerKeyKeySize() {
+    final Dbi<ByteBuffer> db = dbiFactory.factory.apply(env);
+    long maxIntAsLong = Integer.MAX_VALUE;
+
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      //      System.out.println("Flags: " + db.listFlags(txn));
+      int val = 0;
+      db.put(txn, bbNative(0L), bb("val_" + ++val));
+      db.put(txn, bbNative(10L), bb("val_" + ++val));
+      db.put(txn, bbNative(maxIntAsLong - 1_111_111_111), bb("val_" + ++val));
+      db.put(txn, bbNative(maxIntAsLong - 111_111_111), bb("val_" + ++val));
+      db.put(txn, bbNative(maxIntAsLong - 111_111), bb("val_" + ++val));
+      db.put(txn, bbNative(maxIntAsLong - 111), bb("val_" + ++val));
+      db.put(txn, bbNative(maxIntAsLong + 111), bb("val_" + ++val));
+      db.put(txn, bbNative(maxIntAsLong + 111_111), bb("val_" + ++val));
+      db.put(txn, bbNative(maxIntAsLong + 111_111_111), bb("val_" + ++val));
+      db.put(txn, bbNative(maxIntAsLong + 1_111_111_111), bb("val_" + ++val));
+      db.put(txn, bbNative(Long.MAX_VALUE), bb("val_" + ++val));
+      txn.commit();
+    }
+
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      try (CursorIterable<ByteBuffer> iterable = db.iterate(txn)) {
+        for (KeyVal<ByteBuffer> keyVal : iterable) {
+          final String val = getString(keyVal.val());
+          final long key = getNativeLong(keyVal.key());
+          final int remaining = keyVal.key().remaining();
+          //          System.out.println("key: " + key + ", val: " + val + ", remaining: " +
+          // remaining);
+        }
+      }
+    }
+  }
+
+  @Test
+  public void allBackwardTest() {
+    verify(allBackward(), 8, 6, 4, 2);
+  }
+
+  @Test
+  public void allTest() {
+    verify(all(), 2, 4, 6, 8);
+  }
+
+  @Test
+  public void atLeastBackwardTest() {
+    verify(atLeastBackward(bbNative(5)), 4, 2);
+    verify(atLeastBackward(bbNative(6)), 6, 4, 2);
+    verify(atLeastBackward(bbNative(9)), 8, 6, 4, 2);
+  }
+
+  @Test
+  public void atLeastTest() {
+    verify(atLeast(bbNative(5)), 6, 8);
+    verify(atLeast(bbNative(6)), 6, 8);
+  }
+
+  @Test
+  public void atMostBackwardTest() {
+    verify(atMostBackward(bbNative(5)), 8, 6);
+    verify(atMostBackward(bbNative(6)), 8, 6);
+  }
+
+  @Test
+  public void atMostTest() {
+    verify(atMost(bbNative(5)), 2, 4);
+    verify(atMost(bbNative(6)), 2, 4, 6);
+  }
+
+  private void populateTestDataList() {
+    list = new LinkedList<>();
+    list.addAll(asList(2, 3, 4, 5, 6, 7, 8, 9));
+  }
+
+  private void populateDatabase(final Dbi<ByteBuffer> dbi) {
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      final Cursor<ByteBuffer> c = dbi.openCursor(txn);
+      c.put(bbNative(2), bb(3), MDB_NOOVERWRITE);
+      c.put(bbNative(4), bb(5));
+      c.put(bbNative(6), bb(7));
+      c.put(bbNative(8), bb(9));
+      txn.commit();
+    }
+  }
+
+  @Test
+  public void closedBackwardTest() {
+    verify(closedBackward(bbNative(7), bbNative(3)), 6, 4);
+    verify(closedBackward(bbNative(6), bbNative(2)), 6, 4, 2);
+    verify(closedBackward(bbNative(9), bbNative(3)), 8, 6, 4);
+  }
+
+  @Test
+  public void closedOpenBackwardTest() {
+    verify(closedOpenBackward(bbNative(8), bbNative(3)), 8, 6, 4);
+    verify(closedOpenBackward(bbNative(7), bbNative(2)), 6, 4);
+    verify(closedOpenBackward(bbNative(9), bbNative(3)), 8, 6, 4);
+  }
+
+  @Test
+  public void closedOpenTest() {
+    verify(closedOpen(bbNative(3), bbNative(8)), 4, 6);
+    verify(closedOpen(bbNative(2), bbNative(6)), 2, 4);
+  }
+
+  @Test
+  public void closedTest() {
+    verify(closed(bbNative(3), bbNative(7)), 4, 6);
+    verify(closed(bbNative(2), bbNative(6)), 2, 4, 6);
+    verify(closed(bbNative(1), bbNative(7)), 2, 4, 6);
+  }
+
+  @Test
+  public void greaterThanBackwardTest() {
+    verify(greaterThanBackward(bbNative(6)), 4, 2);
+    verify(greaterThanBackward(bbNative(7)), 6, 4, 2);
+    verify(greaterThanBackward(bbNative(9)), 8, 6, 4, 2);
+  }
+
+  @Test
+  public void greaterThanTest() {
+    verify(greaterThan(bbNative(4)), 6, 8);
+    verify(greaterThan(bbNative(3)), 4, 6, 8);
+  }
+
+  public void iterableOnlyReturnedOnce() {
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead();
+                  CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+                c.iterator(); // ok
+                c.iterator(); // fails
+              }
+            })
+        .isInstanceOf(IllegalStateException.class);
+  }
+
+  @Test
+  public void iterate() {
+    populateTestDataList();
+    final Dbi<ByteBuffer> db = getDb();
+    try (Txn<ByteBuffer> txn = env.txnRead();
+        CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+
+      for (final KeyVal<ByteBuffer> kv : c) {
+        assertThat(getNativeInt(kv.key())).isEqualTo(list.pollFirst());
+        assertThat(kv.val().getInt()).isEqualTo(list.pollFirst());
+      }
+    }
+  }
+
+  public void iteratorOnlyReturnedOnce() {
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead();
+                  CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+                c.iterator(); // ok
+                c.iterator(); // fails
+              }
+            })
+        .isInstanceOf(IllegalStateException.class);
+  }
+
+  @Test
+  public void lessThanBackwardTest() {
+    verify(lessThanBackward(bbNative(5)), 8, 6);
+    verify(lessThanBackward(bbNative(2)), 8, 6, 4);
+  }
+
+  @Test
+  public void lessThanTest() {
+    verify(lessThan(bbNative(5)), 2, 4);
+    verify(lessThan(bbNative(8)), 2, 4, 6);
+  }
+
+  public void nextThrowsNoSuchElementExceptionIfNoMoreElements() {
+    Assertions.assertThatThrownBy(
+            () -> {
+              populateTestDataList();
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead();
+                  CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+                final Iterator<KeyVal<ByteBuffer>> i = c.iterator();
+                while (i.hasNext()) {
+                  final KeyVal<ByteBuffer> kv = i.next();
+                  assertThat(getNativeInt(kv.key())).isEqualTo(list.pollFirst());
+                  assertThat(kv.val().getInt()).isEqualTo(list.pollFirst());
+                }
+                assertThat(i.hasNext()).isEqualTo(false);
+                i.next();
+              }
+            })
+        .isInstanceOf(NoSuchElementException.class);
+  }
+
+  @Test
+  public void openBackwardTest() {
+    verify(openBackward(bbNative(7), bbNative(2)), 6, 4);
+    verify(openBackward(bbNative(8), bbNative(1)), 6, 4, 2);
+    verify(openBackward(bbNative(9), bbNative(4)), 8, 6);
+  }
+
+  @Test
+  public void openClosedBackwardTest() {
+    verify(openClosedBackward(bbNative(7), bbNative(2)), 6, 4, 2);
+    verify(openClosedBackward(bbNative(8), bbNative(4)), 6, 4);
+    verify(openClosedBackward(bbNative(9), bbNative(4)), 8, 6, 4);
+  }
+
+  @Test
+  public void openClosedBackwardTestWithGuava() {
+    final Comparator<byte[]> guava = UnsignedBytes.lexicographicalComparator();
+    final Comparator<ByteBuffer> comparator =
+        (bb1, bb2) -> {
+          final byte[] array1 = new byte[bb1.remaining()];
+          final byte[] array2 = new byte[bb2.remaining()];
+          bb1.mark();
+          bb2.mark();
+          bb1.get(array1);
+          bb2.get(array2);
+          bb1.reset();
+          bb2.reset();
+          return guava.compare(array1, array2);
+        };
+    final Dbi<ByteBuffer> guavaDbi = env.openDbi(DB_1, comparator, MDB_CREATE);
+    populateDatabase(guavaDbi);
+    verify(openClosedBackward(bbNative(7), bbNative(2)), guavaDbi, 6, 4, 2);
+    verify(openClosedBackward(bbNative(8), bbNative(4)), guavaDbi, 6, 4);
+  }
+
+  @Test
+  public void openClosedTest() {
+    verify(openClosed(bbNative(3), bbNative(8)), 4, 6, 8);
+    verify(openClosed(bbNative(2), bbNative(6)), 4, 6);
+  }
+
+  @Test
+  public void openTest() {
+    verify(open(bbNative(3), bbNative(7)), 4, 6);
+    verify(open(bbNative(2), bbNative(8)), 4, 6);
+  }
+
+  @Test
+  public void removeOddElements() {
+    final Dbi<ByteBuffer> db = getDb();
+    verify(db, all(), 2, 4, 6, 8);
+    int idx = -1;
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn)) {
+        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+        while (c.hasNext()) {
+          c.next();
+          idx++;
+          if (idx % 2 == 0) {
+            c.remove();
+          }
+        }
+      }
+      txn.commit();
+    }
+    verify(db, all(), 4, 8);
+  }
+
+  public void nextWithClosedEnvTest() {
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+                  env.close();
+                  c.next();
+                }
+              }
+            })
+        .isInstanceOf(Env.AlreadyClosedException.class);
+  }
+
+  public void removeWithClosedEnvTest() {
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnWrite()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+                  final KeyVal<ByteBuffer> keyVal = c.next();
+                  assertThat(keyVal).isNotNull();
+
+                  env.close();
+                  c.remove();
+                }
+              }
+            })
+        .isInstanceOf(Env.AlreadyClosedException.class);
+  }
+
+  public void hasNextWithClosedEnvTest() {
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+                  env.close();
+                  c.hasNext();
+                }
+              }
+            })
+        .isInstanceOf(Env.AlreadyClosedException.class);
+  }
+
+  public void forEachRemainingWithClosedEnvTest() {
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+                  env.close();
+                  c.forEachRemaining(keyVal -> {});
+                }
+              }
+            })
+        .isInstanceOf(Env.AlreadyClosedException.class);
+  }
+
+  private void verify(final KeyRange<ByteBuffer> range, final int... expected) {
+    // Verify using all comparator types
+    final Dbi<ByteBuffer> db = getDb();
+    verify(range, db, expected);
+  }
+
+  private void verify(
+      final Dbi<ByteBuffer> dbi, final KeyRange<ByteBuffer> range, final int... expected) {
+    verify(range, dbi, expected);
+  }
+
+  private void verify(
+      final KeyRange<ByteBuffer> range, final Dbi<ByteBuffer> dbi, final int... expected) {
+
+    final List<Integer> results = new ArrayList<>();
+
+    try (Txn<ByteBuffer> txn = env.txnRead();
+        CursorIterable<ByteBuffer> c = dbi.iterate(txn, range)) {
+      for (final KeyVal<ByteBuffer> kv : c) {
+        final int key = kv.key().order(ByteOrder.nativeOrder()).getInt();
+        final int val = kv.val().getInt();
+        results.add(key);
+        assertThat(val).isEqualTo(key + 1);
+      }
+    }
+
+    assertThat(results).hasSize(expected.length);
+    for (int idx = 0; idx < results.size(); idx++) {
+      assertThat(results.get(idx)).isEqualTo(expected[idx]);
+    }
+  }
+
+  private Dbi<ByteBuffer> getDb() {
+    final Dbi<ByteBuffer> dbi = dbiFactory.factory.apply(env);
+    populateDatabase(dbi);
+    return dbi;
+  }
+
+  // --------------------------------------------------------------------------------
+
+  private static class DbiFactory {
+    private final String name;
+    private final Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory;
+
+    private DbiFactory(String name, Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory) {
+      this.name = name;
+      this.factory = factory;
+    }
+
+    @Override
+    public String toString() {
+      return name;
+    }
+  }
+
+  // --------------------------------------------------------------------------------
+
+  static class MyArgumentProvider implements ArgumentsProvider {
+
+    @Override
+    public Stream<? extends Arguments> provideArguments(
+        ParameterDeclarations parameters, ExtensionContext context) throws Exception {
+      final DbiFactory defaultComparatorDb =
+          new DbiFactory(
+              "defaultComparator",
+              env ->
+                  env.buildDbi()
+                      .setDbName(DB_1)
+                      .withDefaultComparator()
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      final DbiFactory nativeComparatorDb =
+          new DbiFactory(
+              "nativeComparator",
+              env ->
+                  env.buildDbi()
+                      .setDbName(DB_2)
+                      .withNativeComparator()
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      final DbiFactory callbackComparatorDb =
+          new DbiFactory(
+              "callbackComparator",
+              env ->
+                  env.buildDbi()
+                      .setDbName(DB_3)
+                      .withCallbackComparator(MyArgumentProvider::buildComparator)
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      final DbiFactory iteratorComparatorDb =
+          new DbiFactory(
+              "iteratorComparator",
+              env ->
+                  env.buildDbi()
+                      .setDbName(DB_4)
+                      .withIteratorComparator(MyArgumentProvider::buildComparator)
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      return Stream.of(
+              defaultComparatorDb, nativeComparatorDb, callbackComparatorDb, iteratorComparatorDb)
+          .map(Arguments::of);
+    }
+
+    private static Comparator<ByteBuffer> buildComparator(final DbiFlagSet dbiFlagSet) {
+      final Comparator<ByteBuffer> baseComparator = BUFFER_PROXY.getComparator(DBI_FLAGS);
+      return (o1, o2) -> {
+        if (o1.remaining() != o2.remaining()) {
+          // Make sure LMDB is always giving us consistent key lengths.
+          Assertions.fail(
+              "o1: "
+                  + o1
+                  + " "
+                  + getNativeIntOrLong(o1)
+                  + ", o2: "
+                  + o2
+                  + " "
+                  + getNativeIntOrLong(o2));
+        }
+        return baseComparator.compare(o1, o2);
+      };
+    }
+  }
+}
diff --git a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
new file mode 100644
index 00000000..f5210f3c
--- /dev/null
+++ b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
@@ -0,0 +1,201 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import static com.jakewharton.byteunits.BinaryByteUnit.GIBIBYTES;
+import static org.lmdbjava.DbiFlags.MDB_CREATE;
+import static org.lmdbjava.Env.create;
+import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
+import static org.lmdbjava.PutFlags.MDB_APPEND;
+import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
+import static org.lmdbjava.TestUtils.POSIX_MODE;
+import static org.lmdbjava.TestUtils.bb;
+
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.time.Duration;
+import java.time.Instant;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class CursorIterablePerfTest {
+
+  //    private static final int ITERATIONS = 5_000_000;
+  private static final int ITERATIONS = 100_000;
+  //    private static final int ITERATIONS = 10;
+
+  private TempDir tempDir;
+  private Dbi<ByteBuffer> dbJavaComparator;
+  private Dbi<ByteBuffer> dbLmdbComparator;
+  private Dbi<ByteBuffer> dbCallbackComparator;
+  private List<Dbi<ByteBuffer>> dbs = new ArrayList<>();
+  private Env<ByteBuffer> env;
+  private List<Integer> data = new ArrayList<>(ITERATIONS);
+
+  @BeforeEach
+  public void before() {
+    tempDir = new TempDir();
+    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
+    env =
+        create(bufferProxy)
+            .setMapSize(GIBIBYTES.toBytes(1))
+            .setMaxReaders(1)
+            .setMaxDbs(3)
+            .setFilePermissions(POSIX_MODE)
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(tempDir.createTempFile());
+
+    final DbiFlagSet dbiFlagSet = MDB_CREATE;
+    // Use a java comparator for start/stop keys only
+    dbJavaComparator =
+        env.buildDbi()
+            .setDbName("JavaComparator")
+            .withDefaultComparator()
+            .setDbiFlags(dbiFlagSet)
+            .open();
+    // Use LMDB comparator for start/stop keys
+    dbLmdbComparator =
+        env.buildDbi()
+            .setDbName("LmdbComparator")
+            .withNativeComparator()
+            .setDbiFlags(dbiFlagSet)
+            .open();
+
+    // Use a java comparator for start/stop keys and as a callback comparator
+    dbCallbackComparator =
+        env.buildDbi()
+            .setDbName("CallBackComparator")
+            .withCallbackComparator(bufferProxy::getComparator)
+            .setDbiFlags(dbiFlagSet)
+            .open();
+
+    dbs.add(dbJavaComparator);
+    dbs.add(dbLmdbComparator);
+    dbs.add(dbCallbackComparator);
+
+    populateList();
+  }
+
+  @AfterEach
+  public void after() {
+    env.close();
+    tempDir.cleanup();
+  }
+
+  private void populateList() {
+    for (int i = 0; i < ITERATIONS * 2; i += 2) {
+      data.add(i);
+    }
+  }
+
+  private void populateDatabases(final boolean randomOrder) {
+    System.out.println("Clear then populate databases (randomOrder=" + randomOrder + ")");
+
+    final List<Integer> data;
+    if (randomOrder) {
+      data = new ArrayList<>(this.data);
+      Collections.shuffle(data);
+    } else {
+      data = this.data;
+    }
+
+    final PutFlagSet noOverwriteAndAppendFlagSet = PutFlagSet.of(MDB_NOOVERWRITE, MDB_APPEND);
+
+    for (int round = 0; round < 3; round++) {
+      System.out.println("round: " + round + " -----------------------------------------");
+
+      for (final Dbi<ByteBuffer> db : dbs) {
+        // Clean out the db first
+        try (Txn<ByteBuffer> txn = env.txnWrite();
+            final Cursor<ByteBuffer> cursor = db.openCursor(txn)) {
+          while (cursor.next()) {
+            cursor.delete();
+          }
+        }
+
+        final String dbName = db.getNameAsString(StandardCharsets.UTF_8);
+        final Instant start = Instant.now();
+        try (Txn<ByteBuffer> txn = env.txnWrite()) {
+          for (final Integer i : data) {
+            if (randomOrder) {
+              db.put(txn, bb(i), bb(i + 1), MDB_NOOVERWRITE);
+            } else {
+              db.put(txn, bb(i), bb(i + 1), noOverwriteAndAppendFlagSet);
+            }
+          }
+          txn.commit();
+        }
+        final Duration duration = Duration.between(start, Instant.now());
+        System.out.println(
+            "DB: "
+                + dbName
+                + " - Loaded in duration: "
+                + duration
+                + ", millis: "
+                + duration.toMillis());
+      }
+    }
+  }
+
+  @Test
+  public void comparePerf_sequential() {
+    comparePerf(false);
+  }
+
+  @Test
+  public void comparePerf_random() {
+    comparePerf(true);
+  }
+
+  public void comparePerf(final boolean randomOrder) {
+    populateDatabases(randomOrder);
+    final ByteBuffer startKeyBuf = bb(data.get(0));
+    final ByteBuffer stopKeyBuf = bb(data.get(data.size() - 1));
+    final KeyRange<ByteBuffer> keyRange = KeyRange.closed(startKeyBuf, stopKeyBuf);
+
+    System.out.println("\nIterating over all entries");
+    for (int round = 0; round < 3; round++) {
+      System.out.println("round: " + round + " -----------------------------------------");
+      for (final Dbi<ByteBuffer> db : dbs) {
+        final String dbName = new String(db.getName(), StandardCharsets.UTF_8);
+
+        final Instant start = Instant.now();
+        int cnt = 0;
+        // Exercise the stop key comparator on every entry
+        try (Txn<ByteBuffer> txn = env.txnRead();
+            CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
+          for (final CursorIterable.KeyVal<ByteBuffer> kv : c) {
+            cnt++;
+          }
+        }
+        final Duration duration = Duration.between(start, Instant.now());
+        System.out.println(
+            "DB: "
+                + dbName
+                + " - Iterated in duration: "
+                + duration
+                + ", millis: "
+                + duration.toMillis()
+                + ", cnt: "
+                + cnt);
+      }
+    }
+  }
+}
diff --git a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
index f0471bab..4fa036f5 100644
--- a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
@@ -69,7 +69,7 @@ void testSignedComparator(
   void testUnsignedComparator(
       final String keyType, final String startKey, final String stopKey, final String expectedKV) {
     testCSV(
-        AbstractByteBufferProxy::compareBuff,
+        AbstractByteBufferProxy::compareLexicographically,
         false,
         createBasicDBPopulator(),
         EnumSet.of(MDB_CREATE),
@@ -99,7 +99,7 @@ void testSignedComparatorDupsort(
   void testUnsignedComparatorDupsort(
       final String keyType, final String startKey, final String stopKey, final String expectedKV) {
     testCSV(
-        AbstractByteBufferProxy::compareBuff,
+        AbstractByteBufferProxy::compareLexicographically,
         false,
         createMultiDBPopulator(2),
         EnumSet.of(MDB_CREATE, MDB_DUPSORT),
@@ -114,7 +114,7 @@ void testUnsignedComparatorDupsort(
   void testIntegerKey(
       final String keyType, final String startKey, final String stopKey, final String expectedKV) {
     testCSV(
-        AbstractByteBufferProxy::compareBuff,
+        AbstractByteBufferProxy::compareLexicographically,
         false,
         createIntegerDBPopulator(),
         EnumSet.of(MDB_CREATE, MDB_INTEGERKEY),
@@ -131,7 +131,7 @@ void testIntegerKey(
   void testLongKey(
       final String keyType, final String startKey, final String stopKey, final String expectedKV) {
     testCSV(
-        AbstractByteBufferProxy::compareBuff,
+        AbstractByteBufferProxy::compareLexicographically,
         false,
         createLongDBPopulator(),
         EnumSet.of(MDB_CREATE, MDB_INTEGERKEY),
diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index 5e515fee..4a8214e4 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -43,7 +43,9 @@
 import static org.lmdbjava.KeyRange.openClosedBackward;
 import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
 import static org.lmdbjava.TestUtils.DB_1;
-import static org.lmdbjava.TestUtils.POSIX_MODE;
+import static org.lmdbjava.TestUtils.DB_2;
+import static org.lmdbjava.TestUtils.DB_3;
+import static org.lmdbjava.TestUtils.DB_4;
 import static org.lmdbjava.TestUtils.bb;
 
 import com.google.common.primitives.UnsignedBytes;
@@ -55,35 +57,65 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.NoSuchElementException;
+import java.util.function.Function;
+import java.util.stream.Stream;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.params.Parameter;
+import org.junit.jupiter.params.ParameterizedClass;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.ArgumentsProvider;
+import org.junit.jupiter.params.provider.ArgumentsSource;
+import org.junit.jupiter.params.support.ParameterDeclarations;
 import org.lmdbjava.CursorIterable.KeyVal;
 
 /** Test {@link CursorIterable}. */
+@ParameterizedClass(name = "{index}: dbi: {0}")
+@ArgumentsSource(CursorIterableTest.MyArgumentProvider.class)
 public final class CursorIterableTest {
 
+  private static final DbiFlagSet DBI_FLAGS = MDB_CREATE;
+  private static final BufferProxy<ByteBuffer> BUFFER_PROXY = ByteBufferProxy.PROXY_OPTIMAL;
+
   private TempDir tempDir;
-  private Dbi<ByteBuffer> db;
   private Env<ByteBuffer> env;
   private Deque<Integer> list;
 
+  //  /**
+  //   * Injected by {@link #data()} with appropriate runner.
+  //   */
+  //  @SuppressWarnings("ClassEscapesDefinedScope")
+  @Parameter public DbiFactory dbiFactory;
+
   @BeforeEach
   void beforeEach() {
     tempDir = new TempDir();
+    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
     env =
-        create()
+        create(bufferProxy)
             .setMapSize(KIBIBYTES.toBytes(256))
             .setMaxReaders(1)
-            .setMaxDbs(1)
-            .open(tempDir.createTempFile().toFile(), POSIX_MODE, MDB_NOSUBDIR);
-    db = env.openDbi(DB_1, MDB_CREATE);
-    populateDatabase(db);
+            .setMaxDbs(3)
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(tempDir.createTempFile());
+
+    populateTestDataList();
   }
 
-  private void populateDatabase(final Dbi<ByteBuffer> dbi) {
+  @AfterEach
+  void afterEach() {
+    env.close();
+    tempDir.cleanup();
+  }
+
+  private void populateTestDataList() {
     list = new LinkedList<>();
     list.addAll(asList(2, 3, 4, 5, 6, 7, 8, 9));
+  }
+
+  private void populateDatabase(final Dbi<ByteBuffer> dbi) {
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       final Cursor<ByteBuffer> c = dbi.openCursor(txn);
       c.put(bb(2), bb(3), MDB_NOOVERWRITE);
@@ -94,12 +126,6 @@ private void populateDatabase(final Dbi<ByteBuffer> dbi) {
     }
   }
 
-  @AfterEach
-  void afterEach() {
-    env.close();
-    tempDir.cleanup();
-  }
-
   @Test
   void allBackwardTest() {
     verify(allBackward(), 8, 6, 4, 2);
@@ -179,6 +205,7 @@ void greaterThanTest() {
   void iterableOnlyReturnedOnce() {
     assertThatThrownBy(
             () -> {
+              final Dbi<ByteBuffer> db = getDb();
               try (Txn<ByteBuffer> txn = env.txnRead();
                   CursorIterable<ByteBuffer> c = db.iterate(txn)) {
                 c.iterator(); // ok
@@ -190,8 +217,10 @@ void iterableOnlyReturnedOnce() {
 
   @Test
   void iterate() {
+    final Dbi<ByteBuffer> db = getDb();
     try (Txn<ByteBuffer> txn = env.txnRead();
         CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+
       for (final KeyVal<ByteBuffer> kv : c) {
         assertThat(kv.key().getInt()).isEqualTo(list.pollFirst());
         assertThat(kv.val().getInt()).isEqualTo(list.pollFirst());
@@ -203,6 +232,7 @@ void iterate() {
   void iteratorOnlyReturnedOnce() {
     assertThatThrownBy(
             () -> {
+              final Dbi<ByteBuffer> db = getDb();
               try (Txn<ByteBuffer> txn = env.txnRead();
                   CursorIterable<ByteBuffer> c = db.iterate(txn)) {
                 c.iterator(); // ok
@@ -228,6 +258,8 @@ void lessThanTest() {
   void nextThrowsNoSuchElementExceptionIfNoMoreElements() {
     assertThatThrownBy(
             () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              populateTestDataList();
               try (Txn<ByteBuffer> txn = env.txnRead();
                   CursorIterable<ByteBuffer> c = db.iterate(txn)) {
                 final Iterator<KeyVal<ByteBuffer>> i = c.iterator();
@@ -272,7 +304,8 @@ void openClosedBackwardTestWithGuava() {
           bb2.reset();
           return guava.compare(array1, array2);
         };
-    final Dbi<ByteBuffer> guavaDbi = env.openDbi(DB_1, comparator, MDB_CREATE);
+    final Dbi<ByteBuffer> guavaDbi =
+        env.buildDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
     populateDatabase(guavaDbi);
     verify(openClosedBackward(bb(7), bb(2)), guavaDbi, 6, 4, 2);
     verify(openClosedBackward(bb(8), bb(4)), guavaDbi, 6, 4);
@@ -292,6 +325,7 @@ void openTest() {
 
   @Test
   void removeOddElements() {
+    final Dbi<ByteBuffer> db = getDb();
     verify(all(), 2, 4, 6, 8);
     int idx = -1;
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
@@ -307,13 +341,14 @@ void removeOddElements() {
       }
       txn.commit();
     }
-    verify(all(), 4, 8);
+    verify(db, all(), 4, 8);
   }
 
   @Test
   void nextWithClosedEnvTest() {
     assertThatThrownBy(
             () -> {
+              final Dbi<ByteBuffer> db = getDb();
               try (Txn<ByteBuffer> txn = env.txnRead()) {
                 try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
                   final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
@@ -330,6 +365,7 @@ void nextWithClosedEnvTest() {
   void removeWithClosedEnvTest() {
     assertThatThrownBy(
             () -> {
+              final Dbi<ByteBuffer> db = getDb();
               try (Txn<ByteBuffer> txn = env.txnWrite()) {
                 try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
                   final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
@@ -349,6 +385,7 @@ void removeWithClosedEnvTest() {
   void hasNextWithClosedEnvTest() {
     assertThatThrownBy(
             () -> {
+              final Dbi<ByteBuffer> db = getDb();
               try (Txn<ByteBuffer> txn = env.txnRead()) {
                 try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
                   final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
@@ -365,6 +402,7 @@ void hasNextWithClosedEnvTest() {
   void forEachRemainingWithClosedEnvTest() {
     assertThatThrownBy(
             () -> {
+              final Dbi<ByteBuffer> db = getDb();
               try (Txn<ByteBuffer> txn = env.txnRead()) {
                 try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
                   final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
@@ -377,12 +415,67 @@ void forEachRemainingWithClosedEnvTest() {
         .isInstanceOf(Env.AlreadyClosedException.class);
   }
 
+  //  @Test
+  //  public void testSignedVsUnsigned() {
+  //    final ByteBuffer val1 = bb(1);
+  //    final ByteBuffer val2 = bb(2);
+  //    final ByteBuffer val110 = bb(110);
+  //    final ByteBuffer val111 = bb(111);
+  //    final ByteBuffer val150 = bb(150);
+  //
+  //    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
+  //    final Comparator<ByteBuffer> unsignedComparator = bufferProxy.getUnsignedComparator();
+  //    final Comparator<ByteBuffer> signedComparator = bufferProxy.getSignedComparator();
+  //
+  //    // Compare the same
+  //    assertThat(
+  //        unsignedComparator.compare(val1, val2), Matchers.is(signedComparator.compare(val1,
+  // val2)));
+  //
+  //    // Compare differently
+  //    assertThat(
+  //        unsignedComparator.compare(val110, val150),
+  //        Matchers.not(signedComparator.compare(val110, val150)));
+  //
+  //    // Compare differently
+  //    assertThat(
+  //        unsignedComparator.compare(val111, val150),
+  //        Matchers.not(signedComparator.compare(val111, val150)));
+  //
+  //    // This will fail if the db is using a signed comparator for the start/stop keys
+  //    for (final Dbi<ByteBuffer> db : dbs) {
+  //      db.put(val110, val110);
+  //      db.put(val150, val150);
+  //
+  //      final ByteBuffer startKeyBuf = val111;
+  //      KeyRange<ByteBuffer> keyRange = KeyRange.atLeastBackward(startKeyBuf);
+  //
+  //      try (Txn<ByteBuffer> txn = env.txnRead();
+  //          CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
+  //        for (final CursorIterable.KeyVal<ByteBuffer> kv : c) {
+  //          final int key = kv.key().getInt();
+  //          final int val = kv.val().getInt();
+  //          //          System.out.println("key: " + key + " val: " + val);
+  //          assertThat(key, is(110));
+  //          break;
+  //        }
+  //      }
+  //    }
+  //  }
+
   private void verify(final KeyRange<ByteBuffer> range, final int... expected) {
+    final Dbi<ByteBuffer> db = getDb();
     verify(range, db, expected);
   }
 
+  private void verify(
+      final Dbi<ByteBuffer> dbi, final KeyRange<ByteBuffer> range, final int... expected) {
+    verify(range, dbi, expected);
+  }
+
   private void verify(
       final KeyRange<ByteBuffer> range, final Dbi<ByteBuffer> dbi, final int... expected) {
+
     final List<Integer> results = new ArrayList<>();
 
     try (Txn<ByteBuffer> txn = env.txnRead();
@@ -400,4 +493,76 @@ private void verify(
       assertThat(results.get(idx)).isEqualTo(expected[idx]);
     }
   }
+
+  private Dbi<ByteBuffer> getDb() {
+    final Dbi<ByteBuffer> dbi = dbiFactory.factory.apply(env);
+    populateDatabase(dbi);
+    return dbi;
+  }
+
+  // --------------------------------------------------------------------------------
+
+  private static class DbiFactory {
+    private final String name;
+    private final Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory;
+
+    private DbiFactory(String name, Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory) {
+      this.name = name;
+      this.factory = factory;
+    }
+
+    @Override
+    public String toString() {
+      return name;
+    }
+  }
+
+  // --------------------------------------------------------------------------------
+
+  static class MyArgumentProvider implements ArgumentsProvider {
+
+    @Override
+    public Stream<? extends Arguments> provideArguments(
+        ParameterDeclarations parameters, ExtensionContext context) throws Exception {
+      final DbiFactory defaultComparatorDb =
+          new DbiFactory(
+              "defaultComparator",
+              env ->
+                  env.buildDbi()
+                      .setDbName(DB_1)
+                      .withDefaultComparator()
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      final DbiFactory nativeComparatorDb =
+          new DbiFactory(
+              "nativeComparator",
+              env ->
+                  env.buildDbi()
+                      .setDbName(DB_2)
+                      .withNativeComparator()
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      final DbiFactory callbackComparatorDb =
+          new DbiFactory(
+              "callbackComparator",
+              env ->
+                  env.buildDbi()
+                      .setDbName(DB_3)
+                      .withCallbackComparator(BUFFER_PROXY::getComparator)
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      final DbiFactory iteratorComparatorDb =
+          new DbiFactory(
+              "iteratorComparator",
+              env ->
+                  env.buildDbi()
+                      .setDbName(DB_4)
+                      .withIteratorComparator(BUFFER_PROXY::getComparator)
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      return Stream.of(
+              defaultComparatorDb, nativeComparatorDb, callbackComparatorDb, iteratorComparatorDb)
+          .map(Arguments::of);
+    }
+  }
 }
diff --git a/src/test/java/org/lmdbjava/DbiBuilderTest.java b/src/test/java/org/lmdbjava/DbiBuilderTest.java
new file mode 100644
index 00000000..4ef11f2a
--- /dev/null
+++ b/src/test/java/org/lmdbjava/DbiBuilderTest.java
@@ -0,0 +1,204 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import static com.jakewharton.byteunits.BinaryByteUnit.MEBIBYTES;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.lmdbjava.Env.create;
+import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
+import static org.lmdbjava.TestUtils.bb;
+import static org.lmdbjava.TestUtils.getString;
+
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class DbiBuilderTest {
+
+  private TempDir tempDir;
+  private Env<ByteBuffer> env;
+
+  @BeforeEach
+  public void before() {
+    tempDir = new TempDir();
+    env =
+        create()
+            .setMapSize(MEBIBYTES.toBytes(64))
+            .setMaxReaders(2)
+            .setMaxDbs(2)
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(tempDir.createTempFile());
+  }
+
+  @AfterEach
+  public void after() {
+    env.close();
+    tempDir.cleanup();
+  }
+
+  @Test
+  public void unnamed() {
+    final Dbi<ByteBuffer> dbi =
+        env.buildDbi()
+            .withoutDbName()
+            .withDefaultComparator()
+            .setDbiFlags(DbiFlags.MDB_CREATE)
+            .open();
+    assertThat(dbi.getName()).isNull();
+    assertThat(dbi.getNameAsString()).isEmpty();
+    assertThat(env.getDbiNames()).isEmpty();
+    assertPutAndGet(dbi);
+  }
+
+  @Test
+  public void named() {
+    final Dbi<ByteBuffer> dbi =
+        env.buildDbi()
+            .setDbName("foo")
+            .withDefaultComparator()
+            .setDbiFlags(DbiFlags.MDB_CREATE)
+            .open();
+
+    assertPutAndGet(dbi);
+
+    assertThat(env.getDbiNames()).hasSize(1);
+    assertThat(new String(env.getDbiNames().get(0), StandardCharsets.UTF_8)).isEqualTo("foo");
+    assertThat(dbi.getNameAsString()).isEqualTo("foo");
+    assertThat(dbi.getNameAsString(StandardCharsets.UTF_8)).isEqualTo("foo");
+  }
+
+  @Test
+  public void named2() {
+    final Dbi<ByteBuffer> dbi =
+        env.buildDbi()
+            .setDbName("foo".getBytes(StandardCharsets.US_ASCII))
+            .withDefaultComparator()
+            .setDbiFlags(DbiFlags.MDB_CREATE)
+            .open();
+
+    assertPutAndGet(dbi);
+
+    assertThat(env.getDbiNames()).hasSize(1);
+    assertThat(new String(env.getDbiNames().get(0), StandardCharsets.US_ASCII)).isEqualTo("foo");
+    assertThat(dbi.getNameAsString()).isEqualTo("foo");
+    assertThat(dbi.getNameAsString(StandardCharsets.US_ASCII)).isEqualTo("foo");
+  }
+
+  @Test
+  public void nativeComparator() {
+    final Dbi<ByteBuffer> dbi =
+        env.buildDbi()
+            .setDbName("foo")
+            .withNativeComparator()
+            .addDbiFlags(DbiFlags.MDB_CREATE)
+            .open();
+
+    assertPutAndGet(dbi);
+    assertThat(env.getDbiNames()).hasSize(1);
+  }
+
+  @Test
+  public void callback() {
+    final Comparator<ByteBuffer> proxyOptimal = ByteBufferProxy.PROXY_OPTIMAL.getComparator();
+    // Compare on key length, falling back to default
+    final Comparator<ByteBuffer> comparator =
+        (o1, o2) -> {
+          final int res = Integer.compare(o1.remaining(), o2.remaining());
+          if (res == 0) {
+            return proxyOptimal.compare(o1, o2);
+          } else {
+            return res;
+          }
+        };
+
+    final Dbi<ByteBuffer> dbi =
+        env.buildDbi()
+            .setDbName("foo")
+            .withCallbackComparator(ignored -> comparator)
+            .addDbiFlags(DbiFlags.MDB_CREATE)
+            .open();
+
+    TestUtils.doWithWriteTxn(
+        env,
+        txn -> {
+          dbi.put(txn, bb("fox"), bb("val_1"));
+          dbi.put(txn, bb("rabbit"), bb("val_2"));
+          dbi.put(txn, bb("deer"), bb("val_3"));
+          dbi.put(txn, bb("badger"), bb("val_4"));
+          txn.commit();
+        });
+
+    final List<String> keys = new ArrayList<>();
+    TestUtils.doWithReadTxn(
+        env,
+        txn -> {
+          try (CursorIterable<ByteBuffer> cursorIterable = dbi.iterate(txn)) {
+            final Iterator<CursorIterable.KeyVal<ByteBuffer>> iterator = cursorIterable.iterator();
+            iterator.forEachRemaining(
+                keyVal -> {
+                  keys.add(getString(keyVal.key()));
+                });
+          }
+        });
+    assertThat(keys).containsExactly("fox", "deer", "badger", "rabbit");
+  }
+
+  @Test
+  public void flags() {
+    final Dbi<ByteBuffer> dbi =
+        env.buildDbi()
+            .setDbName("foo")
+            .withDefaultComparator()
+            .setDbiFlags(DbiFlags.MDB_DUPSORT, DbiFlags.MDB_DUPFIXED) // Will get overwritten
+            .setDbiFlags() // clear them
+            .addDbiFlags(DbiFlags.MDB_CREATE) // Not a dbi flag as far as lmdb is concerned.
+            .addDbiFlags(DbiFlags.MDB_INTEGERKEY)
+            .addDbiFlags(DbiFlags.MDB_REVERSEKEY)
+            .open();
+
+    assertPutAndGet(dbi);
+
+    assertThat(env.getDbiNames()).hasSize(1);
+    assertThat(new String(env.getDbiNames().get(0), StandardCharsets.UTF_8)).isEqualTo("foo");
+
+    TestUtils.doWithReadTxn(
+        env,
+        readTxn -> {
+          assertThat(dbi.listFlags(readTxn))
+              .containsExactlyInAnyOrder(DbiFlags.MDB_INTEGERKEY, DbiFlags.MDB_REVERSEKEY);
+        });
+  }
+
+  private void assertPutAndGet(Dbi<ByteBuffer> dbi) {
+    try (Txn<ByteBuffer> writeTxn = env.txnWrite()) {
+      dbi.put(writeTxn, bb(123), bb(123_000));
+      writeTxn.commit();
+    }
+
+    try (Txn<ByteBuffer> readTxn = env.txnRead()) {
+      final ByteBuffer byteBuffer = dbi.get(readTxn, bb(123));
+      assertThat(byteBuffer).isNotNull();
+      final int val = byteBuffer.getInt();
+      assertThat(val).isEqualTo(123_000);
+    }
+  }
+}
diff --git a/src/test/java/org/lmdbjava/DbiFlagSetTest.java b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
new file mode 100644
index 00000000..12536957
--- /dev/null
+++ b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import org.junit.jupiter.api.Test;
+
+public class DbiFlagSetTest {
+
+  @Test
+  public void testEmpty() {
+    final DbiFlagSet dbiFlagSet = DbiFlagSet.empty();
+    assertThat(dbiFlagSet.getMask()).isEqualTo(0);
+    assertThat(dbiFlagSet.size()).isEqualTo(0);
+    assertThat(dbiFlagSet.isEmpty()).isEqualTo(true);
+    assertThat(dbiFlagSet.isSet(DbiFlags.MDB_REVERSEDUP)).isEqualTo(false);
+    final DbiFlagSet dbiFlagSet2 = DbiFlagSet.builder().build();
+    assertThat(dbiFlagSet).isEqualTo(dbiFlagSet2);
+    assertThat(dbiFlagSet).isNotEqualTo(DbiFlagSet.of(DbiFlags.MDB_CREATE));
+    assertThat(dbiFlagSet).isNotEqualTo(DbiFlagSet.of(DbiFlags.MDB_CREATE, DbiFlags.MDB_DUPSORT));
+    assertThat(dbiFlagSet)
+        .isNotEqualTo(
+            DbiFlagSet.builder()
+                .setFlag(DbiFlags.MDB_CREATE)
+                .setFlag(DbiFlags.MDB_DUPFIXED)
+                .build());
+  }
+
+  @Test
+  public void testOf() {
+    final DbiFlags dbiFlag = DbiFlags.MDB_CREATE;
+    final DbiFlagSet dbiFlagSet = DbiFlagSet.of(dbiFlag);
+    assertThat(dbiFlagSet.getMask()).isEqualTo(MaskedFlag.mask(dbiFlag));
+    assertThat(dbiFlagSet.size()).isEqualTo(1);
+    assertThat(dbiFlagSet.isSet(DbiFlags.MDB_REVERSEDUP)).isEqualTo(false);
+    for (DbiFlags flag : dbiFlagSet) {
+      assertThat(dbiFlagSet.isSet(flag)).isEqualTo(true);
+    }
+
+    final DbiFlagSet dbiFlagSet2 = DbiFlagSet.builder().setFlag(dbiFlag).build();
+    assertThat(dbiFlagSet).isEqualTo(dbiFlagSet2);
+  }
+
+  @Test
+  public void testOf2() {
+    final DbiFlags dbiFlag1 = DbiFlags.MDB_CREATE;
+    final DbiFlags dbiFlag2 = DbiFlags.MDB_INTEGERKEY;
+    final DbiFlagSet dbiFlagSet = DbiFlagSet.of(dbiFlag1, dbiFlag2);
+    assertThat(dbiFlagSet.getMask()).isEqualTo(MaskedFlag.mask(dbiFlag1, dbiFlag2));
+    assertThat(dbiFlagSet.size()).isEqualTo(2);
+    assertThat(dbiFlagSet.isSet(DbiFlags.MDB_REVERSEDUP)).isEqualTo(false);
+    for (DbiFlags flag : dbiFlagSet) {
+      assertThat(dbiFlagSet.isSet(flag)).isEqualTo(true);
+    }
+  }
+
+  @Test
+  public void testBuilder() {
+    final DbiFlags dbiFlag1 = DbiFlags.MDB_CREATE;
+    final DbiFlags dbiFlag2 = DbiFlags.MDB_INTEGERKEY;
+    final DbiFlagSet dbiFlagSet = DbiFlagSet.builder().setFlag(dbiFlag1).setFlag(dbiFlag2).build();
+    assertThat(dbiFlagSet.getMask()).isEqualTo(MaskedFlag.mask(dbiFlag1, dbiFlag2));
+    assertThat(dbiFlagSet.size()).isEqualTo(2);
+    assertThat(dbiFlagSet.isSet(DbiFlags.MDB_REVERSEDUP)).isEqualTo(false);
+    for (DbiFlags flag : dbiFlagSet) {
+      assertThat(dbiFlagSet.isSet(flag)).isEqualTo(true);
+    }
+    final DbiFlagSet dbiFlagSet2 = DbiFlagSet.builder().withFlags(dbiFlag1, dbiFlag2).build();
+    final DbiFlagSet dbiFlagSet3 =
+        DbiFlagSet.builder().withFlags(new HashSet<>(Arrays.asList(dbiFlag1, dbiFlag2))).build();
+    assertThat(dbiFlagSet).isEqualTo(dbiFlagSet2);
+    assertThat(dbiFlagSet).isEqualTo(dbiFlagSet3);
+  }
+}
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 563215c4..632d51b5 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -57,8 +57,8 @@
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.BiConsumer;
-import java.util.function.Function;
 import java.util.function.IntFunction;
+import java.util.function.Supplier;
 import java.util.function.ToIntFunction;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
@@ -106,7 +106,12 @@ void afterEach() {
   void close() {
     assertThatThrownBy(
             () -> {
-              final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+              final Dbi<ByteBuffer> db =
+                  env.buildDbi()
+                      .setDbName(DB_1)
+                      .withDefaultComparator()
+                      .addDbiFlag(MDB_CREATE)
+                      .open();
               db.put(bb(1), bb(42));
               db.close();
               db.put(bb(2), bb(42)); // error
@@ -187,11 +192,11 @@ void dbiWithComparatorThreadSafetyByteArray() {
 
   private <T> void doDbiWithComparatorThreadSafety(
       Env<T> env,
-      Function<DbiFlags[], Comparator<T>> comparator,
+      Supplier<Comparator<T>> comparatorSupplier,
       IntFunction<T> serializer,
       ToIntFunction<T> deserializer) {
     final DbiFlags[] flags = new DbiFlags[] {MDB_CREATE, MDB_INTEGERKEY};
-    final Comparator<T> c = comparator.apply(flags);
+    final Comparator<T> c = comparatorSupplier.get();
     final Dbi<T> db = env.openDbi(DB_1, c, true, flags);
 
     final List<Integer> keys = range(0, 1_000).boxed().collect(toList());
diff --git a/src/test/java/org/lmdbjava/EnvFlagSetTest.java b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
new file mode 100644
index 00000000..f270507b
--- /dev/null
+++ b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import org.junit.jupiter.api.Test;
+
+public class EnvFlagSetTest {
+
+  @Test
+  public void testEmpty() {
+    final EnvFlagSet envFlagSet = EnvFlagSet.empty();
+    assertThat(envFlagSet.getMask()).isEqualTo(0);
+    assertThat(envFlagSet.size()).isEqualTo(0);
+    assertThat(envFlagSet.isEmpty()).isEqualTo(true);
+    assertThat(envFlagSet.isSet(EnvFlags.MDB_NOSUBDIR)).isEqualTo(false);
+    final EnvFlagSet envFlagSet2 = EnvFlagSet.builder().build();
+    assertThat(envFlagSet).isEqualTo(envFlagSet2);
+    assertThat(envFlagSet).isNotEqualTo(EnvFlagSet.of(EnvFlags.MDB_FIXEDMAP));
+    assertThat(envFlagSet)
+        .isNotEqualTo(EnvFlagSet.of(EnvFlags.MDB_FIXEDMAP, EnvFlags.MDB_NORDAHEAD));
+    assertThat(envFlagSet)
+        .isNotEqualTo(
+            EnvFlagSet.builder()
+                .setFlag(EnvFlags.MDB_FIXEDMAP)
+                .setFlag(EnvFlags.MDB_NORDAHEAD)
+                .build());
+  }
+
+  @Test
+  public void testOf() {
+    final EnvFlags envFlag = EnvFlags.MDB_FIXEDMAP;
+    final EnvFlagSet envFlagSet = EnvFlagSet.of(envFlag);
+    assertThat(envFlagSet.getMask()).isEqualTo(MaskedFlag.mask(envFlag));
+    assertThat(envFlagSet.size()).isEqualTo(1);
+    assertThat(envFlagSet.isSet(EnvFlags.MDB_NOSUBDIR)).isEqualTo(false);
+    for (EnvFlags flag : envFlagSet) {
+      assertThat(envFlagSet.isSet(flag)).isEqualTo(true);
+    }
+
+    final EnvFlagSet envFlagSet2 = EnvFlagSet.builder().setFlag(envFlag).build();
+    assertThat(envFlagSet).isEqualTo(envFlagSet2);
+  }
+
+  @Test
+  public void testOf2() {
+    final EnvFlags envFlag1 = EnvFlags.MDB_FIXEDMAP;
+    final EnvFlags envFlag2 = EnvFlags.MDB_NORDAHEAD;
+    final EnvFlagSet envFlagSet = EnvFlagSet.of(envFlag1, envFlag2);
+    assertThat(envFlagSet.getMask()).isEqualTo(MaskedFlag.mask(envFlag1, envFlag2));
+    assertThat(envFlagSet.size()).isEqualTo(2);
+    assertThat(envFlagSet.isSet(EnvFlags.MDB_WRITEMAP)).isEqualTo(false);
+    for (EnvFlags flag : envFlagSet) {
+      assertThat(envFlagSet.isSet(flag)).isEqualTo(true);
+    }
+  }
+
+  @Test
+  public void testBuilder() {
+    final EnvFlags envFlag1 = EnvFlags.MDB_FIXEDMAP;
+    final EnvFlags envFlag2 = EnvFlags.MDB_NORDAHEAD;
+    final EnvFlagSet envFlagSet = EnvFlagSet.builder().setFlag(envFlag1).setFlag(envFlag2).build();
+    assertThat(envFlagSet.getMask()).isEqualTo(MaskedFlag.mask(envFlag1, envFlag2));
+    assertThat(envFlagSet.size()).isEqualTo(2);
+    assertThat(envFlagSet.isSet(EnvFlags.MDB_NOTLS)).isEqualTo(false);
+    for (EnvFlags flag : envFlagSet) {
+      assertThat(envFlagSet.isSet(flag)).isEqualTo(true);
+    }
+    final EnvFlagSet envFlagSet2 = EnvFlagSet.builder().withFlags(envFlag1, envFlag2).build();
+    final EnvFlagSet envFlagSet3 =
+        EnvFlagSet.builder().withFlags(new HashSet<>(Arrays.asList(envFlag1, envFlag2))).build();
+    assertThat(envFlagSet).isEqualTo(envFlagSet2);
+    assertThat(envFlagSet).isEqualTo(envFlagSet3);
+  }
+}
diff --git a/src/test/java/org/lmdbjava/KeyRangeTest.java b/src/test/java/org/lmdbjava/KeyRangeTest.java
index 0f77b92f..2e8854b9 100644
--- a/src/test/java/org/lmdbjava/KeyRangeTest.java
+++ b/src/test/java/org/lmdbjava/KeyRangeTest.java
@@ -194,7 +194,10 @@ private void verify(final KeyRange<Integer> range, final int... expected) {
 
     IteratorOp op;
     do {
-      op = range.getType().iteratorOp(range.getStart(), range.getStop(), buff, Integer::compare);
+      final Integer finalBuff = buff;
+      final RangeComparator rangeComparator =
+          new CursorIterable.JavaRangeComparator<>(range, Integer::compareTo, () -> finalBuff);
+      op = range.getType().iteratorOp(buff, rangeComparator);
       switch (op) {
         case CALL_NEXT_OP:
           buff = cursor.apply(range.getType().nextOp(), range.getStart());
diff --git a/src/test/java/org/lmdbjava/PutFlagSetTest.java b/src/test/java/org/lmdbjava/PutFlagSetTest.java
new file mode 100644
index 00000000..c7634769
--- /dev/null
+++ b/src/test/java/org/lmdbjava/PutFlagSetTest.java
@@ -0,0 +1,131 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.time.Duration;
+import java.time.Instant;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import org.junit.jupiter.api.Test;
+
+public class PutFlagSetTest {
+
+  @Test
+  public void testEmpty() {
+    final PutFlagSet putFlagSet = PutFlagSet.empty();
+    assertThat(putFlagSet.getMask()).isEqualTo(0);
+    assertThat(putFlagSet.size()).isEqualTo(0);
+    assertThat(putFlagSet.isEmpty()).isEqualTo(true);
+    assertThat(putFlagSet.isSet(PutFlags.MDB_MULTIPLE)).isEqualTo(false);
+    final PutFlagSet putFlagSet2 = PutFlagSet.builder().build();
+    assertThat(putFlagSet).isEqualTo(putFlagSet2);
+    assertThat(putFlagSet).isNotEqualTo(PutFlagSet.of(PutFlags.MDB_APPEND));
+    assertThat(putFlagSet).isNotEqualTo(PutFlagSet.of(PutFlags.MDB_APPEND, PutFlags.MDB_RESERVE));
+    assertThat(putFlagSet)
+        .isNotEqualTo(
+            PutFlagSet.builder()
+                .setFlag(PutFlags.MDB_CURRENT)
+                .setFlag(PutFlags.MDB_MULTIPLE)
+                .build());
+  }
+
+  @Test
+  public void testOf() {
+    final PutFlags putFlag = PutFlags.MDB_APPEND;
+    final PutFlagSet putFlagSet = PutFlagSet.of(putFlag);
+    assertThat(putFlagSet.getMask()).isEqualTo(MaskedFlag.mask(putFlag));
+    assertThat(putFlagSet.size()).isEqualTo(1);
+    assertThat(putFlagSet.isSet(PutFlags.MDB_MULTIPLE)).isEqualTo(false);
+    for (PutFlags flag : putFlagSet) {
+      assertThat(putFlagSet.isSet(flag)).isEqualTo(true);
+    }
+
+    final PutFlagSet putFlagSet2 = PutFlagSet.builder().setFlag(putFlag).build();
+    assertThat(putFlagSet).isEqualTo(putFlagSet2);
+  }
+
+  @Test
+  public void testOf2() {
+    final PutFlags putFlag1 = PutFlags.MDB_APPEND;
+    final PutFlags putFlag2 = PutFlags.MDB_NOOVERWRITE;
+    final PutFlagSet putFlagSet = PutFlagSet.of(putFlag1, putFlag2);
+    assertThat(putFlagSet.getMask()).isEqualTo(MaskedFlag.mask(putFlag1, putFlag2));
+    assertThat(putFlagSet.size()).isEqualTo(2);
+    assertThat(putFlagSet.isSet(PutFlags.MDB_MULTIPLE)).isEqualTo(false);
+    for (PutFlags flag : putFlagSet) {
+      assertThat(putFlagSet.isSet(flag)).isEqualTo(true);
+    }
+  }
+
+  @Test
+  public void testBuilder() {
+    final PutFlags putFlag1 = PutFlags.MDB_APPEND;
+    final PutFlags putFlag2 = PutFlags.MDB_NOOVERWRITE;
+    final PutFlagSet putFlagSet = PutFlagSet.builder().setFlag(putFlag1).setFlag(putFlag2).build();
+    assertThat(putFlagSet.getMask()).isEqualTo(MaskedFlag.mask(putFlag1, putFlag2));
+    assertThat(putFlagSet.size()).isEqualTo(2);
+    assertThat(putFlagSet.isSet(PutFlags.MDB_MULTIPLE)).isEqualTo(false);
+    for (PutFlags flag : putFlagSet) {
+      assertThat(putFlagSet.isSet(flag)).isEqualTo(true);
+    }
+    final PutFlagSet putFlagSet2 = PutFlagSet.builder().withFlags(putFlag1, putFlag2).build();
+    final PutFlagSet putFlagSet3 =
+        PutFlagSet.builder().withFlags(new HashSet<>(Arrays.asList(putFlag1, putFlag2))).build();
+    assertThat(putFlagSet).isEqualTo(putFlagSet2);
+    assertThat(putFlagSet).isEqualTo(putFlagSet3);
+  }
+
+  @Test
+  public void testAddFlagVsCheckPresence() {
+
+    final int cnt = 10_000_000;
+    final int[] arr = new int[cnt];
+    final List<PutFlagSet> flagSets =
+        IntStream.range(0, cnt)
+            .boxed()
+            .map(
+                i ->
+                    PutFlagSet.of(
+                        PutFlags.MDB_APPEND, PutFlags.MDB_NOOVERWRITE, PutFlags.MDB_RESERVE))
+            .collect(Collectors.toList());
+
+    Instant time;
+    for (int i = 0; i < 5; i++) {
+      time = Instant.now();
+      for (int j = 0; j < flagSets.size(); j++) {
+        PutFlagSet flagSet = flagSets.get(j);
+        if (!flagSet.isSet(PutFlags.MDB_RESERVE)) {
+          throw new RuntimeException("Not set");
+        }
+        arr[j] = flagSet.getMask();
+      }
+      System.out.println("Check: " + Duration.between(time, Instant.now()));
+
+      time = Instant.now();
+      for (int j = 0; j < flagSets.size(); j++) {
+        PutFlagSet flagSet = flagSets.get(j);
+        final int mask = flagSet.getMaskWith(PutFlags.MDB_RESERVE);
+        arr[j] = mask;
+      }
+      System.out.println("Append:" + Duration.between(time, Instant.now()));
+    }
+  }
+}
diff --git a/src/test/java/org/lmdbjava/TestUtils.java b/src/test/java/org/lmdbjava/TestUtils.java
index 23606862..abaf63bb 100644
--- a/src/test/java/org/lmdbjava/TestUtils.java
+++ b/src/test/java/org/lmdbjava/TestUtils.java
@@ -22,6 +22,11 @@
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
 import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.charset.StandardCharsets;
+import java.util.Objects;
+import java.util.function.Consumer;
+import java.util.function.Function;
 import org.agrona.MutableDirectBuffer;
 import org.agrona.concurrent.UnsafeBuffer;
 
@@ -29,6 +34,9 @@
 final class TestUtils {
 
   public static final String DB_1 = "test-db-1";
+  public static final String DB_2 = "test-db-2";
+  public static final String DB_3 = "test-db-3";
+  public static final String DB_4 = "test-db-2";
 
   public static final int POSIX_MODE = 0664;
 
@@ -56,6 +64,53 @@ static ByteBuffer bb(final long value) {
     return bb;
   }
 
+  static ByteBuffer bb(final String value) {
+    final ByteBuffer bb = allocateDirect(100);
+    if (value != null) {
+      bb.put(value.getBytes(StandardCharsets.UTF_8));
+      bb.flip();
+    }
+    return bb;
+  }
+
+  static ByteBuffer bbNative(final int value) {
+    final ByteBuffer bb = allocateDirect(Integer.BYTES).order(ByteOrder.nativeOrder());
+    bb.putInt(value).flip();
+    return bb;
+  }
+
+  static ByteBuffer bbNative(final long value) {
+    final ByteBuffer bb = allocateDirect(Long.BYTES).order(ByteOrder.nativeOrder());
+    bb.putLong(value).flip();
+    return bb;
+  }
+
+  static int getNativeInt(final ByteBuffer bb) {
+    final int val = bb.order(ByteOrder.nativeOrder()).getInt();
+    bb.rewind();
+    return val;
+  }
+
+  static long getNativeLong(final ByteBuffer bb) {
+    final long val = bb.order(ByteOrder.nativeOrder()).getLong();
+    bb.rewind();
+    return val;
+  }
+
+  static long getNativeIntOrLong(final ByteBuffer bb) {
+    if (bb.remaining() == Integer.BYTES) {
+      return getNativeInt(bb);
+    } else {
+      return getNativeLong(bb);
+    }
+  }
+
+  static String getString(final ByteBuffer bb) {
+    final String str = StandardCharsets.UTF_8.decode(bb).toString();
+    bb.rewind();
+    return str;
+  }
+
   static byte[] getBytes(final ByteBuffer byteBuffer) {
     if (byteBuffer == null) {
       return null;
@@ -90,4 +145,36 @@ static ByteBuf nb(final int value) {
     b.writeInt(value);
     return b;
   }
+
+  static <T> void doWithReadTxn(final Env<T> env, final Consumer<Txn<T>> work) {
+    Objects.requireNonNull(env);
+    Objects.requireNonNull(work);
+    try (Txn<T> readTxn = env.txnRead()) {
+      work.accept(readTxn);
+    }
+  }
+
+  static <T, R> R getWithReadTxn(final Env<T> env, final Function<Txn<T>, R> work) {
+    Objects.requireNonNull(env);
+    Objects.requireNonNull(work);
+    try (Txn<T> readTxn = env.txnRead()) {
+      return work.apply(readTxn);
+    }
+  }
+
+  static <T> void doWithWriteTxn(final Env<T> env, final Consumer<Txn<T>> work) {
+    Objects.requireNonNull(env);
+    Objects.requireNonNull(work);
+    try (Txn<T> readTxn = env.txnWrite()) {
+      work.accept(readTxn);
+    }
+  }
+
+  static <T, R> R getWithWriteTxn(final Env<T> env, final Function<Txn<T>, R> work) {
+    Objects.requireNonNull(env);
+    Objects.requireNonNull(work);
+    try (Txn<T> readTxn = env.txnWrite()) {
+      return work.apply(readTxn);
+    }
+  }
 }
diff --git a/src/test/java/org/lmdbjava/TxnFlagSetTest.java b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
new file mode 100644
index 00000000..08788c63
--- /dev/null
+++ b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.Collections;
+import java.util.HashSet;
+import org.junit.jupiter.api.Test;
+
+public class TxnFlagSetTest {
+
+  @Test
+  void testSingleEnum() {
+    final TxnFlagSet txnFlagSet = TxnFlags.MDB_RDONLY_TXN;
+    assertThat(txnFlagSet.getMask()).isEqualTo(MaskedFlag.mask(TxnFlags.MDB_RDONLY_TXN));
+    assertThat(txnFlagSet.size()).isEqualTo(1);
+    for (TxnFlags flag : txnFlagSet) {
+      assertThat(txnFlagSet.isSet(flag)).isEqualTo(true);
+    }
+
+    final TxnFlagSet txnFlagSet2 = TxnFlagSet.builder().setFlag(TxnFlags.MDB_RDONLY_TXN).build();
+    assertThat(txnFlagSet2.getFlags()).containsExactlyElementsOf(txnFlagSet.getFlags());
+    assertThat(txnFlagSet.areAnySet(TxnFlags.MDB_RDONLY_TXN)).isTrue();
+    assertThat(txnFlagSet.areAnySet(TxnFlagSet.empty())).isFalse();
+  }
+
+  @Test
+  public void testEmpty() {
+    final TxnFlagSet txnFlagSet = TxnFlagSet.empty();
+    assertThat(txnFlagSet.getMask()).isEqualTo(0);
+    assertThat(txnFlagSet.size()).isEqualTo(0);
+    assertThat(txnFlagSet.isEmpty()).isEqualTo(true);
+    assertThat(txnFlagSet.isSet(TxnFlags.MDB_RDONLY_TXN)).isEqualTo(false);
+    final TxnFlagSet txnFlagSet2 = TxnFlagSet.builder().build();
+    assertThat(txnFlagSet).isEqualTo(txnFlagSet2);
+    assertThat(txnFlagSet).isNotEqualTo(TxnFlagSet.of(TxnFlags.MDB_RDONLY_TXN));
+    assertThat(txnFlagSet)
+        .isNotEqualTo(TxnFlagSet.builder().setFlag(TxnFlags.MDB_RDONLY_TXN).build());
+  }
+
+  @Test
+  public void testOf() {
+    final TxnFlags txnFlag = TxnFlags.MDB_RDONLY_TXN;
+    final TxnFlagSet txnFlagSet = TxnFlagSet.of(txnFlag);
+    assertThat(txnFlagSet.getMask()).isEqualTo(MaskedFlag.mask(txnFlag));
+    assertThat(txnFlagSet.size()).isEqualTo(1);
+    for (TxnFlags flag : txnFlagSet) {
+      assertThat(txnFlagSet.isSet(flag)).isEqualTo(true);
+    }
+
+    final TxnFlagSet txnFlagSet2 = TxnFlagSet.builder().setFlag(txnFlag).build();
+    assertThat(txnFlagSet).isEqualTo(txnFlagSet2);
+  }
+
+  @Test
+  public void testBuilder() {
+    final TxnFlags txnFlag1 = TxnFlags.MDB_RDONLY_TXN;
+    final TxnFlagSet txnFlagSet = TxnFlagSet.builder().setFlag(txnFlag1).build();
+    assertThat(txnFlagSet.getMask()).isEqualTo(MaskedFlag.mask(txnFlag1));
+    assertThat(txnFlagSet.size()).isEqualTo(1);
+    assertThat(txnFlagSet.isSet(TxnFlags.MDB_RDONLY_TXN)).isEqualTo(true);
+    for (TxnFlags flag : txnFlagSet) {
+      assertThat(txnFlagSet.isSet(flag)).isEqualTo(true);
+    }
+    final TxnFlagSet txnFlagSet2 = TxnFlagSet.builder().withFlags(txnFlag1).build();
+    final TxnFlagSet txnFlagSet3 =
+        TxnFlagSet.builder().withFlags(new HashSet<>(Collections.singletonList(txnFlag1))).build();
+    assertThat(txnFlagSet).isEqualTo(txnFlagSet2);
+    assertThat(txnFlagSet).isEqualTo(txnFlagSet3);
+  }
+}

From 484a772b03ad439ba5977d2afdca6e1d8bbf0118 Mon Sep 17 00:00:00 2001
From: stroomdev66 <stroomdev66@gmail.com>
Date: Wed, 5 Nov 2025 18:41:39 +0000
Subject: [PATCH 257/322] Merged new comparator code

---
 .../java/org/lmdbjava/CursorIterableRangeTest.java |  8 +++++---
 .../CursorIterableRangeTest/testIntegerKey.csv     | 14 ++++++--------
 .../CursorIterableRangeTest/testLongKey.csv        | 14 ++++++--------
 3 files changed, 17 insertions(+), 19 deletions(-)

diff --git a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
index 4fa036f5..f835c494 100644
--- a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
@@ -114,7 +114,7 @@ void testUnsignedComparatorDupsort(
   void testIntegerKey(
       final String keyType, final String startKey, final String stopKey, final String expectedKV) {
     testCSV(
-        AbstractByteBufferProxy::compareLexicographically,
+        AbstractByteBufferProxy::compareAsIntegerKeys,
         false,
         createIntegerDBPopulator(),
         EnumSet.of(MDB_CREATE, MDB_INTEGERKEY),
@@ -131,7 +131,7 @@ void testIntegerKey(
   void testLongKey(
       final String keyType, final String startKey, final String stopKey, final String expectedKV) {
     testCSV(
-        AbstractByteBufferProxy::compareLexicographically,
+        AbstractByteBufferProxy::compareAsIntegerKeys,
         false,
         createLongDBPopulator(),
         EnumSet.of(MDB_CREATE, MDB_INTEGERKEY),
@@ -183,7 +183,9 @@ private void testCSV(
               .setMapSize(KIBIBYTES.toBytes(256))
               .setMaxReaders(1)
               .setMaxDbs(1)
-              .open(file.toFile(), POSIX_MODE, MDB_NOSUBDIR)) {
+              .setFilePermissions(POSIX_MODE)
+              .setEnvFlags(MDB_NOSUBDIR)
+              .open(file)) {
         final Dbi<ByteBuffer> dbi =
             env.openDbi(DB_1, comparator, nativeCb, flags.toArray(new DbiFlags[0]));
         dbPopulator.accept(env, dbi);
diff --git a/src/test/resources/CursorIterableRangeTest/testIntegerKey.csv b/src/test/resources/CursorIterableRangeTest/testIntegerKey.csv
index d8d6dc35..df61bf73 100644
--- a/src/test/resources/CursorIterableRangeTest/testIntegerKey.csv
+++ b/src/test/resources/CursorIterableRangeTest/testIntegerKey.csv
@@ -43,13 +43,11 @@ BACKWARD_GREATER_THAN,1001,,[1000 2][0 1]
 BACKWARD_LESS_THAN,,999,[-1000 5][-1000000 4][1000000 3][1000 2]
 BACKWARD_LESS_THAN,,1000,[-1000 5][-1000000 4][1000000 3]
 BACKWARD_LESS_THAN,,1001,[-1000 5][-1000000 4][1000000 3]
-BACKWARD_OPEN,999,1001,[1000 2]
-BACKWARD_OPEN,999,1000,
-BACKWARD_OPEN,999,1001,[1000 2]
+BACKWARD_OPEN,1001,999,[1000 2]
+BACKWARD_OPEN,1000,999,
 BACKWARD_OPEN,1000,1000,
-BACKWARD_OPEN,1000,1001,
-BACKWARD_OPEN_CLOSED,999,1001,[1000 2]
-BACKWARD_OPEN_CLOSED,999,1000,[1000 2]
+BACKWARD_OPEN,1001,1000,
+BACKWARD_OPEN_CLOSED,1001,999,[1000 2]
+BACKWARD_OPEN_CLOSED,1000,999,
 BACKWARD_OPEN_CLOSED,1000,1000,
-BACKWARD_OPEN_CLOSED,1000,1001,
-BACKWARD_OPEN_CLOSED,1000,1001,
+BACKWARD_OPEN_CLOSED,1001,1000,[1000 2]
diff --git a/src/test/resources/CursorIterableRangeTest/testLongKey.csv b/src/test/resources/CursorIterableRangeTest/testLongKey.csv
index d8d6dc35..df61bf73 100644
--- a/src/test/resources/CursorIterableRangeTest/testLongKey.csv
+++ b/src/test/resources/CursorIterableRangeTest/testLongKey.csv
@@ -43,13 +43,11 @@ BACKWARD_GREATER_THAN,1001,,[1000 2][0 1]
 BACKWARD_LESS_THAN,,999,[-1000 5][-1000000 4][1000000 3][1000 2]
 BACKWARD_LESS_THAN,,1000,[-1000 5][-1000000 4][1000000 3]
 BACKWARD_LESS_THAN,,1001,[-1000 5][-1000000 4][1000000 3]
-BACKWARD_OPEN,999,1001,[1000 2]
-BACKWARD_OPEN,999,1000,
-BACKWARD_OPEN,999,1001,[1000 2]
+BACKWARD_OPEN,1001,999,[1000 2]
+BACKWARD_OPEN,1000,999,
 BACKWARD_OPEN,1000,1000,
-BACKWARD_OPEN,1000,1001,
-BACKWARD_OPEN_CLOSED,999,1001,[1000 2]
-BACKWARD_OPEN_CLOSED,999,1000,[1000 2]
+BACKWARD_OPEN,1001,1000,
+BACKWARD_OPEN_CLOSED,1001,999,[1000 2]
+BACKWARD_OPEN_CLOSED,1000,999,
 BACKWARD_OPEN_CLOSED,1000,1000,
-BACKWARD_OPEN_CLOSED,1000,1001,
-BACKWARD_OPEN_CLOSED,1000,1001,
+BACKWARD_OPEN_CLOSED,1001,1000,[1000 2]

From ad75cb2351ecf10b452e80005d68b04eb1af11f9 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Wed, 5 Nov 2025 21:08:15 +0000
Subject: [PATCH 258/322] Fix CodeQL issues, add setMapSizeXx methods

---
 .../java/org/lmdbjava/CursorIterable.java     |   2 +-
 src/main/java/org/lmdbjava/Dbi.java           | 120 +++---
 src/main/java/org/lmdbjava/DbiBuilder.java    |   8 +-
 src/main/java/org/lmdbjava/Env.java           | 125 +++++-
 src/main/java/org/lmdbjava/FlagSet.java       |   1 +
 src/main/java/org/lmdbjava/Verifier.java      |   2 +-
 .../org/lmdbjava/ByteBufferProxyTest.java     |  21 +-
 .../java/org/lmdbjava/CursorParamTest.java    |   2 +-
 src/test/java/org/lmdbjava/CursorTest.java    |  16 +-
 src/test/java/org/lmdbjava/DbiTest.java       |   8 +-
 src/test/java/org/lmdbjava/EnvTest.java       | 387 +++++++++---------
 src/test/java/org/lmdbjava/TutorialTest.java  |   2 +-
 12 files changed, 404 insertions(+), 290 deletions(-)

diff --git a/src/main/java/org/lmdbjava/CursorIterable.java b/src/main/java/org/lmdbjava/CursorIterable.java
index 69d43fcd..89dc5e84 100644
--- a/src/main/java/org/lmdbjava/CursorIterable.java
+++ b/src/main/java/org/lmdbjava/CursorIterable.java
@@ -115,7 +115,7 @@ public KeyVal<T> next() {
 
       @Override
       public void remove() {
-        cursor.delete();
+        cursor.delete(PutFlags.EMPTY);
       }
     };
   }
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index 5e8fa2f2..7347605f 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -49,7 +49,6 @@
  */
 public final class Dbi<T> {
 
-  private final ComparatorCallback callbackComparator;
   private boolean cleaned;
   // Used for CursorIterable KeyRange testing and/or native callbacks
   private final Comparator<T> comparator;
@@ -59,6 +58,14 @@ public final class Dbi<T> {
   private final BufferProxy<T> proxy;
   private final DbiFlagSet dbiFlagSet;
 
+  Dbi(final Env<T> env,
+      final Txn<T> txn,
+      final byte[] name,
+      final BufferProxy<T> proxy,
+      final DbiFlagSet dbiFlagSet) {
+    this(env, txn, name, null, false, proxy, dbiFlagSet);
+  }
+
   Dbi(
       final Env<T> env,
       final Txn<T> txn,
@@ -67,7 +74,11 @@ public final class Dbi<T> {
       final boolean nativeCb,
       final BufferProxy<T> proxy,
       final DbiFlagSet dbiFlagSet) {
+
     if (SHOULD_CHECK) {
+      if (nativeCb && comparator == null) {
+        throw new IllegalArgumentException("Is nativeCb is true, you must supply a comparator");
+      }
       requireNonNull(txn);
       txn.checkReady();
     }
@@ -75,40 +86,32 @@ public final class Dbi<T> {
     this.name = name == null ? null : Arrays.copyOf(name, name.length);
     this.proxy = proxy;
     this.comparator = comparator;
-    this.dbiFlagSet = dbiFlagSet;
+    this.dbiFlagSet = dbiFlagSet == null ? DbiFlagSet.EMPTY : dbiFlagSet;
     final Pointer dbiPtr = allocateDirect(RUNTIME, ADDRESS);
-    checkRc(LIB.mdb_dbi_open(txn.pointer(), name, dbiFlagSet.getMask(), dbiPtr));
+    checkRc(LIB.mdb_dbi_open(txn.pointer(), name, this.dbiFlagSet.getMask(), dbiPtr));
     ptr = dbiPtr.getPointer(0);
+    ComparatorCallback callbackComparator;
     if (nativeCb) {
-      requireNonNull(comparator, "comparator cannot be null if nativeCb is set");
       // LMDB will call back to this comparator for insertion/iteration order
-//      if (dbiFlagSet.areAnySet(DbiFlagSet.INTEGER_KEY_FLAGS)) {
-//        this.callbackComparator =
-//            (keyA, keyB) -> {
-//              final T compKeyA  = proxy.out(proxy.allocate(), keyA);
-//              final T compKeyB = proxy.out(proxy.allocate(), keyB);
-//              final int result = this.comparator.compare(compKeyA, compKeyB);
-//              proxy.deallocate(compKeyA);
-//              proxy.deallocate(compKeyB);
-//              return result;
-//            };
-//      } else {
-        this.callbackComparator =
-            (keyA, keyB) -> {
-              final T compKeyA  = proxy.out(proxy.allocate(), keyA);
-              final T compKeyB = proxy.out(proxy.allocate(), keyB);
-              final int result = this.comparator.compare(compKeyA, compKeyB);
-              proxy.deallocate(compKeyA);
-              proxy.deallocate(compKeyB);
-              return result;
-            };
-//      }
+      callbackComparator = createCallbackComparator(proxy);
       LIB.mdb_set_compare(txn.pointer(), ptr, callbackComparator);
-    } else {
-      callbackComparator = null;
     }
   }
 
+  private ComparatorCallback createCallbackComparator(BufferProxy<T> proxy) {
+    ComparatorCallback callbackComparator;
+    callbackComparator =
+        (keyA, keyB) -> {
+          final T compKeyA = proxy.out(proxy.allocate(), keyA);
+          final T compKeyB = proxy.out(proxy.allocate(), keyB);
+          final int result = this.comparator.compare(compKeyA, compKeyB);
+          proxy.deallocate(compKeyA);
+          proxy.deallocate(compKeyB);
+          return result;
+        };
+    return callbackComparator;
+  }
+
   Pointer pointer() {
     return ptr;
   }
@@ -215,7 +218,7 @@ public void drop(final Txn<T> txn) {
    * closed. See {@link #close()} for implication of handle close. Otherwise, only the data in this
    * database will be dropped.
    *
-   * @param txn transaction handle (not null; not committed; must be R-W)
+   * @param txn    transaction handle (not null; not committed; must be R-W)
    * @param delete whether database should be deleted.
    */
   public void drop(final Txn<T> txn, final boolean delete) {
@@ -311,7 +314,7 @@ public CursorIterable<T> iterate(final Txn<T> txn) {
   /**
    * Iterate the database in accordance with the provided {@link KeyRange}.
    *
-   * @param txn transaction handle (not null; not committed)
+   * @param txn   transaction handle (not null; not committed)
    * @param range range of acceptable keys (not null)
    * @return iterator (never null)
    */
@@ -392,6 +395,12 @@ public void put(final T key, final T val) {
   }
 
   /**
+   * @param txn   transaction handle (not null; not committed; must be R-W)
+   * @param key   key to store in the database (not null)
+   * @param val   value to store in the database (not null)
+   * @param flags Special options for this operation
+   * @return true if the value was put, false if MDB_NOOVERWRITE or MDB_NODUPDATA were set and the
+   * key/value existed already.
    * @deprecated Use {@link Dbi#put(Txn, Object, Object, PutFlagSet)} instead, with a statically
    * held {@link PutFlagSet}.
    * <hr>
@@ -401,13 +410,6 @@ public void put(final T key, final T val) {
    * <p>This function stores key/data pairs in the database. The default behavior is to enter the
    * new key/data pair, replacing any previously existing key if duplicates are disallowed, or
    * adding a duplicate data item if duplicates are allowed ({@link DbiFlags#MDB_DUPSORT}).
-   *
-   * @param txn transaction handle (not null; not committed; must be R-W)
-   * @param key key to store in the database (not null)
-   * @param val value to store in the database (not null)
-   * @param flags Special options for this operation
-   * @return true if the value was put, false if MDB_NOOVERWRITE or MDB_NODUPDATA were set and the
-   *     key/value existed already.
    */
   @Deprecated
   public boolean put(final Txn<T> txn, final T key, final T val, final PutFlags... flags) {
@@ -421,7 +423,7 @@ public boolean put(final Txn<T> txn, final T key, final T val, final PutFlags...
    * @param key key to store in the database (not null)
    * @param val value to store in the database (not null)
    * @return true if the value was put, false if MDB_NOOVERWRITE or MDB_NODUPDATA were set and the
-   *     key/value existed already.
+   * key/value existed already.
    * @see #put(Txn, Object, Object, PutFlagSet)
    */
   public boolean put(final Txn<T> txn, final T key, final T val) {
@@ -435,12 +437,12 @@ public boolean put(final Txn<T> txn, final T key, final T val) {
    * new key/data pair, replacing any previously existing key if duplicates are disallowed, or
    * adding a duplicate data item if duplicates are allowed ({@link DbiFlags#MDB_DUPSORT}).
    *
-   * @param txn transaction handle (not null; not committed; must be R-W)
-   * @param key key to store in the database (not null)
-   * @param val value to store in the database (not null)
+   * @param txn   transaction handle (not null; not committed; must be R-W)
+   * @param key   key to store in the database (not null)
+   * @param val   value to store in the database (not null)
    * @param flags Special options for this operation.
    * @return true if the value was put, false if MDB_NOOVERWRITE or MDB_NODUPDATA were set and the
-   *     key/value existed already.
+   * key/value existed already.
    */
   public boolean put(final Txn<T> txn, final T key, final T val, final PutFlagSet flags) {
     if (SHOULD_CHECK) {
@@ -480,10 +482,10 @@ public boolean put(final Txn<T> txn, final T key, final T val, final PutFlagSet
    *
    * <p>This flag must not be specified if the database was opened with MDB_DUPSORT
    *
-   * @param txn transaction handle (not null; not committed; must be R-W)
-   * @param key key to store in the database (not null)
+   * @param txn  transaction handle (not null; not committed; must be R-W)
+   * @param key  key to store in the database (not null)
    * @param size size of the value to be stored in the database
-   * @param op options for this operation
+   * @param op   options for this operation
    * @return a buffer that can be used to modify the value
    */
   public T reserve(final Txn<T> txn, final T key, final int size, final PutFlags... op) {
@@ -544,12 +546,14 @@ public String toString() {
       name = "?";
     }
     return "Dbi{" +
-            "name='" + name +
-            "', dbiFlagSet=" + dbiFlagSet +
-            '}';
+        "name='" + name +
+        "', dbiFlagSet=" + dbiFlagSet +
+        '}';
   }
 
-  /** The specified DBI was changed unexpectedly. */
+  /**
+   * The specified DBI was changed unexpectedly.
+   */
   public static final class BadDbiException extends LmdbNativeException {
 
     static final int MDB_BAD_DBI = -30_780;
@@ -560,7 +564,9 @@ public static final class BadDbiException extends LmdbNativeException {
     }
   }
 
-  /** Unsupported size of key/DB name/data, or wrong DUPFIXED size. */
+  /**
+   * Unsupported size of key/DB name/data, or wrong DUPFIXED size.
+   */
   public static final class BadValueSizeException extends LmdbNativeException {
 
     static final int MDB_BAD_VALSIZE = -30_781;
@@ -571,7 +577,9 @@ public static final class BadValueSizeException extends LmdbNativeException {
     }
   }
 
-  /** Environment maxdbs reached. */
+  /**
+   * Environment maxdbs reached.
+   */
   public static final class DbFullException extends LmdbNativeException {
 
     static final int MDB_DBS_FULL = -30_791;
@@ -604,7 +612,9 @@ public static final class IncompatibleException extends LmdbNativeException {
     }
   }
 
-  /** Key/data pair already exists. */
+  /**
+   * Key/data pair already exists.
+   */
   public static final class KeyExistsException extends LmdbNativeException {
 
     static final int MDB_KEYEXIST = -30_799;
@@ -615,7 +625,9 @@ public static final class KeyExistsException extends LmdbNativeException {
     }
   }
 
-  /** Key/data pair not found (EOF). */
+  /**
+   * Key/data pair not found (EOF).
+   */
   public static final class KeyNotFoundException extends LmdbNativeException {
 
     static final int MDB_NOTFOUND = -30_798;
@@ -626,7 +638,9 @@ public static final class KeyNotFoundException extends LmdbNativeException {
     }
   }
 
-  /** Database contents grew beyond environment mapsize. */
+  /**
+   * Database contents grew beyond environment mapsize.
+   */
   public static final class MapResizedException extends LmdbNativeException {
 
     static final int MDB_MAP_RESIZED = -30_785;
diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
index 9cb85616..062e77f4 100644
--- a/src/main/java/org/lmdbjava/DbiBuilder.java
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -391,10 +391,10 @@ public DbiBuilderStage3<T> setTxn(final Txn<T> txn) {
     public Dbi<T> open() {
       final DbiBuilder<T> dbiBuilder = dbiBuilderStage2.dbiBuilder;
       if (txn != null) {
-        return open(txn, dbiBuilder);
+        return openDbi(txn, dbiBuilder);
       } else {
         try (final Txn<T> txn = getTxn(dbiBuilder)) {
-          final Dbi<T> dbi = open(txn, dbiBuilder);
+          final Dbi<T> dbi = openDbi(txn, dbiBuilder);
           // even RO Txns require a commit to retain Dbi in Env
           txn.commit();
           return dbi;
@@ -432,8 +432,8 @@ private Comparator<T> getComparator(final DbiBuilder<T> dbiBuilder,
       return comparator;
     }
 
-    private Dbi<T> open(final Txn<T> txn,
-                        final DbiBuilder<T> dbiBuilder) {
+    private Dbi<T> openDbi(final Txn<T> txn,
+                           final DbiBuilder<T> dbiBuilder) {
       final DbiFlagSet dbiFlagSet = flagSetBuilder.build();
       final ComparatorType comparatorType = dbiBuilderStage2.comparatorType;
       final Comparator<T> comparator = getComparator(dbiBuilder, comparatorType, dbiFlagSet);
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index b8003cbb..e01de06b 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -63,6 +63,11 @@ public final class Env<T> implements AutoCloseable {
    */
   public static final boolean SHOULD_CHECK = !getBoolean(DISABLE_CHECKS_PROP);
 
+  private static final long KIBIBYTES = 1_024;
+  private static final long MEBIBYTES = KIBIBYTES * 1_024;
+  private static final long GIBIBYTES = MEBIBYTES * 1_024;
+  private static final long TEBIBYTES = GIBIBYTES * 1_024;
+
   private boolean closed;
   private final int maxKeySize;
   private final boolean noSubDir;
@@ -104,20 +109,19 @@ public static <T> Builder<T> create(final BufferProxy<T> proxy) {
   }
 
   /**
-   * @deprecated Instead use {@link Env#create()} or {@link Env#create(BufferProxy)}
-   * <p>
-   * Opens an environment with a single default database in 0664 mode using the {@link
-   * ByteBufferProxy#PROXY_OPTIMAL}.
-   *
    * @param path  file system destination
    * @param size  size in megabytes
    * @param flags the flags for this new environment
    * @return env the environment (never null)
+   * @deprecated Instead use {@link Env#create()} or {@link Env#create(BufferProxy)}
+   * <p>
+   * Opens an environment with a single default database in 0664 mode using the {@link
+   * ByteBufferProxy#PROXY_OPTIMAL}.
    */
   @Deprecated
   public static Env<ByteBuffer> open(final File path, final int size, final EnvFlags... flags) {
     return new Builder<>(PROXY_OPTIMAL)
-        .setMapSize(size * 1_024L * 1_024L)
+        .setMapSize(size * MEBIBYTES)
         .open(path, flags);
   }
 
@@ -193,9 +197,10 @@ public void copy(final File path, final CopyFlagSet flags) {
    */
   public List<byte[]> getDbiNames() {
     final List<byte[]> result = new ArrayList<>();
-    final Dbi<T> names = openDbi((byte[]) null);
-    try (Txn<T> txn = txnRead();
-         Cursor<T> cursor = names.openCursor(txn)) {
+    // The unnamed DB is special so the names of the named DBs are held as keys in it.
+    final Dbi<T> unnamedDb = openDbi((byte[]) null, DbiFlagSet.EMPTY);
+    try (final Txn<T> txn = txnRead();
+         final Cursor<T> cursor = unnamedDb.openCursor(txn)) {
       if (!cursor.first()) {
         return Collections.emptyList();
       }
@@ -204,7 +209,6 @@ public List<byte[]> getDbiNames() {
         result.add(name);
       } while (cursor.next());
     }
-
     return result;
   }
 
@@ -282,11 +286,49 @@ public DbiBuilder<T> buildDbi() {
     return new DbiBuilder<>(this, proxy, readOnly);
   }
 
+  /**
+   * Convenience method that opens a {@link Dbi} with a UTF-8 database name and default
+   * {@link Comparator} that is not invoked from native code.
+   * <p>
+   * For more options when opening a {@link Dbi} see {@link Env#buildDbi()}.
+   * </p>
+   * @param name       name of the database (or null if no name is required)
+   * @param dbiFlagSet Flags to open the database with
+   * @return a database that is ready to use
+   */
+  public Dbi<T> openDbi(final String name, final DbiFlagSet dbiFlagSet) {
+    final byte[] nameBytes = name == null ? null : name.getBytes(UTF_8);
+    try (Txn<T> txn = readOnly ? txnRead() : txnWrite()) {
+      final Dbi<T> dbi = new Dbi<>(this, txn, nameBytes, proxy, dbiFlagSet);
+      txn.commit(); // even RO Txns require a commit to retain Dbi in Env
+      return dbi;
+    }
+  }
+
+  /**
+   * Convenience method that opens a {@link Dbi} with a default
+   * {@link Comparator} that is not invoked from native code.
+   * <p>
+   * For more options when opening a {@link Dbi} see {@link Env#buildDbi()}.
+   * </p>
+   * @param name       name of the database (or null if no name is required)
+   * @param dbiFlagSet Flags to open the database with
+   * @return a database that is ready to use
+   */
+  public Dbi<T> openDbi(final byte[] name,
+                        final DbiFlagSet dbiFlagSet) {
+    try (Txn<T> txn = readOnly ? txnRead() : txnWrite()) {
+      final Dbi<T> dbi = new Dbi<>(this, txn, name, proxy, dbiFlagSet);
+      txn.commit(); // even RO Txns require a commit to retain Dbi in Env
+      return dbi;
+    }
+  }
+
   /**
    * @param name  name of the database (or null if no name is required)
    * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#buildDbi()}
+   * @deprecated Instead use {@link Env#buildDbi()} or {@link Env#openDbi(String, DbiFlagSet)}
    * Convenience method that opens a {@link Dbi} with a UTF-8 database name and default {@link
    * Comparator} that is not invoked from native code.
    */
@@ -315,7 +357,7 @@ public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
   public Dbi<T> openDbi(final String name,
                         final Comparator<T> comparator,
                         final DbiFlags... flags) {
-    final byte[] nameBytes = name == null ? null : name.getBytes(UTF_8);
+    final byte[] nameBytes = name == null ? null : name.getBytes(DEFAULT_NAME_CHARSET);
     return openDbi(nameBytes, comparator, false, flags);
   }
 
@@ -338,7 +380,7 @@ public Dbi<T> openDbi(final String name,
                         final Comparator<T> comparator,
                         final boolean nativeCb,
                         final DbiFlags... flags) {
-    final byte[] nameBytes = name == null ? null : name.getBytes(UTF_8);
+    final byte[] nameBytes = name == null ? null : name.getBytes(DEFAULT_NAME_CHARSET);
     return openDbi(nameBytes, comparator, nativeCb, flags);
   }
 
@@ -354,7 +396,11 @@ public Dbi<T> openDbi(final String name,
   @Deprecated()
   public Dbi<T> openDbi(final byte[] name,
                         final DbiFlags... flags) {
-    return openDbi(name, null, false, flags);
+    return buildDbi()
+        .setDbName(name)
+        .withDefaultComparator()
+        .setDbiFlags(flags)
+        .open();
   }
 
   /**
@@ -371,7 +417,12 @@ public Dbi<T> openDbi(final byte[] name,
   public Dbi<T> openDbi(final byte[] name,
                         final Comparator<T> comparator,
                         final DbiFlags... flags) {
-    return openDbi(name, comparator, false, flags);
+    requireNonNull(comparator);
+    return buildDbi()
+        .setDbName(name)
+        .withIteratorComparator(ignored -> comparator)
+        .setDbiFlags(flags)
+        .open();
   }
 
   /**
@@ -435,10 +486,6 @@ public Dbi<T> openDbi(
       final Comparator<T> comparator,
       final boolean nativeCb,
       final DbiFlags... flags) {
-
-    if (nativeCb && comparator == null) {
-      throw new IllegalArgumentException("Is nativeCb is true, you must supply a comparator");
-    }
     return new Dbi<>(this, txn, name, comparator, nativeCb, proxy, DbiFlagSet.of(flags));
   }
 
@@ -724,6 +771,46 @@ public Builder<T> setMapSize(final long mapSize) {
       return this;
     }
 
+    /**
+     * Sets the map size in kibibytes
+     *
+     * @param mapSizeKb new limit in kibibytes
+     * @return the builder
+     */
+    public Builder<T> setMapSizeKb(final long mapSizeKb) {
+      return setMapSize(mapSizeKb * KIBIBYTES);
+    }
+
+    /**
+     * Sets the map size in mebibytes.
+     *
+     * @param mapSizeMb new limit in mebibytes.
+     * @return the builder
+     */
+    public Builder<T> setMapSizeMb(final long mapSizeMb) {
+      return setMapSize(mapSizeMb * MEBIBYTES);
+    }
+
+    /**
+     * Sets the map size in gibibytes
+     *
+     * @param mapSizeGb new limit in gibibytes
+     * @return the builder
+     */
+    public Builder<T> setMapSizeGb(final long mapSizeGb) {
+      return setMapSize(mapSizeGb * GIBIBYTES);
+    }
+
+    /**
+     * Sets the map size in tebibytes.
+     *
+     * @param mapSizeTb new limit in tebibytes.
+     * @return the builder
+     */
+    public Builder<T> setMapSizeTb(final long mapSizeTb) {
+      return setMapSize(mapSizeTb * TEBIBYTES);
+    }
+
     /**
      * Sets the maximum number of databases (ie {@link Dbi}s permitted.
      *
diff --git a/src/main/java/org/lmdbjava/FlagSet.java b/src/main/java/org/lmdbjava/FlagSet.java
index 27513fcd..a9cffd47 100644
--- a/src/main/java/org/lmdbjava/FlagSet.java
+++ b/src/main/java/org/lmdbjava/FlagSet.java
@@ -88,6 +88,7 @@ default boolean isEmpty() {
   /**
    * @return The {@link Iterator} (in no particular order) for the flags in this {@link FlagSet}.
    */
+  @Override
   default Iterator<T> iterator() {
     return getFlags().iterator();
   }
diff --git a/src/main/java/org/lmdbjava/Verifier.java b/src/main/java/org/lmdbjava/Verifier.java
index ff9b28f8..cbe99b81 100644
--- a/src/main/java/org/lmdbjava/Verifier.java
+++ b/src/main/java/org/lmdbjava/Verifier.java
@@ -175,7 +175,7 @@ private void createDbis() {
 
   private void deleteDbis() {
     for (final byte[] existingDbiName : env.getDbiNames()) {
-      final Dbi<ByteBuffer> existingDbi = env.openDbi(existingDbiName);
+      final Dbi<ByteBuffer> existingDbi = env.openDbi(existingDbiName, DbiFlagSet.EMPTY);
       try (Txn<ByteBuffer> txn = env.txnWrite()) {
         existingDbi.drop(txn, true);
         txn.commit();
diff --git a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
index dc034f7f..e035911b 100644
--- a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
+++ b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
@@ -155,29 +155,32 @@ void unsafeIsDefault() {
    */
   @Test
   public void comparatorPerformance() {
-    final Random random = new Random();
+    final Random random = new Random(345098);
     final ByteBuffer buffer1 = ByteBuffer.allocateDirect(Long.BYTES);
     final ByteBuffer buffer2 = ByteBuffer.allocateDirect(Long.BYTES);
     buffer1.limit(Long.BYTES);
     buffer2.limit(Long.BYTES);
-    final long[] values = random.longs(5_000_000).toArray();
+    final long[] values = random.longs(20_000_000).toArray();
 
     Instant time = Instant.now();
+    // x is to ensure result is used by the jvm
     int x = 0;
     for (int rounds = 0; rounds < 100; rounds++) {
       for (int i = 1; i < values.length; i++) {
-        buffer1.order(ByteOrder.nativeOrder())
+//        buffer1.order(ByteOrder.nativeOrder())
+        buffer1
             .putLong(0, values[i - 1]);
-        buffer2.order(ByteOrder.nativeOrder())
+//        buffer2.order(ByteOrder.nativeOrder())
+        buffer2
             .putLong(0, values[i]);
         final int result = ByteBufferProxy.AbstractByteBufferProxy.compareAsIntegerKeys(buffer1, buffer2);
         x += result;
       }
     }
-    System.out.println("compareAsIntegerKeys: " + Duration.between(time, Instant.now()));
+    System.out.println("compareAsIntegerKeys: " + Duration.between(time, Instant.now()) + ", x: " + x);
 
     time = Instant.now();
-    x = 0;
+    int y = 0;
     for (int rounds = 0; rounds < 100; rounds++) {
       for (int i = 1; i < values.length; i++) {
         buffer1.order(BIG_ENDIAN)
@@ -185,10 +188,12 @@ public void comparatorPerformance() {
         buffer2.order(BIG_ENDIAN)
             .putLong(0, values[i]);
         final int result = ByteBufferProxy.AbstractByteBufferProxy.compareLexicographically(buffer1, buffer2);
-        x += result;
+        y += result;
       }
     }
-    System.out.println("compareLexicographically: " + Duration.between(time, Instant.now()));
+    System.out.println("compareLexicographically: " + Duration.between(time, Instant.now()) + ", y: " + y);
+
+    assertThat(y).isEqualTo(x);
   }
 
   @Test
diff --git a/src/test/java/org/lmdbjava/CursorParamTest.java b/src/test/java/org/lmdbjava/CursorParamTest.java
index 1a3604be..5b701382 100644
--- a/src/test/java/org/lmdbjava/CursorParamTest.java
+++ b/src/test/java/org/lmdbjava/CursorParamTest.java
@@ -88,7 +88,7 @@ protected AbstractBufferRunner(final BufferProxy<T> proxy) {
     public final void execute(final Path tmp) {
       try (Env<T> env = env(tmp)) {
         assertThat(env.getDbiNames()).isEmpty();
-        final Dbi<T> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+        final Dbi<T> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
         assertThat(env.getDbiNames().get(0)).isEqualTo(DB_1.getBytes(UTF_8));
         try (Txn<T> txn = env.txnWrite();
             Cursor<T> c = db.openCursor(txn)) {
diff --git a/src/test/java/org/lmdbjava/CursorTest.java b/src/test/java/org/lmdbjava/CursorTest.java
index a0c78855..41893ae6 100644
--- a/src/test/java/org/lmdbjava/CursorTest.java
+++ b/src/test/java/org/lmdbjava/CursorTest.java
@@ -175,7 +175,7 @@ void closedEnvRejectsDeleteCall() {
 
   @Test
   void count() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
     try (Txn<ByteBuffer> txn = env.txnWrite();
         Cursor<ByteBuffer> c = db.openCursor(txn)) {
       c.put(bb(1), bb(2), MDB_APPENDDUP);
@@ -193,7 +193,7 @@ void count() {
   void cursorCannotCloseIfTransactionCommitted() {
     assertThatThrownBy(
             () -> {
-              final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+              final Dbi<ByteBuffer> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
               try (Txn<ByteBuffer> txn = env.txnWrite()) {
                 try (Cursor<ByteBuffer> c = db.openCursor(txn); ) {
                   c.put(bb(1), bb(2), MDB_APPENDDUP);
@@ -238,7 +238,7 @@ void cursorFirstLastNextPrev() {
 
   @Test
   void delete() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
     try (Txn<ByteBuffer> txn = env.txnWrite();
         Cursor<ByteBuffer> c = db.openCursor(txn)) {
       c.put(bb(1), bb(2), MDB_NOOVERWRITE);
@@ -257,7 +257,7 @@ void delete() {
 
   @Test
   void getKeyVal() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
     try (Txn<ByteBuffer> txn = env.txnWrite();
         Cursor<ByteBuffer> c = db.openCursor(txn)) {
       c.put(bb(1), bb(2), MDB_APPENDDUP);
@@ -278,7 +278,7 @@ void getKeyVal() {
 
   @Test
   void putMultiple() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT, MDB_DUPFIXED);
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT, MDB_DUPFIXED));
     final int elemCount = 20;
 
     final ByteBuffer values = allocateDirect(Integer.BYTES * elemCount);
@@ -300,7 +300,7 @@ void putMultiple() {
   void putMultipleWithoutMdbMultipleFlag() {
     assertThatThrownBy(
             () -> {
-              final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+              final Dbi<ByteBuffer> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
               try (Txn<ByteBuffer> txn = env.txnWrite();
                   Cursor<ByteBuffer> c = db.openCursor(txn)) {
                 c.putMultiple(bb(100), bb(1), 1);
@@ -345,7 +345,7 @@ void renewTxRw() {
 
   @Test
   void repeatedCloseCausesNotError() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       final Cursor<ByteBuffer> c = db.openCursor(txn);
       c.close();
@@ -375,7 +375,7 @@ void reserve() {
 
   @Test
   void returnValueForNoDupData() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
     try (Txn<ByteBuffer> txn = env.txnWrite();
         Cursor<ByteBuffer> c = db.openCursor(txn)) {
       // ok
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 7302018c..3e876f67 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -264,7 +264,7 @@ void drop() {
   @Test
   void dropAndDelete() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
-    final Dbi<ByteBuffer> nameDb = env.openDbi((byte[]) null);
+    final Dbi<ByteBuffer> nameDb = env.openDbi((byte[]) null, DbiFlagSet.EMPTY);
     final byte[] dbNameBytes = DB_1.getBytes(UTF_8);
     final ByteBuffer dbNameBuffer = allocateDirect(dbNameBytes.length);
     dbNameBuffer.put(dbNameBytes).flip();
@@ -321,7 +321,7 @@ void getNamesWhenEmpty() {
 
   @Test
   void listsFlags() {
-    final Dbi<ByteBuffer> dbi = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT, MDB_REVERSEKEY);
+    final Dbi<ByteBuffer> dbi = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT, MDB_REVERSEKEY));
 
     try (Txn<ByteBuffer> txn = env.txnRead()) {
       final List<DbiFlags> flags = dbi.listFlags(txn);
@@ -415,7 +415,7 @@ void putDelete() {
 
   @Test
   void putDuplicateDelete() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
 
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       db.put(txn, bb(5), bb(5));
@@ -474,7 +474,7 @@ void putZeroByteValueForNonMdbDupSortDatabase() {
 
   @Test
   void returnValueForNoDupData() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       // ok
       assertThat(db.put(txn, bb(5), bb(6), MDB_NODUPDATA)).isTrue();
diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index 87edd049..eb925b42 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -24,8 +24,6 @@
 import static org.lmdbjava.CopyFlags.MDB_CP_COMPACT;
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
 import static org.lmdbjava.Env.Builder.MAX_READERS_DEFAULT;
-import static org.lmdbjava.Env.create;
-import static org.lmdbjava.Env.open;
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
 import static org.lmdbjava.EnvFlags.MDB_RDONLY_ENV;
 import static org.lmdbjava.TestUtils.DB_1;
@@ -45,7 +43,9 @@
 import org.lmdbjava.Env.MapFullException;
 import org.lmdbjava.Txn.BadReaderLockException;
 
-/** Test {@link Env}. */
+/**
+ * Test {@link Env}.
+ */
 public final class EnvTest {
 
   @Test
@@ -53,10 +53,10 @@ void byteUnit() {
     FileUtil.useTempFile(
         file -> {
           try (Env<ByteBuffer> env =
-              create()
-                  .setMaxReaders(1)
-                  .setMapSize(MEBIBYTES.toBytes(1))
-                  .open(file.toFile(), MDB_NOSUBDIR)) {
+                   Env.create()
+                       .setMaxReaders(1)
+                       .setMapSize(MEBIBYTES.toBytes(1))
+                       .open(file.toFile(), MDB_NOSUBDIR)) {
             final EnvInfo info = env.info();
             assertThat(info.mapSize).isEqualTo(MEBIBYTES.toBytes(1));
           }
@@ -66,116 +66,116 @@ void byteUnit() {
   @Test
   void cannotChangeMapSizeAfterOpen() {
     assertThatThrownBy(
-            () -> {
-              FileUtil.useTempFile(
-                  file -> {
-                    final Builder<ByteBuffer> builder = create().setMaxReaders(1);
-                    try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
-                      builder.setMapSize(1);
-                    }
-                  });
-            })
+        () -> {
+          FileUtil.useTempFile(
+              file -> {
+                final Builder<ByteBuffer> builder = Env.create().setMaxReaders(1);
+                try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
+                  builder.setMapSize(1);
+                }
+              });
+        })
         .isInstanceOf(AlreadyOpenException.class);
   }
 
   @Test
   void cannotChangeMaxDbsAfterOpen() {
     assertThatThrownBy(
-            () -> {
-              FileUtil.useTempFile(
-                  file -> {
-                    final Builder<ByteBuffer> builder = create().setMaxReaders(1);
-                    try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
-                      builder.setMaxDbs(1);
-                    }
-                  });
-            })
+        () -> {
+          FileUtil.useTempFile(
+              file -> {
+                final Builder<ByteBuffer> builder = Env.create().setMaxReaders(1);
+                try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
+                  builder.setMaxDbs(1);
+                }
+              });
+        })
         .isInstanceOf(AlreadyOpenException.class);
   }
 
   @Test
   void cannotChangeMaxReadersAfterOpen() {
     assertThatThrownBy(
-            () -> {
-              FileUtil.useTempFile(
-                  file -> {
-                    final Builder<ByteBuffer> builder = create().setMaxReaders(1);
-                    try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
-                      builder.setMaxReaders(1);
-                    }
-                  });
-            })
+        () -> {
+          FileUtil.useTempFile(
+              file -> {
+                final Builder<ByteBuffer> builder = Env.create().setMaxReaders(1);
+                try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
+                  builder.setMaxReaders(1);
+                }
+              });
+        })
         .isInstanceOf(AlreadyOpenException.class);
   }
 
   @Test
   void cannotInfoOnceClosed() {
     assertThatThrownBy(
-            () -> {
-              FileUtil.useTempFile(
-                  file -> {
-                    final Env<ByteBuffer> env =
-                        create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
-                    env.close();
-                    env.info();
-                  });
-            })
+        () -> {
+          FileUtil.useTempFile(
+              file -> {
+                final Env<ByteBuffer> env =
+                    Env.create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
+                env.close();
+                env.info();
+              });
+        })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void cannotOpenTwice() {
     assertThatThrownBy(
-            () -> {
-              FileUtil.useTempFile(
-                  file -> {
-                    final Builder<ByteBuffer> builder = create().setMaxReaders(1);
-                    builder.open(file.toFile(), MDB_NOSUBDIR).close();
-                    builder.open(file.toFile(), MDB_NOSUBDIR);
-                  });
-            })
+        () -> {
+          FileUtil.useTempFile(
+              file -> {
+                final Builder<ByteBuffer> builder = Env.create().setMaxReaders(1);
+                builder.open(file.toFile(), MDB_NOSUBDIR).close();
+                builder.open(file.toFile(), MDB_NOSUBDIR);
+              });
+        })
         .isInstanceOf(AlreadyOpenException.class);
   }
 
   @Test
   void cannotOverflowMapSize() {
     assertThatThrownBy(
-            () -> {
-              final Builder<ByteBuffer> builder = create().setMaxReaders(1);
-              final int mb = 1_024 * 1_024;
-              final int size = mb * 2_048; // as per issue 18
-              builder.setMapSize(size);
-            })
+        () -> {
+          final Builder<ByteBuffer> builder = Env.create().setMaxReaders(1);
+          final int mb = 1_024 * 1_024;
+          final int size = mb * 2_048; // as per issue 18
+          builder.setMapSize(size);
+        })
         .isInstanceOf(IllegalArgumentException.class);
   }
 
   @Test
   void cannotStatOnceClosed() {
     assertThatThrownBy(
-            () -> {
-              FileUtil.useTempFile(
-                  file -> {
-                    final Env<ByteBuffer> env =
-                        create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
-                    env.close();
-                    env.stat();
-                  });
-            })
+        () -> {
+          FileUtil.useTempFile(
+              file -> {
+                final Env<ByteBuffer> env =
+                    Env.create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
+                env.close();
+                env.stat();
+              });
+        })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void cannotSyncOnceClosed() {
     assertThatThrownBy(
-            () -> {
-              FileUtil.useTempFile(
-                  file -> {
-                    final Env<ByteBuffer> env =
-                        create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
-                    env.close();
-                    env.sync(false);
-                  });
-            })
+        () -> {
+          FileUtil.useTempFile(
+              file -> {
+                final Env<ByteBuffer> env =
+                    Env.create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
+                env.close();
+                env.sync(false);
+              });
+        })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
@@ -188,7 +188,7 @@ void copyDirectoryBased() {
           assertThat(FileUtil.count(dest)).isEqualTo(0);
           FileUtil.useTempDir(
               src -> {
-                try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src.toFile())) {
+                try (Env<ByteBuffer> env = Env.create().setMaxReaders(1).open(src.toFile())) {
                   env.copy(dest.toFile(), MDB_CP_COMPACT);
                   assertThat(FileUtil.count(dest)).isEqualTo(1);
                 }
@@ -199,66 +199,66 @@ void copyDirectoryBased() {
   @Test
   void copyDirectoryRejectsFileDestination() {
     assertThatThrownBy(
-            () -> {
-              FileUtil.useTempDir(
-                  dest -> {
-                    FileUtil.deleteDir(dest);
-                    FileUtil.useTempDir(
-                        src -> {
-                          try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src.toFile())) {
-                            env.copy(dest.toFile(), MDB_CP_COMPACT);
-                          }
-                        });
-                  });
-            })
+        () -> {
+          FileUtil.useTempDir(
+              dest -> {
+                FileUtil.deleteDir(dest);
+                FileUtil.useTempDir(
+                    src -> {
+                      try (Env<ByteBuffer> env = Env.create().setMaxReaders(1).open(src.toFile())) {
+                        env.copy(dest.toFile(), MDB_CP_COMPACT);
+                      }
+                    });
+              });
+        })
         .isInstanceOf(InvalidCopyDestination.class);
   }
 
   @Test
   void copyDirectoryRejectsMissingDestination() {
     assertThatThrownBy(
-            () -> {
-              FileUtil.useTempDir(
-                  dest -> {
-                    try {
-                      Files.delete(dest);
-                      FileUtil.useTempDir(
-                          src -> {
-                            try (Env<ByteBuffer> env =
-                                create().setMaxReaders(1).open(src.toFile())) {
-                              env.copy(dest.toFile(), MDB_CP_COMPACT);
-                            }
-                          });
-                    } catch (final IOException e) {
-                      throw new UncheckedIOException(e);
-                    }
-                  });
-            })
+        () -> {
+          FileUtil.useTempDir(
+              dest -> {
+                try {
+                  Files.delete(dest);
+                  FileUtil.useTempDir(
+                      src -> {
+                        try (Env<ByteBuffer> env =
+                                 Env.create().setMaxReaders(1).open(src.toFile())) {
+                          env.copy(dest.toFile(), MDB_CP_COMPACT);
+                        }
+                      });
+                } catch (final IOException e) {
+                  throw new UncheckedIOException(e);
+                }
+              });
+        })
         .isInstanceOf(InvalidCopyDestination.class);
   }
 
   @Test
   void copyDirectoryRejectsNonEmptyDestination() {
     assertThatThrownBy(
-            () -> {
-              FileUtil.useTempDir(
-                  dest -> {
-                    try {
-                      final Path subDir = dest.resolve("hello");
-                      Files.createDirectory(subDir);
-                      assertThat(Files.isDirectory(subDir)).isTrue();
-                      FileUtil.useTempDir(
-                          src -> {
-                            try (Env<ByteBuffer> env =
-                                create().setMaxReaders(1).open(src.toFile())) {
-                              env.copy(dest.toFile(), MDB_CP_COMPACT);
-                            }
-                          });
-                    } catch (final IOException e) {
-                      throw new UncheckedIOException(e);
-                    }
-                  });
-            })
+        () -> {
+          FileUtil.useTempDir(
+              dest -> {
+                try {
+                  final Path subDir = dest.resolve("hello");
+                  Files.createDirectory(subDir);
+                  assertThat(Files.isDirectory(subDir)).isTrue();
+                  FileUtil.useTempDir(
+                      src -> {
+                        try (Env<ByteBuffer> env =
+                                 Env.create().setMaxReaders(1).open(src.toFile())) {
+                          env.copy(dest.toFile(), MDB_CP_COMPACT);
+                        }
+                      });
+                } catch (final IOException e) {
+                  throw new UncheckedIOException(e);
+                }
+              });
+        })
         .isInstanceOf(InvalidCopyDestination.class);
   }
 
@@ -271,7 +271,7 @@ void copyFileBased() {
           FileUtil.useTempFile(
               src -> {
                 try (Env<ByteBuffer> env =
-                    create().setMaxReaders(1).open(src.toFile(), MDB_NOSUBDIR)) {
+                         Env.create().setMaxReaders(1).open(src.toFile(), MDB_NOSUBDIR)) {
                   env.copy(dest.toFile(), MDB_CP_COMPACT);
                 }
                 assertThat(FileUtil.size(dest)).isGreaterThan(0L);
@@ -282,19 +282,19 @@ void copyFileBased() {
   @Test
   void copyFileRejectsExistingDestination() {
     assertThatThrownBy(
-            () -> {
-              FileUtil.useTempFile(
-                  dest -> {
-                    assertThat(Files.exists(dest)).isTrue();
-                    FileUtil.useTempFile(
-                        src -> {
-                          try (Env<ByteBuffer> env =
-                              create().setMaxReaders(1).open(src.toFile(), MDB_NOSUBDIR)) {
-                            env.copy(dest.toFile(), MDB_CP_COMPACT);
-                          }
-                        });
-                  });
-            })
+        () -> {
+          FileUtil.useTempFile(
+              dest -> {
+                assertThat(Files.exists(dest)).isTrue();
+                FileUtil.useTempFile(
+                    src -> {
+                      try (Env<ByteBuffer> env =
+                               Env.create().setMaxReaders(1).open(src.toFile(), MDB_NOSUBDIR)) {
+                        env.copy(dest.toFile(), MDB_CP_COMPACT);
+                      }
+                    });
+              });
+        })
         .isInstanceOf(InvalidCopyDestination.class);
   }
 
@@ -302,7 +302,7 @@ void copyFileRejectsExistingDestination() {
   void createAsDirectory() {
     FileUtil.useTempDir(
         dest -> {
-          final Env<ByteBuffer> env = create().setMaxReaders(1).open(dest.toFile());
+          final Env<ByteBuffer> env = Env.create().setMaxReaders(1).open(dest.toFile());
           assertThat(Files.isDirectory(dest)).isTrue();
           env.sync(false);
           env.close();
@@ -316,11 +316,11 @@ void createAsFile() {
     FileUtil.useTempFile(
         file -> {
           try (Env<ByteBuffer> env =
-              create()
-                  .setMapSize(MEBIBYTES.toBytes(1))
-                  .setMaxDbs(1)
-                  .setMaxReaders(1)
-                  .open(file.toFile(), MDB_NOSUBDIR)) {
+                   Env.create()
+                       .setMapSize(MEBIBYTES.toBytes(1))
+                       .setMaxDbs(1)
+                       .setMaxReaders(1)
+                       .open(file.toFile(), MDB_NOSUBDIR)) {
             env.sync(true);
             assertThat(Files.isRegularFile(file)).isTrue();
           }
@@ -330,16 +330,16 @@ void createAsFile() {
   @Test
   void detectTransactionThreadViolation() {
     assertThatThrownBy(
-            () -> {
-              FileUtil.useTempFile(
-                  file -> {
-                    try (Env<ByteBuffer> env =
-                        create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR)) {
-                      env.txnRead();
-                      env.txnRead();
-                    }
-                  });
-            })
+        () -> {
+          FileUtil.useTempFile(
+              file -> {
+                try (Env<ByteBuffer> env =
+                         Env.create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR)) {
+                  env.txnRead();
+                  env.txnRead();
+                }
+              });
+        })
         .isInstanceOf(BadReaderLockException.class);
   }
 
@@ -348,7 +348,7 @@ void info() {
     FileUtil.useTempFile(
         file -> {
           try (Env<ByteBuffer> env =
-              create().setMaxReaders(4).setMapSize(123_456).open(file.toFile(), MDB_NOSUBDIR)) {
+                   Env.create().setMaxReaders(4).setMapSize(123_456).open(file.toFile(), MDB_NOSUBDIR)) {
             final EnvInfo info = env.info();
             assertThat(info).isNotNull();
             assertThat(info.lastPageNumber).isEqualTo(1L);
@@ -366,30 +366,30 @@ void info() {
   @Test
   void mapFull() {
     assertThatThrownBy(
-            () -> {
-              FileUtil.useTempDir(
-                  dir -> {
-                    final byte[] k = new byte[500];
-                    final ByteBuffer key = allocateDirect(500);
-                    final ByteBuffer val = allocateDirect(1_024);
-                    final Random rnd = new Random();
-                    try (Env<ByteBuffer> env =
-                        create()
-                            .setMaxReaders(1)
-                            .setMapSize(MEBIBYTES.toBytes(8))
-                            .setMaxDbs(1)
-                            .open(dir.toFile())) {
-                      final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
-                      for (; ; ) {
-                        rnd.nextBytes(k);
-                        key.clear();
-                        key.put(k).flip();
-                        val.clear();
-                        db.put(key, val);
-                      }
-                    }
-                  });
-            })
+        () -> {
+          FileUtil.useTempDir(
+              dir -> {
+                final byte[] k = new byte[500];
+                final ByteBuffer key = allocateDirect(500);
+                final ByteBuffer val = allocateDirect(1_024);
+                final Random rnd = new Random();
+                try (Env<ByteBuffer> env =
+                         Env.create()
+                             .setMaxReaders(1)
+                             .setMapSize(MEBIBYTES.toBytes(8))
+                             .setMaxDbs(1)
+                             .open(dir.toFile())) {
+                  final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+                  for (; ; ) {
+                    rnd.nextBytes(k);
+                    key.clear();
+                    key.put(k).flip();
+                    val.clear();
+                    db.put(key, val);
+                  }
+                }
+              });
+        })
         .isInstanceOf(MapFullException.class);
   }
 
@@ -397,13 +397,17 @@ void mapFull() {
   void readOnlySupported() {
     FileUtil.useTempDir(
         dir -> {
-          try (Env<ByteBuffer> rwEnv = create().setMaxReaders(1).open(dir.toFile())) {
+          try (Env<ByteBuffer> rwEnv = Env.create()
+              .setMaxReaders(1)
+              .open(dir)) {
             final Dbi<ByteBuffer> rwDb = rwEnv.openDbi(DB_1, MDB_CREATE);
             rwDb.put(bb(1), bb(42));
           }
-          try (Env<ByteBuffer> roEnv =
-              create().setMaxReaders(1).open(dir.toFile(), MDB_RDONLY_ENV)) {
-            final Dbi<ByteBuffer> roDb = roEnv.openDbi(DB_1);
+          try (Env<ByteBuffer> roEnv = Env.create()
+              .setMaxReaders(1)
+              .setEnvFlags(MDB_RDONLY_ENV)
+              .open(dir)) {
+            final Dbi<ByteBuffer> roDb = roEnv.openDbi(DB_1, DbiFlagSet.EMPTY);
             try (Txn<ByteBuffer> roTxn = roEnv.txnRead()) {
               assertThat(roDb.get(roTxn, bb(1))).isNotNull();
             }
@@ -420,11 +424,11 @@ void setMapSize() {
           final ByteBuffer val = allocateDirect(1_024);
           final Random rnd = new Random();
           try (Env<ByteBuffer> env =
-              create()
-                  .setMaxReaders(1)
-                  .setMapSize(KIBIBYTES.toBytes(256))
-                  .setMaxDbs(1)
-                  .open(dir.toFile())) {
+                   Env.create()
+                       .setMaxReaders(1)
+                       .setMapSize(KIBIBYTES.toBytes(256))
+                       .setMaxDbs(1)
+                       .open(dir)) {
             final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
 
             db.put(bb(1), bb(42));
@@ -471,7 +475,10 @@ void setMapSize() {
   void stats() {
     FileUtil.useTempFile(
         file -> {
-          try (Env<ByteBuffer> env = create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR)) {
+          try (Env<ByteBuffer> env = Env.create()
+              .setMaxReaders(1)
+              .setEnvFlags(MDB_NOSUBDIR)
+              .open(file)) {
             final Stat stat = env.stat();
             assertThat(stat).isNotNull();
             assertThat(stat.branchPages).isEqualTo(0L);
@@ -489,7 +496,7 @@ void stats() {
   void testDefaultOpen() {
     FileUtil.useTempDir(
         dir -> {
-          try (Env<ByteBuffer> env = open(dir.toFile(), 10)) {
+          try (Env<ByteBuffer> env = Env.create().setMapSizeMb(10).open(dir)) {
             final EnvInfo info = env.info();
             assertThat(info.maxReaders).isEqualTo(MAX_READERS_DEFAULT);
             final Dbi<ByteBuffer> db = env.openDbi("test", MDB_CREATE);
diff --git a/src/test/java/org/lmdbjava/TutorialTest.java b/src/test/java/org/lmdbjava/TutorialTest.java
index 1b42b327..35e2c169 100644
--- a/src/test/java/org/lmdbjava/TutorialTest.java
+++ b/src/test/java/org/lmdbjava/TutorialTest.java
@@ -345,7 +345,7 @@ void tutorial5() {
 
           // This time we're going to tell the Dbi it can store > 1 value per key.
           // There are other flags available if we're storing integers etc.
-          final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE, MDB_DUPSORT);
+          final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
 
           // Duplicate support requires both keys and values to be <= max key size.
           final ByteBuffer key = allocateDirect(env.getMaxKeySize());

From 77a3494a4008a516b2d1c3fe517b3171b638fac3 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Wed, 5 Nov 2025 21:35:51 +0000
Subject: [PATCH 259/322] Fix failing test

---
 src/main/java/org/lmdbjava/Cursor.java        |  2 --
 src/main/java/org/lmdbjava/Dbi.java           | 28 +++++++++----------
 src/main/java/org/lmdbjava/DbiBuilder.java    |  5 ++--
 .../CursorIterableIntegerKeyTest.java         | 20 ++++++-------
 4 files changed, 25 insertions(+), 30 deletions(-)

diff --git a/src/main/java/org/lmdbjava/Cursor.java b/src/main/java/org/lmdbjava/Cursor.java
index 127fffc0..245a5a9a 100644
--- a/src/main/java/org/lmdbjava/Cursor.java
+++ b/src/main/java/org/lmdbjava/Cursor.java
@@ -110,8 +110,6 @@ public void delete(final PutFlags... flags) {
   }
 
   /**
-   * @deprecated Instead use {@link Cursor#delete(PutFlagSet)}.
-   * <hr>
    * Delete current key/data pair.
    *
    * <p>This function deletes the key/data pair to which the cursor refers.
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index 7347605f..65527224 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -49,6 +49,8 @@
  */
 public final class Dbi<T> {
 
+  @SuppressWarnings("FieldCanBeLocal") // Needs to be instance variable for FFI
+  private final ComparatorCallback callbackComparator;
   private boolean cleaned;
   // Used for CursorIterable KeyRange testing and/or native callbacks
   private final Comparator<T> comparator;
@@ -90,26 +92,24 @@ public final class Dbi<T> {
     final Pointer dbiPtr = allocateDirect(RUNTIME, ADDRESS);
     checkRc(LIB.mdb_dbi_open(txn.pointer(), name, this.dbiFlagSet.getMask(), dbiPtr));
     ptr = dbiPtr.getPointer(0);
-    ComparatorCallback callbackComparator;
     if (nativeCb) {
       // LMDB will call back to this comparator for insertion/iteration order
-      callbackComparator = createCallbackComparator(proxy);
+      this.callbackComparator = createCallbackComparator(proxy);
       LIB.mdb_set_compare(txn.pointer(), ptr, callbackComparator);
+    } else {
+      callbackComparator = null;
     }
   }
 
-  private ComparatorCallback createCallbackComparator(BufferProxy<T> proxy) {
-    ComparatorCallback callbackComparator;
-    callbackComparator =
-        (keyA, keyB) -> {
-          final T compKeyA = proxy.out(proxy.allocate(), keyA);
-          final T compKeyB = proxy.out(proxy.allocate(), keyB);
-          final int result = this.comparator.compare(compKeyA, compKeyB);
-          proxy.deallocate(compKeyA);
-          proxy.deallocate(compKeyB);
-          return result;
-        };
-    return callbackComparator;
+  private ComparatorCallback createCallbackComparator(final BufferProxy<T> proxy) {
+    return (keyA, keyB) -> {
+      final T compKeyA = proxy.out(proxy.allocate(), keyA);
+      final T compKeyB = proxy.out(proxy.allocate(), keyB);
+      final int result = this.comparator.compare(compKeyA, compKeyB);
+      proxy.deallocate(compKeyA);
+      proxy.deallocate(compKeyB);
+      return result;
+    };
   }
 
   Pointer pointer() {
diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
index 062e77f4..1abff0a2 100644
--- a/src/main/java/org/lmdbjava/DbiBuilder.java
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -420,9 +420,8 @@ private Comparator<T> getComparator(final DbiBuilder<T> dbiBuilder,
           break;
         case CALLBACK:
         case ITERATOR:
-          comparator = Objects.requireNonNull(
-              dbiBuilderStage2.comparatorFactory.create(dbiFlagSet),
-              () -> "comparatorFactory returned null");
+          comparator = dbiBuilderStage2.comparatorFactory.create(dbiFlagSet);
+          Objects.requireNonNull(comparator, "comparatorFactory returned null");
           break;
         case NATIVE:
           break;
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
index a0d9ab0c..87f7a952 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
@@ -234,18 +234,16 @@ public void testIntegerKeyKeySize() {
       db.put(txn, bbNative(Long.MAX_VALUE), bb("val_" + ++val));
       txn.commit();
     }
-
-    try (Txn<ByteBuffer> txn = env.txnRead()) {
-      try (CursorIterable<ByteBuffer> iterable = db.iterate(txn)) {
-        for (KeyVal<ByteBuffer> keyVal : iterable) {
-          final String val = getString(keyVal.val());
-          final long key = getNativeLong(keyVal.key());
-          final int remaining = keyVal.key().remaining();
+//    try (Txn<ByteBuffer> txn = env.txnRead()) {
+//      try (CursorIterable<ByteBuffer> iterable = db.iterate(txn)) {
+//        for (KeyVal<ByteBuffer> keyVal : iterable) {
+//          final String val = getString(keyVal.val());
+//          final long key = getNativeLong(keyVal.key());
+//          final int remaining = keyVal.key().remaining();
 //          System.out.println("key: " + key + ", val: " + val + ", remaining: " + remaining);
-        }
-      }
-    }
-
+//        }
+//      }
+//    }
   }
 
   @Test

From 1d46e0b09251767be3f730a37c981535d1a11d5d Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Thu, 6 Nov 2025 10:24:19 +0000
Subject: [PATCH 260/322] Refactor deprecated method calls

---
 src/main/java/org/lmdbjava/Env.java           |   8 +-
 .../org/lmdbjava/ByteBufferProxyTest.java     |  64 +++--
 .../CursorIterableIntegerDupTest.java         |  42 +--
 .../CursorIterableIntegerKeyTest.java         |   6 +-
 .../org/lmdbjava/CursorIterablePerfTest.java  |  27 +-
 .../java/org/lmdbjava/CursorParamTest.java    |   4 +-
 src/test/java/org/lmdbjava/CursorTest.java    |   4 +-
 src/test/java/org/lmdbjava/DbiTest.java       | 244 +++++++++---------
 src/test/java/org/lmdbjava/EnvTest.java       |  83 ++++--
 .../org/lmdbjava/GarbageCollectionTest.java   |   6 +-
 src/test/java/org/lmdbjava/TutorialTest.java  |  82 +++---
 src/test/java/org/lmdbjava/TxnTest.java       |  10 +-
 12 files changed, 308 insertions(+), 272 deletions(-)

diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index e01de06b..7ccebb4e 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -63,10 +63,10 @@ public final class Env<T> implements AutoCloseable {
    */
   public static final boolean SHOULD_CHECK = !getBoolean(DISABLE_CHECKS_PROP);
 
-  private static final long KIBIBYTES = 1_024;
-  private static final long MEBIBYTES = KIBIBYTES * 1_024;
-  private static final long GIBIBYTES = MEBIBYTES * 1_024;
-  private static final long TEBIBYTES = GIBIBYTES * 1_024;
+  private static final long KIBIBYTES = 1_024L;
+  private static final long MEBIBYTES = KIBIBYTES * 1_024L;
+  private static final long GIBIBYTES = MEBIBYTES * 1_024L;
+  private static final long TEBIBYTES = GIBIBYTES * 1_024L;
 
   private boolean closed;
   private final int maxKeySize;
diff --git a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
index e035911b..a91fbf75 100644
--- a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
+++ b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
@@ -148,11 +148,6 @@ void unsafeIsDefault() {
     assertThat(v.getClass().getSimpleName()).startsWith("Unsafe");
   }
 
-  /**
-   * For 100 rounds of 5,000,000 comparisons
-   * compareAsIntegerKeys: PT1.600525631S
-   * compareLexicographically: PT3.381935001S
-   */
   @Test
   public void comparatorPerformance() {
     final Random random = new Random(345098);
@@ -160,40 +155,41 @@ public void comparatorPerformance() {
     final ByteBuffer buffer2 = ByteBuffer.allocateDirect(Long.BYTES);
     buffer1.limit(Long.BYTES);
     buffer2.limit(Long.BYTES);
-    final long[] values = random.longs(20_000_000).toArray();
+    final long[] values = random.longs(10_000_000).toArray();
+    final int rounds = 100;
 
-    Instant time = Instant.now();
-    // x is to ensure result is used by the jvm
-    int x = 0;
-    for (int rounds = 0; rounds < 100; rounds++) {
-      for (int i = 1; i < values.length; i++) {
-//        buffer1.order(ByteOrder.nativeOrder())
-        buffer1
-            .putLong(0, values[i - 1]);
-//        buffer2.order(ByteOrder.nativeOrder())
-        buffer2
-            .putLong(0, values[i]);
-        final int result = ByteBufferProxy.AbstractByteBufferProxy.compareAsIntegerKeys(buffer1, buffer2);
-        x += result;
+    for (int run = 0; run < 3; run++) {
+      Instant time = Instant.now();
+      // x is to ensure result is used by the jvm
+      int x = 0;
+      for (int round = 0; round < rounds; round++) {
+        for (int i = 1; i < values.length; i++) {
+          buffer1.order(ByteOrder.nativeOrder())
+              .putLong(0, values[i - 1]);
+          buffer2.order(ByteOrder.nativeOrder())
+              .putLong(0, values[i]);
+          final int result = ByteBufferProxy.AbstractByteBufferProxy.compareAsIntegerKeys(buffer1, buffer2);
+          x += result;
+        }
       }
-    }
-    System.out.println("compareAsIntegerKeys: " + Duration.between(time, Instant.now()) + ", x: " + x);
+      System.out.println("compareAsIntegerKeys: " + Duration.between(time, Instant.now()) + ", x: " + x);
 
-    time = Instant.now();
-    int y = 0;
-    for (int rounds = 0; rounds < 100; rounds++) {
-      for (int i = 1; i < values.length; i++) {
-        buffer1.order(BIG_ENDIAN)
-            .putLong(0, values[i - 1]);
-        buffer2.order(BIG_ENDIAN)
-            .putLong(0, values[i]);
-        final int result = ByteBufferProxy.AbstractByteBufferProxy.compareLexicographically(buffer1, buffer2);
-        y += result;
+      time = Instant.now();
+      int y = 0;
+      for (int round = 0; round < rounds; round++) {
+        for (int i = 1; i < values.length; i++) {
+          buffer1.order(BIG_ENDIAN)
+              .putLong(0, values[i - 1]);
+          buffer2.order(BIG_ENDIAN)
+              .putLong(0, values[i]);
+          final int result = ByteBufferProxy.AbstractByteBufferProxy.compareLexicographically(buffer1, buffer2);
+          y += result;
+        }
       }
-    }
-    System.out.println("compareLexicographically: " + Duration.between(time, Instant.now()) + ", y: " + y);
+      System.out.println("compareLexicographically: " + Duration.between(time, Instant.now()) + ", y: " + y);
 
-    assertThat(y).isEqualTo(x);
+      assertThat(y).isEqualTo(x);
+    }
   }
 
   @Test
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
index 775ac4bc..1098ca5c 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
@@ -44,7 +44,6 @@
 import static org.lmdbjava.TestUtils.DB_2;
 import static org.lmdbjava.TestUtils.DB_3;
 import static org.lmdbjava.TestUtils.DB_4;
-import static org.lmdbjava.TestUtils.POSIX_MODE;
 import static org.lmdbjava.TestUtils.bb;
 import static org.lmdbjava.TestUtils.bbNative;
 import static org.lmdbjava.TestUtils.getNativeInt;
@@ -63,7 +62,6 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
-import java.util.NoSuchElementException;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
@@ -87,7 +85,7 @@
  */
 @Disabled // Waiting for the merge of stroomdev66's cursor tests
 @ParameterizedClass(name = "{index}: dbi: {0}")
-@ArgumentsSource(CursorIterableTest.MyArgumentProvider.class)
+@ArgumentsSource(CursorIterableIntegerDupTest.MyArgumentProvider.class)
 public final class CursorIterableIntegerDupTest {
 
   private static final DbiFlagSet DBI_FLAGS = DbiFlagSet.of(
@@ -128,7 +126,8 @@ public void before() throws IOException {
             .setMapSize(KIBIBYTES.toBytes(256))
             .setMaxReaders(1)
             .setMaxDbs(3)
-            .open(file.toFile(), POSIX_MODE, MDB_NOSUBDIR);
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(file);
 
     populateExpectedEntriesDeque();
   }
@@ -187,16 +186,15 @@ private void populateDatabase(final Dbi<ByteBuffer> dbi) {
       }
       txn.commit();
     }
-
-    try (Txn<ByteBuffer> txn = env.txnRead();
-         CursorIterable<ByteBuffer> c = dbi.iterate(txn)) {
-
+//    try (Txn<ByteBuffer> txn = env.txnRead();
+//         CursorIterable<ByteBuffer> c = dbi.iterate(txn)) {
+//
 //      for (final KeyVal<ByteBuffer> kv : c) {
 //        System.out.print(getNativeInt(kv.key()) + " => " + kv.val().getInt());
 //        System.out.print(", ");
 //      }
 //      System.out.println();
-    }
+//    }
   }
 
   private int[] rangeInc(final int fromInc, final int toInc) {
@@ -278,6 +276,7 @@ public void iterate() {
 
       for (final KeyVal<ByteBuffer> kv : c) {
         final Map.Entry<Integer, Integer> entry = expectedEntriesDeque.pollFirst();
+        assertThat(entry).isNotNull();
 //        System.out.println(entry.getKey() + " => " + entry.getValue());
         assertThat(getNativeInt(kv.key())).isEqualTo(entry.getKey());
         assertThat(kv.val().getInt()).isEqualTo(entry.getValue());
@@ -308,24 +307,6 @@ public void lessThanTest() {
     verify(lessThan(bbNative(8)), 2, 4, 6);
   }
 
-  public void nextThrowsNoSuchElementExceptionIfNoMoreElements() {
-    Assertions.assertThatThrownBy(() -> {
-      populateExpectedEntriesDeque();
-      final Dbi<ByteBuffer> db = getDb();
-      try (Txn<ByteBuffer> txn = env.txnRead();
-           CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-        final Iterator<KeyVal<ByteBuffer>> i = c.iterator();
-        while (i.hasNext()) {
-          final KeyVal<ByteBuffer> kv = i.next();
-          assertThat(getNativeInt(kv.key())).isEqualTo(expectedEntriesDeque.pollFirst().getKey());
-          assertThat(kv.val().getInt()).isEqualTo(expectedEntriesDeque.pollFirst().getValue());
-        }
-        assertThat(i.hasNext()).isEqualTo(false);
-        i.next();
-      }
-    }).isInstanceOf(NoSuchElementException.class);
-  }
-
   @Test
   public void openBackwardTest() {
     verify(openBackward(bbNative(7), bbNative(2)), 6, 4);
@@ -355,7 +336,12 @@ public void openClosedBackwardTestWithGuava() {
           bb2.reset();
           return guava.compare(array1, array2);
         };
-    final Dbi<ByteBuffer> guavaDbi = env.openDbi(DB_1, comparator, MDB_CREATE);
+
+    final Dbi<ByteBuffer> guavaDbi = env.buildDbi()
+        .setDbName(DB_1).withIteratorComparator(ignored -> comparator)
+        .setDbiFlags(MDB_CREATE)
+        .open();
+
     populateDatabase(guavaDbi);
     verify(openClosedBackward(bbNative(7), bbNative(2)), guavaDbi, 6, 4, 2);
     verify(openClosedBackward(bbNative(8), bbNative(4)), guavaDbi, 6, 4);
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
index 87f7a952..007b5e29 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
@@ -432,7 +432,11 @@ public void openClosedBackwardTestWithGuava() {
           bb2.reset();
           return guava.compare(array1, array2);
         };
-    final Dbi<ByteBuffer> guavaDbi = env.openDbi(DB_1, comparator, MDB_CREATE);
+    final Dbi<ByteBuffer> guavaDbi = env.buildDbi()
+        .setDbName(DB_1)
+        .withIteratorComparator(ignored -> comparator)
+        .setDbiFlags(MDB_CREATE)
+        .open();
     populateDatabase(guavaDbi);
     verify(openClosedBackward(bbNative(7), bbNative(2)), guavaDbi, 6, 4, 2);
     verify(openClosedBackward(bbNative(8), bbNative(4)), guavaDbi, 6, 4);
diff --git a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
index e0a40fd9..80555966 100644
--- a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
@@ -21,7 +21,6 @@
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
 import static org.lmdbjava.PutFlags.MDB_APPEND;
 import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
-import static org.lmdbjava.TestUtils.POSIX_MODE;
 import static org.lmdbjava.TestUtils.bb;
 
 import java.io.IOException;
@@ -39,17 +38,12 @@
 
 public class CursorIterablePerfTest {
 
-  //    private static final int ITERATIONS = 5_000_000;
   private static final int ITERATIONS = 100_000;
-  //    private static final int ITERATIONS = 10;
 
-  private Path file;
-  private Dbi<ByteBuffer> dbJavaComparator;
-  private Dbi<ByteBuffer> dbLmdbComparator;
-  private Dbi<ByteBuffer> dbCallbackComparator;
-  private List<Dbi<ByteBuffer>> dbs = new ArrayList<>();
+  private final List<Dbi<ByteBuffer>> dbs = new ArrayList<>();
+  private final List<Integer> data = new ArrayList<>(ITERATIONS);
   private Env<ByteBuffer> env;
-  private List<Integer> data = new ArrayList<>(ITERATIONS);
+  private Path file;
 
   @BeforeEach
   public void before() throws IOException {
@@ -60,24 +54,25 @@ public void before() throws IOException {
             .setMapSize(GIBIBYTES.toBytes(1))
             .setMaxReaders(1)
             .setMaxDbs(3)
-            .open(file.toFile(), POSIX_MODE, MDB_NOSUBDIR);
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(file);
 
     final DbiFlagSet dbiFlagSet = MDB_CREATE;
     // Use a java comparator for start/stop keys only
-    dbJavaComparator = env.buildDbi()
+    Dbi<ByteBuffer> dbJavaComparator = env.buildDbi()
         .setDbName("JavaComparator")
         .withDefaultComparator()
         .setDbiFlags(dbiFlagSet)
         .open();
     // Use LMDB comparator for start/stop keys
-    dbLmdbComparator = env.buildDbi()
+    Dbi<ByteBuffer> dbLmdbComparator = env.buildDbi()
         .setDbName("LmdbComparator")
         .withNativeComparator()
         .setDbiFlags(dbiFlagSet)
         .open();
 
     // Use a java comparator for start/stop keys and as a callback comparator
-    dbCallbackComparator = env.buildDbi()
+    Dbi<ByteBuffer> dbCallbackComparator = env.buildDbi()
         .setDbName("CallBackComparator")
         .withCallbackComparator(bufferProxy::getComparator)
         .setDbiFlags(dbiFlagSet)
@@ -171,14 +166,14 @@ public void comparePerf(final boolean randomOrder) {
     for (int round = 0; round < 3; round++) {
       System.out.println("round: " + round + " -----------------------------------------");
       for (final Dbi<ByteBuffer> db : dbs) {
-        final String dbName = new String(db.getName(), StandardCharsets.UTF_8);
+        final String dbName = db.getNameAsString();
 
         final Instant start = Instant.now();
         int cnt = 0;
         // Exercise the stop key comparator on every entry
         try (Txn<ByteBuffer> txn = env.txnRead();
-            CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
-          for (final CursorIterable.KeyVal<ByteBuffer> kv : c) {
+            CursorIterable<ByteBuffer> cursorIterable = db.iterate(txn, keyRange)) {
+          for (final CursorIterable.KeyVal<ByteBuffer> ignored : cursorIterable) {
             cnt++;
           }
         }
diff --git a/src/test/java/org/lmdbjava/CursorParamTest.java b/src/test/java/org/lmdbjava/CursorParamTest.java
index 5b701382..4dd52b6f 100644
--- a/src/test/java/org/lmdbjava/CursorParamTest.java
+++ b/src/test/java/org/lmdbjava/CursorParamTest.java
@@ -37,7 +37,6 @@
 import static org.lmdbjava.SeekOp.MDB_NEXT;
 import static org.lmdbjava.SeekOp.MDB_PREV;
 import static org.lmdbjava.TestUtils.DB_1;
-import static org.lmdbjava.TestUtils.POSIX_MODE;
 import static org.lmdbjava.TestUtils.bb;
 import static org.lmdbjava.TestUtils.mdb;
 import static org.lmdbjava.TestUtils.nb;
@@ -162,7 +161,8 @@ private Env<T> env(final Path tmp) {
           .setMapSize(MEBIBYTES.toBytes(1))
           .setMaxReaders(1)
           .setMaxDbs(1)
-          .open(tmp.resolve("db").toFile(), POSIX_MODE, MDB_NOSUBDIR);
+          .setEnvFlags(MDB_NOSUBDIR)
+          .open(tmp.resolve("db"));
     }
   }
 
diff --git a/src/test/java/org/lmdbjava/CursorTest.java b/src/test/java/org/lmdbjava/CursorTest.java
index 41893ae6..9126026f 100644
--- a/src/test/java/org/lmdbjava/CursorTest.java
+++ b/src/test/java/org/lmdbjava/CursorTest.java
@@ -37,7 +37,6 @@
 import static org.lmdbjava.SeekOp.MDB_LAST;
 import static org.lmdbjava.SeekOp.MDB_NEXT;
 import static org.lmdbjava.TestUtils.DB_1;
-import static org.lmdbjava.TestUtils.POSIX_MODE;
 import static org.lmdbjava.TestUtils.bb;
 
 import java.nio.ByteBuffer;
@@ -65,7 +64,8 @@ void beforeEach() {
             .setMapSize(MEBIBYTES.toBytes(1))
             .setMaxReaders(1)
             .setMaxDbs(1)
-            .open(file.toFile(), POSIX_MODE, MDB_NOSUBDIR);
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(file);
   }
 
   @AfterEach
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 3e876f67..95da87a4 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -108,16 +108,16 @@ void afterEach() {
   @Test
   void close() {
     assertThatThrownBy(
-            () -> {
-              final Dbi<ByteBuffer> db = env.buildDbi()
-                  .setDbName(DB_1)
-                  .withDefaultComparator()
-                  .addDbiFlag(MDB_CREATE)
-                  .open();
-              db.put(bb(1), bb(42));
-              db.close();
-              db.put(bb(2), bb(42)); // error
-            })
+        () -> {
+          final Dbi<ByteBuffer> db = env.buildDbi()
+              .setDbName(DB_1)
+              .withDefaultComparator()
+              .addDbiFlag(MDB_CREATE)
+              .open();
+          db.put(bb(1), bb(42));
+          db.close();
+          db.put(bb(2), bb(42)); // error
+        })
         .isInstanceOf(ConstantDerivedException.class);
   }
 
@@ -152,7 +152,11 @@ private <T> void doCustomComparator(
       Comparator<T> comparator,
       IntFunction<T> serializer,
       ToIntFunction<T> deserializer) {
-    final Dbi<T> db = env.openDbi(DB_1, comparator, true, MDB_CREATE);
+    final Dbi<T> db = env.buildDbi()
+        .setDbName(DB_1)
+        .withCallbackComparator(ignored -> comparator)
+        .setDbiFlags(MDB_CREATE)
+        .open();
     try (Txn<T> txn = env.txnWrite()) {
       assertThat(db.put(txn, serializer.apply(2), serializer.apply(3))).isTrue();
       assertThat(db.put(txn, serializer.apply(4), serializer.apply(6))).isTrue();
@@ -172,11 +176,11 @@ private <T> void doCustomComparator(
   @Test
   void dbOpenMaxDatabases() {
     assertThatThrownBy(
-            () -> {
-              env.openDbi("db1 is OK", MDB_CREATE);
-              env.openDbi("db2 is OK", MDB_CREATE);
-              env.openDbi("db3 fails", MDB_CREATE);
-            })
+        () -> {
+          env.openDbi("db1 is OK", MDB_CREATE);
+          env.openDbi("db2 is OK", MDB_CREATE);
+          env.openDbi("db3 fails", MDB_CREATE);
+        })
         .isInstanceOf(DbFullException.class);
   }
 
@@ -197,49 +201,56 @@ private <T> void doDbiWithComparatorThreadSafety(
       Supplier<Comparator<T>> comparatorSupplier,
       IntFunction<T> serializer,
       ToIntFunction<T> deserializer) {
-    final DbiFlags[] flags = new DbiFlags[]{MDB_CREATE, MDB_INTEGERKEY};
-    final Comparator<T> c = comparatorSupplier.get();
-    final Dbi<T> db = env.openDbi(DB_1, c, true, flags);
-
-    final List<Integer> keys = range(0, 1_000).boxed().collect(toList());
-
-    final ExecutorService pool = Executors.newCachedThreadPool();
-    final AtomicBoolean proceed = new AtomicBoolean(true);
-    final Future<?> reader =
-        pool.submit(
-            () -> {
-              while (proceed.get()) {
-                try (Txn<T> txn = env.txnRead()) {
-                  db.get(txn, serializer.apply(50));
+    final DbiFlagSet flags = DbiFlagSet.of(MDB_CREATE, MDB_INTEGERKEY);
+    final Comparator<T> comparator = comparatorSupplier.get();
+    final Dbi<T> db = env.buildDbi()
+        .setDbName(DB_1)
+        .withCallbackComparator(ignored -> comparator)
+        .setDbiFlags(flags)
+        .open();
+
+    final List<Integer> keys = range(0, 1_000)
+        .boxed()
+        .collect(toList());
+
+    try (ExecutorService pool = Executors.newCachedThreadPool()) {
+      final AtomicBoolean proceed = new AtomicBoolean(true);
+      final Future<?> reader =
+          pool.submit(
+              () -> {
+                while (proceed.get()) {
+                  try (Txn<T> txn = env.txnRead()) {
+                    db.get(txn, serializer.apply(50));
+                  }
                 }
-              }
-            });
+              });
 
-    for (final Integer key : keys) {
-      try (Txn<T> txn = env.txnWrite()) {
-        db.put(txn, serializer.apply(key), serializer.apply(3));
-        txn.commit();
+      for (final Integer key : keys) {
+        try (Txn<T> txn = env.txnWrite()) {
+          db.put(txn, serializer.apply(key), serializer.apply(3));
+          txn.commit();
+        }
       }
-    }
 
-    try (Txn<T> txn = env.txnRead();
-         CursorIterable<T> ci = db.iterate(txn)) {
-      final Iterator<KeyVal<T>> iter = ci.iterator();
-      final List<Integer> result = new ArrayList<>();
-      while (iter.hasNext()) {
-        result.add(deserializer.applyAsInt(iter.next().key()));
-      }
+      try (Txn<T> txn = env.txnRead();
+           CursorIterable<T> ci = db.iterate(txn)) {
+        final Iterator<KeyVal<T>> iter = ci.iterator();
+        final List<Integer> result = new ArrayList<>();
+        while (iter.hasNext()) {
+          result.add(deserializer.applyAsInt(iter.next().key()));
+        }
 
-      assertThat(result).contains(keys.toArray(new Integer[0]));
-    }
+        assertThat(result).contains(keys.toArray(new Integer[0]));
+      }
 
-    proceed.set(false);
-    try {
-      reader.get(1, SECONDS);
-      pool.shutdown();
-      pool.awaitTermination(1, SECONDS);
-    } catch (ExecutionException | InterruptedException | TimeoutException e) {
-      throw new IllegalStateException(e);
+      proceed.set(false);
+      try {
+        reader.get(1, SECONDS);
+        pool.shutdown();
+        pool.awaitTermination(1, SECONDS);
+      } catch (ExecutionException | InterruptedException | TimeoutException e) {
+        throw new IllegalStateException(e);
+      }
     }
   }
 
@@ -280,7 +291,7 @@ void dropAndDelete() {
   @Test
   void dropAndDeleteAnonymousDb() {
     env.openDbi(DB_1, MDB_CREATE);
-    final Dbi<ByteBuffer> nameDb = env.openDbi((byte[]) null);
+    final Dbi<ByteBuffer> nameDb = env.openDbi((byte[]) null, DbiFlagSet.EMPTY);
     final byte[] dbNameBytes = DB_1.getBytes(UTF_8);
     final ByteBuffer dbNameBuffer = allocateDirect(dbNameBytes.length);
     dbNameBuffer.put(dbNameBytes).flip();
@@ -380,12 +391,12 @@ void putCommitGet() {
   void putCommitGetByteArray() {
     FileUtil.useTempFile(
         file -> {
-    try (Env<byte[]> envBa =
-             create(PROXY_BA)
-                 .setMapSize(MEBIBYTES.toBytes(64))
-                 .setMaxReaders(1)
-                 .setMaxDbs(2)
-                  .open(file.toFile(), MDB_NOSUBDIR)) {
+          try (Env<byte[]> envBa = create(PROXY_BA)
+                       .setMapSize(MEBIBYTES.toBytes(64))
+                       .setMaxReaders(1)
+                       .setMaxDbs(2)
+                       .setEnvFlags(MDB_NOSUBDIR)
+                       .open(file)) {
             final Dbi<byte[]> db = envBa.openDbi(DB_1, MDB_CREATE);
             try (Txn<byte[]> txn = envBa.txnWrite()) {
               db.put(txn, ba(5), ba(5));
@@ -517,19 +528,19 @@ void stats() {
   @Test
   void testMapFullException() {
     assertThatThrownBy(
-            () -> {
-              final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
-              try (Txn<ByteBuffer> txn = env.txnWrite()) {
-                final ByteBuffer v;
-                try {
-                  v = allocateDirect(1_024 * 1_024 * 1_024);
-                } catch (final OutOfMemoryError e) {
-                  // Travis CI OS X build cannot allocate this much memory, so assume OK
-                  throw new MapFullException();
-                }
-                db.put(txn, bb(1), v);
-              }
-            })
+        () -> {
+          final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+          try (Txn<ByteBuffer> txn = env.txnWrite()) {
+            final ByteBuffer v;
+            try {
+              v = allocateDirect(1_024 * 1_024 * 1_024);
+            } catch (final OutOfMemoryError e) {
+              // Travis CI OS X build cannot allocate this much memory, so assume OK
+              throw new MapFullException();
+            }
+            db.put(txn, bb(1), v);
+          }
+        })
         .isInstanceOf(MapFullException.class);
   }
 
@@ -554,109 +565,110 @@ void testParallelWritesStress() {
   @Test
   void closedEnvRejectsOpenCall() {
     assertThatThrownBy(
-            () -> {
-              env.close();
-              env.openDbi(DB_1, MDB_CREATE);
-            })
+        () -> {
+          env.close();
+          env.openDbi(DB_1, MDB_CREATE);
+        })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void closedEnvRejectsCloseCall() {
     assertThatThrownBy(
-            () -> {
-              doEnvClosedTest(null, (db, txn) -> db.close());
-            })
+        () -> {
+          doEnvClosedTest(null, (db, txn) -> db.close());
+        })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void closedEnvRejectsGetCall() {
     assertThatThrownBy(
-            () -> {
-              doEnvClosedTest(
-                  (db, txn) -> {
-                    final ByteBuffer valBuf = db.get(txn, bb(1));
-                    assertThat(valBuf.getInt()).isEqualTo(10);
-                  },
-                  (db, txn) -> db.get(txn, bb(2)));
-            })
+        () -> {
+          doEnvClosedTest(
+              (db, txn) -> {
+                final ByteBuffer valBuf = db.get(txn, bb(1));
+                assertThat(valBuf).isNotNull();
+                assertThat(valBuf.getInt()).isEqualTo(10);
+              },
+              (db, txn) -> db.get(txn, bb(2)));
+        })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void closedEnvRejectsPutCall() {
     assertThatThrownBy(
-            () -> {
-              doEnvClosedTest(null, (db, txn) -> db.put(bb(5), bb(50)));
-            })
+        () -> {
+          doEnvClosedTest(null, (db, txn) -> db.put(bb(5), bb(50)));
+        })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void closedEnvRejectsPutWithTxnCall() {
     assertThatThrownBy(
-            () -> {
-              doEnvClosedTest(
-                  null,
-                  (db, txn) -> {
-                    db.put(txn, bb(5), bb(50));
-                  });
-            })
+        () -> {
+          doEnvClosedTest(
+              null,
+              (db, txn) -> {
+                db.put(txn, bb(5), bb(50));
+              });
+        })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void closedEnvRejectsIterateCall() {
     assertThatThrownBy(
-            () -> {
-              doEnvClosedTest(null, Dbi::iterate);
-            })
+        () -> {
+          doEnvClosedTest(null, Dbi::iterate);
+        })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void closedEnvRejectsDropCall() {
     assertThatThrownBy(
-            () -> {
-              doEnvClosedTest(null, Dbi::drop);
-            })
+        () -> {
+          doEnvClosedTest(null, Dbi::drop);
+        })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void closedEnvRejectsDropAndDeleteCall() {
     assertThatThrownBy(
-            () -> {
-              doEnvClosedTest(null, (db, txn) -> db.drop(txn, true));
-            })
+        () -> {
+          doEnvClosedTest(null, (db, txn) -> db.drop(txn, true));
+        })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void closedEnvRejectsOpenCursorCall() {
     assertThatThrownBy(
-            () -> {
-              doEnvClosedTest(null, Dbi::openCursor);
-            })
+        () -> {
+          doEnvClosedTest(null, Dbi::openCursor);
+        })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void closedEnvRejectsReserveCall() {
     assertThatThrownBy(
-            () -> {
-              doEnvClosedTest(null, (db, txn) -> db.reserve(txn, bb(1), 32, MDB_NOOVERWRITE));
-            })
+        () -> {
+          doEnvClosedTest(null, (db, txn) -> db.reserve(txn, bb(1), 32, MDB_NOOVERWRITE));
+        })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void closedEnvRejectsStatCall() {
     assertThatThrownBy(
-            () -> {
-              doEnvClosedTest(null, Dbi::stat);
-            })
+        () -> {
+          doEnvClosedTest(null, Dbi::stat);
+        })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index eb925b42..69c20c1b 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -56,7 +56,8 @@ void byteUnit() {
                    Env.create()
                        .setMaxReaders(1)
                        .setMapSize(MEBIBYTES.toBytes(1))
-                       .open(file.toFile(), MDB_NOSUBDIR)) {
+                       .setEnvFlags(MDB_NOSUBDIR)
+                       .open(file)) {
             final EnvInfo info = env.info();
             assertThat(info.mapSize).isEqualTo(MEBIBYTES.toBytes(1));
           }
@@ -69,8 +70,10 @@ void cannotChangeMapSizeAfterOpen() {
         () -> {
           FileUtil.useTempFile(
               file -> {
-                final Builder<ByteBuffer> builder = Env.create().setMaxReaders(1);
-                try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
+                final Builder<ByteBuffer> builder = Env.create()
+                    .setMaxReaders(1)
+                    .setEnvFlags(MDB_NOSUBDIR);
+                try (Env<ByteBuffer> ignored = builder.open(file)) {
                   builder.setMapSize(1);
                 }
               });
@@ -84,8 +87,10 @@ void cannotChangeMaxDbsAfterOpen() {
         () -> {
           FileUtil.useTempFile(
               file -> {
-                final Builder<ByteBuffer> builder = Env.create().setMaxReaders(1);
-                try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
+                final Builder<ByteBuffer> builder = Env.create()
+                    .setMaxReaders(1)
+                    .setEnvFlags(MDB_NOSUBDIR);
+                try (Env<ByteBuffer> ignored = builder.open(file)) {
                   builder.setMaxDbs(1);
                 }
               });
@@ -99,8 +104,10 @@ void cannotChangeMaxReadersAfterOpen() {
         () -> {
           FileUtil.useTempFile(
               file -> {
-                final Builder<ByteBuffer> builder = Env.create().setMaxReaders(1);
-                try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
+                final Builder<ByteBuffer> builder = Env.create()
+                    .setMaxReaders(1)
+                    .setEnvFlags(MDB_NOSUBDIR);
+                try (Env<ByteBuffer> ignored = builder.open(file)) {
                   builder.setMaxReaders(1);
                 }
               });
@@ -114,8 +121,10 @@ void cannotInfoOnceClosed() {
         () -> {
           FileUtil.useTempFile(
               file -> {
-                final Env<ByteBuffer> env =
-                    Env.create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
+                final Env<ByteBuffer> env = Env.create()
+                    .setMaxReaders(1)
+                    .setEnvFlags(MDB_NOSUBDIR)
+                    .open(file);
                 env.close();
                 env.info();
               });
@@ -129,9 +138,12 @@ void cannotOpenTwice() {
         () -> {
           FileUtil.useTempFile(
               file -> {
-                final Builder<ByteBuffer> builder = Env.create().setMaxReaders(1);
-                builder.open(file.toFile(), MDB_NOSUBDIR).close();
-                builder.open(file.toFile(), MDB_NOSUBDIR);
+                final Builder<ByteBuffer> builder = Env.create()
+                    .setMaxReaders(1)
+                    .setEnvFlags(MDB_NOSUBDIR);
+                builder.open(file).close();
+                //noinspection resource // This will fail to open
+                builder.open(file);
               });
         })
         .isInstanceOf(AlreadyOpenException.class);
@@ -143,20 +155,33 @@ void cannotOverflowMapSize() {
         () -> {
           final Builder<ByteBuffer> builder = Env.create().setMaxReaders(1);
           final int mb = 1_024 * 1_024;
+          //noinspection NumericOverflow // Intentional overflow
           final int size = mb * 2_048; // as per issue 18
           builder.setMapSize(size);
         })
         .isInstanceOf(IllegalArgumentException.class);
   }
 
+  @Test
+  void negativeMapSize() {
+    assertThatThrownBy(
+        () -> {
+          final Builder<ByteBuffer> builder = Env.create().setMaxReaders(1);
+          builder.setMapSize(-1);
+        })
+        .isInstanceOf(IllegalArgumentException.class);
+  }
+
   @Test
   void cannotStatOnceClosed() {
     assertThatThrownBy(
         () -> {
           FileUtil.useTempFile(
               file -> {
-                final Env<ByteBuffer> env =
-                    Env.create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
+                final Env<ByteBuffer> env = Env.create()
+                    .setMaxReaders(1)
+                    .setEnvFlags(MDB_NOSUBDIR)
+                    .open(file);
                 env.close();
                 env.stat();
               });
@@ -170,8 +195,10 @@ void cannotSyncOnceClosed() {
         () -> {
           FileUtil.useTempFile(
               file -> {
-                final Env<ByteBuffer> env =
-                    Env.create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
+                final Env<ByteBuffer> env = Env.create()
+                    .setMaxReaders(1)
+                    .setEnvFlags(MDB_NOSUBDIR)
+                    .open(file);
                 env.close();
                 env.sync(false);
               });
@@ -188,7 +215,7 @@ void copyDirectoryBased() {
           assertThat(FileUtil.count(dest)).isEqualTo(0);
           FileUtil.useTempDir(
               src -> {
-                try (Env<ByteBuffer> env = Env.create().setMaxReaders(1).open(src.toFile())) {
+                try (Env<ByteBuffer> env = Env.create().setMaxReaders(1).open(src)) {
                   env.copy(dest.toFile(), MDB_CP_COMPACT);
                   assertThat(FileUtil.count(dest)).isEqualTo(1);
                 }
@@ -205,7 +232,7 @@ void copyDirectoryRejectsFileDestination() {
                 FileUtil.deleteDir(dest);
                 FileUtil.useTempDir(
                     src -> {
-                      try (Env<ByteBuffer> env = Env.create().setMaxReaders(1).open(src.toFile())) {
+                      try (Env<ByteBuffer> env = Env.create().setMaxReaders(1).open(src)) {
                         env.copy(dest.toFile(), MDB_CP_COMPACT);
                       }
                     });
@@ -225,7 +252,7 @@ void copyDirectoryRejectsMissingDestination() {
                   FileUtil.useTempDir(
                       src -> {
                         try (Env<ByteBuffer> env =
-                                 Env.create().setMaxReaders(1).open(src.toFile())) {
+                                 Env.create().setMaxReaders(1).open(src)) {
                           env.copy(dest.toFile(), MDB_CP_COMPACT);
                         }
                       });
@@ -250,7 +277,7 @@ void copyDirectoryRejectsNonEmptyDestination() {
                   FileUtil.useTempDir(
                       src -> {
                         try (Env<ByteBuffer> env =
-                                 Env.create().setMaxReaders(1).open(src.toFile())) {
+                                 Env.create().setMaxReaders(1).open(src)) {
                           env.copy(dest.toFile(), MDB_CP_COMPACT);
                         }
                       });
@@ -271,7 +298,7 @@ void copyFileBased() {
           FileUtil.useTempFile(
               src -> {
                 try (Env<ByteBuffer> env =
-                         Env.create().setMaxReaders(1).open(src.toFile(), MDB_NOSUBDIR)) {
+                         Env.create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR).open(src)) {
                   env.copy(dest.toFile(), MDB_CP_COMPACT);
                 }
                 assertThat(FileUtil.size(dest)).isGreaterThan(0L);
@@ -289,7 +316,7 @@ void copyFileRejectsExistingDestination() {
                 FileUtil.useTempFile(
                     src -> {
                       try (Env<ByteBuffer> env =
-                               Env.create().setMaxReaders(1).open(src.toFile(), MDB_NOSUBDIR)) {
+                               Env.create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR).open(src)) {
                         env.copy(dest.toFile(), MDB_CP_COMPACT);
                       }
                     });
@@ -302,7 +329,7 @@ void copyFileRejectsExistingDestination() {
   void createAsDirectory() {
     FileUtil.useTempDir(
         dest -> {
-          final Env<ByteBuffer> env = Env.create().setMaxReaders(1).open(dest.toFile());
+          final Env<ByteBuffer> env = Env.create().setMaxReaders(1).open(dest);
           assertThat(Files.isDirectory(dest)).isTrue();
           env.sync(false);
           env.close();
@@ -320,7 +347,8 @@ void createAsFile() {
                        .setMapSize(MEBIBYTES.toBytes(1))
                        .setMaxDbs(1)
                        .setMaxReaders(1)
-                       .open(file.toFile(), MDB_NOSUBDIR)) {
+                       .setEnvFlags(MDB_NOSUBDIR)
+                       .open(file)) {
             env.sync(true);
             assertThat(Files.isRegularFile(file)).isTrue();
           }
@@ -334,7 +362,7 @@ void detectTransactionThreadViolation() {
           FileUtil.useTempFile(
               file -> {
                 try (Env<ByteBuffer> env =
-                         Env.create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR)) {
+                         Env.create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR).open(file)) {
                   env.txnRead();
                   env.txnRead();
                 }
@@ -348,7 +376,7 @@ void info() {
     FileUtil.useTempFile(
         file -> {
           try (Env<ByteBuffer> env =
-                   Env.create().setMaxReaders(4).setMapSize(123_456).open(file.toFile(), MDB_NOSUBDIR)) {
+                   Env.create().setMaxReaders(4).setMapSize(123_456).setEnvFlags(MDB_NOSUBDIR).open(file)) {
             final EnvInfo info = env.info();
             assertThat(info).isNotNull();
             assertThat(info.lastPageNumber).isEqualTo(1L);
@@ -378,8 +406,9 @@ void mapFull() {
                              .setMaxReaders(1)
                              .setMapSize(MEBIBYTES.toBytes(8))
                              .setMaxDbs(1)
-                             .open(dir.toFile())) {
+                             .open(dir)) {
                   final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+                  //noinspection InfiniteLoopStatement // Needs infinite loop to fill the env
                   for (; ; ) {
                     rnd.nextBytes(k);
                     key.clear();
diff --git a/src/test/java/org/lmdbjava/GarbageCollectionTest.java b/src/test/java/org/lmdbjava/GarbageCollectionTest.java
index f0aa64e4..21ef5182 100644
--- a/src/test/java/org/lmdbjava/GarbageCollectionTest.java
+++ b/src/test/java/org/lmdbjava/GarbageCollectionTest.java
@@ -37,8 +37,10 @@ public class GarbageCollectionTest {
   void buffersNotGarbageCollectedTest() {
     FileUtil.useTempDir(
         dir -> {
-          try (Env<ByteBuffer> env =
-              create().setMapSize(2_085_760_999).setMaxDbs(1).open(dir.toFile())) {
+          try (Env<ByteBuffer> env = create()
+              .setMapSize(2_085_760_999)
+              .setMaxDbs(1)
+              .open(dir)) {
             final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
 
             try (Txn<ByteBuffer> txn = env.txnWrite()) {
diff --git a/src/test/java/org/lmdbjava/TutorialTest.java b/src/test/java/org/lmdbjava/TutorialTest.java
index 35e2c169..93c4a031 100644
--- a/src/test/java/org/lmdbjava/TutorialTest.java
+++ b/src/test/java/org/lmdbjava/TutorialTest.java
@@ -16,16 +16,13 @@
 
 package org.lmdbjava;
 
-import static java.nio.ByteBuffer.allocateDirect;
 import static java.nio.charset.StandardCharsets.UTF_8;
-import static java.util.concurrent.Executors.newCachedThreadPool;
 import static java.util.concurrent.TimeUnit.SECONDS;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
 import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
 import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
-import static org.lmdbjava.Env.create;
 import static org.lmdbjava.GetOp.MDB_SET;
 import static org.lmdbjava.SeekOp.MDB_FIRST;
 import static org.lmdbjava.SeekOp.MDB_LAST;
@@ -34,6 +31,7 @@
 import java.nio.ByteBuffer;
 import java.nio.file.Path;
 import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 import org.agrona.DirectBuffer;
 import org.agrona.MutableDirectBuffer;
 import org.agrona.concurrent.UnsafeBuffer;
@@ -57,7 +55,9 @@ public final class TutorialTest {
 
   private static final String DB_NAME = "my DB";
 
-  /** In this first tutorial we will use LmdbJava with some basic defaults. */
+  /**
+   * In this first tutorial we will use LmdbJava with some basic defaults.
+   */
   @Test
   void tutorial1() {
     // We need a storage directory first.
@@ -67,16 +67,15 @@ void tutorial1() {
 
           // We always need an Env. An Env owns a physical on-disk storage file. One
           // Env can store many different databases (ie sorted maps).
-          final Env<ByteBuffer> env =
-              create()
-                  // LMDB also needs to know how large our DB might be. Over-estimating is OK.
-                  .setMapSize(10_485_760)
-                  // LMDB also needs to know how many DBs (Dbi) we want to store in this Env.
-                  .setMaxDbs(1)
-                  // Now let's open the Env. The same path can be concurrently opened and
-                  // used in different processes, but do not open the same path twice in
-                  // the same process at the same time.
-                  .open(dir.toFile());
+          final Env<ByteBuffer> env = Env.create()
+              // LMDB also needs to know how large our DB might be. Over-estimating is OK.
+              .setMapSize(10_485_760)
+              // LMDB also needs to know how many DBs (Dbi) we want to store in this Env.
+              .setMaxDbs(1)
+              // Now let's open the Env. The same path can be concurrently opened and
+              // used in different processes, but do not open the same path twice in
+              // the same process at the same time.
+              .open(dir);
 
           // We need a Dbi for each DB. A Dbi roughly equates to a sorted map. The
           // MDB_CREATE flag causes the DB to be created if it doesn't already exist.
@@ -85,8 +84,8 @@ void tutorial1() {
           // We want to store some data, so we will need a direct ByteBuffer.
           // Note that LMDB keys cannot exceed maxKeySize bytes (511 bytes by default).
           // Values can be larger.
-          final ByteBuffer key = allocateDirect(env.getMaxKeySize());
-          final ByteBuffer val = allocateDirect(700);
+          final ByteBuffer key = ByteBuffer.allocateDirect(env.getMaxKeySize());
+          final ByteBuffer val = ByteBuffer.allocateDirect(700);
           key.put("greeting".getBytes(UTF_8)).flip();
           val.put("Hello world".getBytes(UTF_8)).flip();
           final int valSize = val.remaining();
@@ -125,7 +124,9 @@ void tutorial1() {
         });
   }
 
-  /** In this second tutorial we'll learn more about LMDB's ACID Txns. */
+  /**
+   * In this second tutorial we'll learn more about LMDB's ACID Txns.
+   */
   @Test
   void tutorial2() {
     FileUtil.useTempDir(
@@ -133,8 +134,8 @@ void tutorial2() {
           try {
             final Env<ByteBuffer> env = createSimpleEnv(dir);
             final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
-            final ByteBuffer key = allocateDirect(env.getMaxKeySize());
-            final ByteBuffer val = allocateDirect(700);
+            final ByteBuffer key = ByteBuffer.allocateDirect(env.getMaxKeySize());
+            final ByteBuffer val = ByteBuffer.allocateDirect(700);
 
             // Let's write and commit "key1" via a Txn. A Txn can include multiple Dbis.
             // Note write Txns block other write Txns, due to writes being serialized.
@@ -163,7 +164,7 @@ void tutorial2() {
             // typically permitted (the exception is a read-only Env with MDB_NOTLS).
             //
             // Let's write out a "key2" via a new write Txn in a different thread.
-            final ExecutorService es = newCachedThreadPool();
+            final ExecutorService es = Executors.newCachedThreadPool();
             es.execute(
                 () -> {
                   try (Txn<ByteBuffer> txn = env.txnWrite()) {
@@ -211,8 +212,8 @@ void tutorial3() {
         dir -> {
           final Env<ByteBuffer> env = createSimpleEnv(dir);
           final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
-          final ByteBuffer key = allocateDirect(env.getMaxKeySize());
-          final ByteBuffer val = allocateDirect(700);
+          final ByteBuffer key = ByteBuffer.allocateDirect(env.getMaxKeySize());
+          final ByteBuffer val = ByteBuffer.allocateDirect(700);
 
           try (Txn<ByteBuffer> txn = env.txnWrite()) {
             // A cursor always belongs to a particular Dbi.
@@ -288,8 +289,8 @@ void tutorial4() {
           final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
 
           try (Txn<ByteBuffer> txn = env.txnWrite()) {
-            final ByteBuffer key = allocateDirect(env.getMaxKeySize());
-            final ByteBuffer val = allocateDirect(700);
+            final ByteBuffer key = ByteBuffer.allocateDirect(env.getMaxKeySize());
+            final ByteBuffer val = ByteBuffer.allocateDirect(700);
 
             // Insert some data. Note that ByteBuffer order defaults to Big Endian.
             // LMDB does not persist the byte order, but it's critical to sort keys.
@@ -336,7 +337,9 @@ void tutorial4() {
         });
   }
 
-  /** In this fifth tutorial we'll explore multiple values sharing a single key. */
+  /**
+   * In this fifth tutorial we'll explore multiple values sharing a single key.
+   */
   @Test
   void tutorial5() {
     FileUtil.useTempDir(
@@ -348,8 +351,8 @@ void tutorial5() {
           final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
 
           // Duplicate support requires both keys and values to be <= max key size.
-          final ByteBuffer key = allocateDirect(env.getMaxKeySize());
-          final ByteBuffer val = allocateDirect(env.getMaxKeySize());
+          final ByteBuffer key = ByteBuffer.allocateDirect(env.getMaxKeySize());
+          final ByteBuffer val = ByteBuffer.allocateDirect(env.getMaxKeySize());
 
           try (Txn<ByteBuffer> txn = env.txnWrite()) {
             final Cursor<ByteBuffer> c = db.openCursor(txn);
@@ -396,11 +399,10 @@ void tutorial6() {
     FileUtil.useTempDir(
         dir -> {
           // Note we need to specify the Verifier's DBI_COUNT for the Env.
-          final Env<ByteBuffer> env =
-              create(PROXY_OPTIMAL)
+          final Env<ByteBuffer> env = Env.create(PROXY_OPTIMAL)
                   .setMapSize(10_485_760)
                   .setMaxDbs(Verifier.DBI_COUNT)
-                  .open(dir.toFile());
+                  .open(dir);
 
           // Create a Verifier (it's a Callable<Long> for those needing full control).
           final Verifier v = new Verifier(env);
@@ -413,7 +415,9 @@ void tutorial6() {
         });
   }
 
-  /** In this final tutorial we'll look at using Agrona's DirectBuffer. */
+  /**
+   * In this final tutorial we'll look at using Agrona's DirectBuffer.
+   */
   @Test
   void tutorial7() {
     FileUtil.useTempDir(
@@ -421,14 +425,16 @@ void tutorial7() {
           // The critical difference is we pass the PROXY_DB field to Env.create().
           // There's also a PROXY_SAFE if you want to stop ByteBuffer's Unsafe use.
           // Aside from that and a different type argument, it's the same as usual...
-          final Env<DirectBuffer> env =
-              create(PROXY_DB).setMapSize(10_485_760).setMaxDbs(1).open(dir.toFile());
+          final Env<DirectBuffer> env = Env.create(PROXY_DB)
+              .setMapSize(10_485_760)
+              .setMaxDbs(1)
+              .open(dir);
 
           final Dbi<DirectBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
 
-          final ByteBuffer keyBb = allocateDirect(env.getMaxKeySize());
+          final ByteBuffer keyBb = ByteBuffer.allocateDirect(env.getMaxKeySize());
           final MutableDirectBuffer key = new UnsafeBuffer(keyBb);
-          final MutableDirectBuffer val = new UnsafeBuffer(allocateDirect(700));
+          final MutableDirectBuffer val = new UnsafeBuffer(ByteBuffer.allocateDirect(700));
 
           try (Txn<DirectBuffer> txn = env.txnWrite()) {
             try (Cursor<DirectBuffer> c = db.openCursor(txn)) {
@@ -479,6 +485,10 @@ void tutorial7() {
   // or reverse ordered keys, using Env.DISABLE_CHECKS_PROP etc), but you now
   // know enough to tackle the JavaDocs with confidence. Have fun!
   private Env<ByteBuffer> createSimpleEnv(final Path path) {
-    return create().setMapSize(10_485_760).setMaxDbs(1).setMaxReaders(1).open(path.toFile());
+    return Env.create()
+        .setMapSize(10_485_760)
+        .setMaxDbs(1)
+        .setMaxReaders(1)
+        .open(path);
   }
 }
diff --git a/src/test/java/org/lmdbjava/TxnTest.java b/src/test/java/org/lmdbjava/TxnTest.java
index 46ffeb70..f81b525e 100644
--- a/src/test/java/org/lmdbjava/TxnTest.java
+++ b/src/test/java/org/lmdbjava/TxnTest.java
@@ -27,7 +27,6 @@
 import static org.lmdbjava.EnvFlags.MDB_RDONLY_ENV;
 import static org.lmdbjava.KeyRange.closed;
 import static org.lmdbjava.TestUtils.DB_1;
-import static org.lmdbjava.TestUtils.POSIX_MODE;
 import static org.lmdbjava.TestUtils.bb;
 import static org.lmdbjava.Txn.State.DONE;
 import static org.lmdbjava.Txn.State.READY;
@@ -68,7 +67,8 @@ void beforeEach() {
             .setMapSize(KIBIBYTES.toBytes(256))
             .setMaxReaders(1)
             .setMaxDbs(2)
-            .open(file.toFile(), POSIX_MODE, MDB_NOSUBDIR);
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(file);
   }
 
   @AfterEach
@@ -126,8 +126,10 @@ void rangeSearch() {
   @Test
   void readOnlyTxnAllowedInReadOnlyEnv() {
     env.openDbi(DB_1, MDB_CREATE);
-    try (Env<ByteBuffer> roEnv =
-        create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR, MDB_RDONLY_ENV)) {
+    try (Env<ByteBuffer> roEnv = create()
+        .setMaxReaders(1)
+        .setEnvFlags(MDB_NOSUBDIR, MDB_RDONLY_ENV)
+        .open(file)) {
       assertThat(roEnv.txnRead()).isNotNull();
     }
   }

From 577062f6d5df8e0cde054d11334e507419c63414 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Thu, 6 Nov 2025 10:33:06 +0000
Subject: [PATCH 261/322] Fix compile issue

---
 .../org/lmdbjava/AbstractFlagSetTest.java     | 20 +++++
 src/test/java/org/lmdbjava/DbiTest.java       | 75 ++++++++++---------
 2 files changed, 58 insertions(+), 37 deletions(-)
 create mode 100644 src/test/java/org/lmdbjava/AbstractFlagSetTest.java

diff --git a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
new file mode 100644
index 00000000..f986fa7f
--- /dev/null
+++ b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+public abstract class AbstractFlagSetTest {
+
+}
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 95da87a4..6d86bd85 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -213,44 +213,45 @@ private <T> void doDbiWithComparatorThreadSafety(
         .boxed()
         .collect(toList());
 
-    try (ExecutorService pool = Executors.newCachedThreadPool()) {
-      final AtomicBoolean proceed = new AtomicBoolean(true);
-      final Future<?> reader =
-          pool.submit(
-              () -> {
-                while (proceed.get()) {
-                  try (Txn<T> txn = env.txnRead()) {
-                    db.get(txn, serializer.apply(50));
-                  }
+    // TODO surround with try-with-resources in J19+
+    //noinspection resource // Not in J8
+    ExecutorService pool = Executors.newCachedThreadPool();
+    final AtomicBoolean proceed = new AtomicBoolean(true);
+    final Future<?> reader =
+        pool.submit(
+            () -> {
+              while (proceed.get()) {
+                try (Txn<T> txn = env.txnRead()) {
+                  db.get(txn, serializer.apply(50));
                 }
-              });
+              }
+            });
 
-      for (final Integer key : keys) {
-        try (Txn<T> txn = env.txnWrite()) {
-          db.put(txn, serializer.apply(key), serializer.apply(3));
-          txn.commit();
-        }
+    for (final Integer key : keys) {
+      try (Txn<T> txn = env.txnWrite()) {
+        db.put(txn, serializer.apply(key), serializer.apply(3));
+        txn.commit();
       }
+    }
 
-      try (Txn<T> txn = env.txnRead();
-           CursorIterable<T> ci = db.iterate(txn)) {
-        final Iterator<KeyVal<T>> iter = ci.iterator();
-        final List<Integer> result = new ArrayList<>();
-        while (iter.hasNext()) {
-          result.add(deserializer.applyAsInt(iter.next().key()));
-        }
-
-        assertThat(result).contains(keys.toArray(new Integer[0]));
+    try (Txn<T> txn = env.txnRead();
+         CursorIterable<T> ci = db.iterate(txn)) {
+      final Iterator<KeyVal<T>> iter = ci.iterator();
+      final List<Integer> result = new ArrayList<>();
+      while (iter.hasNext()) {
+        result.add(deserializer.applyAsInt(iter.next().key()));
       }
 
-      proceed.set(false);
-      try {
-        reader.get(1, SECONDS);
-        pool.shutdown();
-        pool.awaitTermination(1, SECONDS);
-      } catch (ExecutionException | InterruptedException | TimeoutException e) {
-        throw new IllegalStateException(e);
-      }
+      assertThat(result).contains(keys.toArray(new Integer[0]));
+    }
+
+    proceed.set(false);
+    try {
+      reader.get(1, SECONDS);
+      pool.shutdown();
+      pool.awaitTermination(1, SECONDS);
+    } catch (ExecutionException | InterruptedException | TimeoutException e) {
+      throw new IllegalStateException(e);
     }
   }
 
@@ -392,11 +393,11 @@ void putCommitGetByteArray() {
     FileUtil.useTempFile(
         file -> {
           try (Env<byte[]> envBa = create(PROXY_BA)
-                       .setMapSize(MEBIBYTES.toBytes(64))
-                       .setMaxReaders(1)
-                       .setMaxDbs(2)
-                       .setEnvFlags(MDB_NOSUBDIR)
-                       .open(file)) {
+              .setMapSize(MEBIBYTES.toBytes(64))
+              .setMaxReaders(1)
+              .setMaxDbs(2)
+              .setEnvFlags(MDB_NOSUBDIR)
+              .open(file)) {
             final Dbi<byte[]> db = envBa.openDbi(DB_1, MDB_CREATE);
             try (Txn<byte[]> txn = envBa.txnWrite()) {
               db.put(txn, ba(5), ba(5));

From 12a9679899aefe8e27a9af9da4b688189ba0085f Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Thu, 6 Nov 2025 11:31:32 +0000
Subject: [PATCH 262/322] Improve FlagSet tests

---
 .../java/org/lmdbjava/AbstractFlagSet.java    |  12 +-
 src/main/java/org/lmdbjava/CopyFlagSet.java   |   4 +-
 src/main/java/org/lmdbjava/DbiBuilder.java    |   8 +-
 src/main/java/org/lmdbjava/DbiFlagSet.java    |   4 +-
 src/main/java/org/lmdbjava/Env.java           |   8 +-
 src/main/java/org/lmdbjava/EnvFlagSet.java    |   4 +-
 src/main/java/org/lmdbjava/PutFlagSet.java    |   4 +-
 src/main/java/org/lmdbjava/TxnFlagSet.java    |  15 +-
 .../org/lmdbjava/AbstractFlagSetTest.java     | 153 ++++++++++++++++--
 .../java/org/lmdbjava/CopyFlagSetTest.java    |  85 ++++------
 .../java/org/lmdbjava/DbiFlagSetTest.java     |  99 ++++--------
 .../java/org/lmdbjava/EnvFlagSetTest.java     |  99 ++++--------
 .../java/org/lmdbjava/PutFlagSetTest.java     |  96 ++++-------
 .../java/org/lmdbjava/TxnFlagSetTest.java     |  96 ++++-------
 14 files changed, 324 insertions(+), 363 deletions(-)

diff --git a/src/main/java/org/lmdbjava/AbstractFlagSet.java b/src/main/java/org/lmdbjava/AbstractFlagSet.java
index 058969de..849bbe73 100644
--- a/src/main/java/org/lmdbjava/AbstractFlagSet.java
+++ b/src/main/java/org/lmdbjava/AbstractFlagSet.java
@@ -278,7 +278,7 @@ protected Builder(final Class<E> type,
      * @param flags The flags to set in the builder.
      * @return this builder instance.
      */
-    public Builder<E, S> withFlags(final Collection<E> flags) {
+    public Builder<E, S> setFlags(final Collection<E> flags) {
       clear();
       if (flags != null) {
         for (E flag : flags) {
@@ -295,7 +295,7 @@ public Builder<E, S> withFlags(final Collection<E> flags) {
      * @return this builder instance.
      */
     @SafeVarargs
-    public final Builder<E, S> withFlags(final E... flags) {
+    public final Builder<E, S> setFlags(final E... flags) {
       clear();
       if (flags != null) {
         for (E flag : flags) {
@@ -311,12 +311,12 @@ public final Builder<E, S> withFlags(final E... flags) {
     }
 
     /**
-     * Sets a single flag in the builder.
+     * Adds a single flag in the builder.
      *
      * @param flag The flag to set in the builder.
      * @return this builder instance.
      */
-    public Builder<E, S> setFlag(final E flag) {
+    public Builder<E, S> addFlag(final E flag) {
       if (flag != null) {
         enumSet.add(flag);
       }
@@ -324,12 +324,12 @@ public Builder<E, S> setFlag(final E flag) {
     }
 
     /**
-     * Sets multiple flag in the builder.
+     * Adds multiple flag in the builder.
      *
      * @param flags The flags to set in the builder.
      * @return this builder instance.
      */
-    public Builder<E, S> setFlags(final Collection<E> flags) {
+    public Builder<E, S> addFlags(final Collection<E> flags) {
       if (flags != null) {
         enumSet.addAll(flags);
       }
diff --git a/src/main/java/org/lmdbjava/CopyFlagSet.java b/src/main/java/org/lmdbjava/CopyFlagSet.java
index 5f7901de..e21680dd 100644
--- a/src/main/java/org/lmdbjava/CopyFlagSet.java
+++ b/src/main/java/org/lmdbjava/CopyFlagSet.java
@@ -34,13 +34,13 @@ static CopyFlagSet of(final CopyFlags dbiFlag) {
 
   static CopyFlagSet of(final CopyFlags... CopyFlags) {
     return builder()
-        .withFlags(CopyFlags)
+        .setFlags(CopyFlags)
         .build();
   }
 
   static CopyFlagSet of(final Collection<CopyFlags> CopyFlags) {
     return builder()
-        .withFlags(CopyFlags)
+        .setFlags(CopyFlags)
         .build();
   }
 
diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
index 1abff0a2..b478c9df 100644
--- a/src/main/java/org/lmdbjava/DbiBuilder.java
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -300,7 +300,7 @@ public DbiBuilderStage3<T> setDbiFlags(final DbiFlags... dbiFlags) {
       if (dbiFlags != null) {
         Arrays.stream(dbiFlags)
             .filter(Objects::nonNull)
-            .forEach(this.flagSetBuilder::setFlag);
+            .forEach(this.flagSetBuilder::addFlag);
       }
       return this;
     }
@@ -322,7 +322,7 @@ public DbiBuilderStage3<T> setDbiFlags(final DbiFlags... dbiFlags) {
     public DbiBuilderStage3<T> setDbiFlags(final DbiFlagSet dbiFlagSet) {
       flagSetBuilder.clear();
       if (dbiFlagSet != null) {
-        this.flagSetBuilder.withFlags(dbiFlagSet.getFlags());
+        this.flagSetBuilder.setFlags(dbiFlagSet.getFlags());
       }
       return this;
     }
@@ -337,7 +337,7 @@ public DbiBuilderStage3<T> setDbiFlags(final DbiFlagSet dbiFlagSet) {
      * @return this builder instance.
      */
     public DbiBuilderStage3<T> addDbiFlag(final DbiFlags dbiFlag) {
-      this.flagSetBuilder.setFlag(dbiFlag);
+      this.flagSetBuilder.addFlag(dbiFlag);
       return this;
     }
 
@@ -352,7 +352,7 @@ public DbiBuilderStage3<T> addDbiFlag(final DbiFlags dbiFlag) {
      */
     public DbiBuilderStage3<T> addDbiFlags(final DbiFlagSet dbiFlagSet) {
       if (dbiFlagSet != null) {
-        flagSetBuilder.setFlags(dbiFlagSet.getFlags());
+        flagSetBuilder.addFlags(dbiFlagSet.getFlags());
       }
       return this;
     }
diff --git a/src/main/java/org/lmdbjava/DbiFlagSet.java b/src/main/java/org/lmdbjava/DbiFlagSet.java
index 5a0bc83e..8ffd2499 100644
--- a/src/main/java/org/lmdbjava/DbiFlagSet.java
+++ b/src/main/java/org/lmdbjava/DbiFlagSet.java
@@ -40,13 +40,13 @@ static DbiFlagSet of(final DbiFlags dbiFlag) {
 
   static DbiFlagSet of(final DbiFlags... DbiFlags) {
     return builder()
-        .withFlags(DbiFlags)
+        .setFlags(DbiFlags)
         .build();
   }
 
   static DbiFlagSet of(final Collection<DbiFlags> DbiFlags) {
     return builder()
-        .withFlags(DbiFlags)
+        .setFlags(DbiFlags)
         .build();
   }
 
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 7ccebb4e..542b67c3 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -885,7 +885,7 @@ public Builder<T> setEnvFlags(final EnvFlags... envFlags) {
       if (envFlags != null) {
         Arrays.stream(envFlags)
             .filter(Objects::nonNull)
-            .forEach(this.flagSetBuilder::setFlag);
+            .forEach(this.flagSetBuilder::addFlag);
       }
       return this;
     }
@@ -901,7 +901,7 @@ public Builder<T> setEnvFlags(final EnvFlags... envFlags) {
     public Builder<T> setEnvFlags(final EnvFlagSet envFlagSet) {
       flagSetBuilder.clear();
       if (envFlagSet != null) {
-        this.flagSetBuilder.withFlags(envFlagSet.getFlags());
+        this.flagSetBuilder.setFlags(envFlagSet.getFlags());
       }
       return this;
     }
@@ -914,7 +914,7 @@ public Builder<T> setEnvFlags(final EnvFlagSet envFlagSet) {
      * @return this builder instance.
      */
     public Builder<T> addEnvFlag(final EnvFlags dbiFlag) {
-      this.flagSetBuilder.setFlag(dbiFlag);
+      this.flagSetBuilder.addFlag(dbiFlag);
       return this;
     }
 
@@ -927,7 +927,7 @@ public Builder<T> addEnvFlag(final EnvFlags dbiFlag) {
      */
     public Builder<T> addEnvFlags(final EnvFlagSet dbiFlagSet) {
       if (dbiFlagSet != null) {
-        flagSetBuilder.setFlags(dbiFlagSet.getFlags());
+        flagSetBuilder.addFlags(dbiFlagSet.getFlags());
       }
       return this;
     }
diff --git a/src/main/java/org/lmdbjava/EnvFlagSet.java b/src/main/java/org/lmdbjava/EnvFlagSet.java
index a3c8d1fa..c104edd9 100644
--- a/src/main/java/org/lmdbjava/EnvFlagSet.java
+++ b/src/main/java/org/lmdbjava/EnvFlagSet.java
@@ -34,13 +34,13 @@ static EnvFlagSet of(final EnvFlags envFlag) {
 
   static EnvFlagSet of(final EnvFlags... EnvFlags) {
     return builder()
-        .withFlags(EnvFlags)
+        .setFlags(EnvFlags)
         .build();
   }
 
   static EnvFlagSet of(final Collection<EnvFlags> EnvFlags) {
     return builder()
-        .withFlags(EnvFlags)
+        .setFlags(EnvFlags)
         .build();
   }
 
diff --git a/src/main/java/org/lmdbjava/PutFlagSet.java b/src/main/java/org/lmdbjava/PutFlagSet.java
index 9d3a7288..aaba7cb7 100644
--- a/src/main/java/org/lmdbjava/PutFlagSet.java
+++ b/src/main/java/org/lmdbjava/PutFlagSet.java
@@ -34,13 +34,13 @@ static PutFlagSet of(final PutFlags putFlag) {
 
     static PutFlagSet of(final PutFlags... putFlags) {
         return builder()
-                .withFlags(putFlags)
+                .setFlags(putFlags)
                 .build();
     }
 
     static PutFlagSet of(final Collection<PutFlags> putFlags) {
         return builder()
-            .withFlags(putFlags)
+            .setFlags(putFlags)
             .build();
     }
 
diff --git a/src/main/java/org/lmdbjava/TxnFlagSet.java b/src/main/java/org/lmdbjava/TxnFlagSet.java
index 8e6310b3..0943b362 100644
--- a/src/main/java/org/lmdbjava/TxnFlagSet.java
+++ b/src/main/java/org/lmdbjava/TxnFlagSet.java
@@ -15,6 +15,7 @@
  */
 package org.lmdbjava;
 
+import java.util.Collection;
 import java.util.EnumSet;
 import java.util.Objects;
 
@@ -26,14 +27,20 @@ static TxnFlagSet empty() {
     return TxnFlagSetImpl.EMPTY;
   }
 
-  static TxnFlagSet of(final TxnFlags putFlag) {
-    Objects.requireNonNull(putFlag);
-    return new SingleTxnFlagSet(putFlag);
+  static TxnFlagSet of(final TxnFlags putflag) {
+    Objects.requireNonNull(putflag);
+    return new SingleTxnFlagSet(putflag);
   }
 
   static TxnFlagSet of(final TxnFlags... TxnFlags) {
     return builder()
-        .withFlags(TxnFlags)
+        .setFlags(TxnFlags)
+        .build();
+  }
+
+  static TxnFlagSet of(final Collection<TxnFlags> txnFlags) {
+    return builder()
+        .setFlags(txnFlags)
         .build();
   }
 
diff --git a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
index f986fa7f..e09d72c6 100644
--- a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
@@ -1,20 +1,141 @@
-/*
- * Copyright © 2016-2025 The LmdbJava Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 package org.lmdbjava;
 
-public abstract class AbstractFlagSetTest {
+import static org.assertj.core.api.Assertions.assertThat;
 
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import org.junit.jupiter.api.Test;
+
+public abstract class AbstractFlagSetTest<T extends Enum<T> & MaskedFlag & FlagSet<T>, F extends FlagSet<T>> {
+
+  abstract List<T> getAllFlags();
+
+  abstract F getEmptyFlagSet();
+
+  abstract AbstractFlagSet.Builder<T, F> getBuilder();
+
+  abstract F getFlagSet(final Collection<T> flags);
+
+  abstract F getFlagSet(final T[] flags);
+
+  abstract F getFlagSet(final T flag);
+
+  abstract Class<T> getFlagType();
+
+  T getFirst() {
+    return getAllFlags().get(0);
+  }
+
+  int getFlagCount() {
+    return getAllFlags().size();
+  }
+
+  @Test
+  void testEmpty() {
+    final F emptyFlagSet = getEmptyFlagSet();
+    assertThat(emptyFlagSet.getMask())
+        .isEqualTo(0);
+    assertThat(emptyFlagSet.getFlags())
+        .isEmpty();
+    assertThat(emptyFlagSet.isEmpty())
+        .isTrue();
+    assertThat(emptyFlagSet.size())
+        .isEqualTo(0);
+    assertThat(emptyFlagSet.isSet(getFirst()))
+        .isFalse();
+    assertThat(getBuilder().build().getFlags())
+        .isEqualTo(emptyFlagSet.getFlags());
+  }
+
+  @Test
+  void testSingleFlagSet() {
+    final List<T> allFlags = getAllFlags();
+    for (T flag : allFlags) {
+      final F flagSet = getBuilder()
+          .addFlag(flag)
+          .build();
+      assertThat(flagSet.getMask())
+          .isEqualTo(flag.getMask());
+      assertThat(flagSet.getMask())
+          .isEqualTo(MaskedFlag.mask(flag));
+      assertThat(flagSet.getFlags())
+          .containsExactly(flag);
+      assertThat(flagSet.size())
+          .isEqualTo(1);
+      assertThat(FlagSet.equals(flagSet, flag))
+          .isTrue();
+      assertThat(FlagSet.equals(flagSet, getFlagSet(flag)))
+          .isTrue();
+      assertThat(FlagSet.equals(flagSet, getFlagSet(flagSet.getFlags())))
+          .isTrue();
+      assertThat(flagSet.areAnySet(flag))
+          .isTrue();
+      assertThat(flagSet.isSet(getFirst()))
+          .isEqualTo(getFirst() == flag);
+      if (getFirst() == flag) {
+        assertThat(flagSet.getMask())
+            .isEqualTo(MaskedFlag.mask(getFirst()));
+      } else {
+        assertThat(flagSet.getMask())
+            .isNotEqualTo(MaskedFlag.mask(getFirst()));
+      }
+      assertThat(flagSet.toString())
+          .isNotNull();
+      assertThat(flag.name())
+          .isNotNull();
+    }
+  }
+
+  @Test
+  void testAllFlags() {
+    final List<T> allFlags = getAllFlags();
+    final List<T> flags = new ArrayList<>(allFlags.size());
+    final Set<Integer> masks = new HashSet<>();
+    final T firstFlag = getFirst();
+    for (T flag : allFlags) {
+      flags.add(flag);
+      final F flagSet = getBuilder()
+          .setFlags(flags)
+          .build();
+      final int flagSetMask = flagSet.getMask();
+
+      assertThat(masks)
+          .doesNotContain(flagSetMask);
+      masks.add(flagSetMask);
+      assertThat(flagSetMask)
+          .isEqualTo(MaskedFlag.mask(flags));
+      final T[] flagsArr = flags.stream().toArray(this::toArray);
+      assertThat(flagSetMask)
+          .isEqualTo(MaskedFlag.mask(flagsArr));
+      assertThat(flagSet.getFlags())
+          .containsExactlyElementsOf(flags);
+      assertThat(flagSet)
+          .isNotEmpty();
+      assertThat(FlagSet.equals(flagSet, getBuilder().setFlags(flagsArr).build()))
+          .isTrue();
+      assertThat(FlagSet.equals(flagSet, getFlagSet(flags)))
+          .isTrue();
+      assertThat(FlagSet.equals(flagSet, getFlagSet(flagsArr)))
+          .isTrue();
+      assertThat(flagSet.size())
+          .isEqualTo(flags.size());
+      assertThat(flagSet.isSet(getFirst()))
+          .isEqualTo(true);
+
+      final int maskWith = flagSet.getMaskWith(firstFlag);
+      final List<T> combinedList = new ArrayList<>(flags);
+      combinedList.add(firstFlag);
+      assertThat(maskWith)
+          .isEqualTo(MaskedFlag.mask(combinedList));
+    }
+  }
+
+  private T[] toArray(final int cnt) {
+    //noinspection unchecked
+    return (T[]) Array.newInstance(getFlagType(), cnt);
+  }
 }
diff --git a/src/test/java/org/lmdbjava/CopyFlagSetTest.java b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
index 2782fe81..e53c7508 100644
--- a/src/test/java/org/lmdbjava/CopyFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
@@ -15,65 +15,46 @@
  */
 package org.lmdbjava;
 
-import static org.assertj.core.api.Assertions.assertThat;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Collectors;
 
-import java.util.Collections;
-import java.util.HashSet;
-import org.junit.jupiter.api.Test;
+public class CopyFlagSetTest extends AbstractFlagSetTest<CopyFlags, CopyFlagSet> {
 
-public class CopyFlagSetTest {
+    @Override
+    List<CopyFlags> getAllFlags() {
+        return Arrays.stream(CopyFlags.values())
+            .collect(Collectors.toList());
+    }
+
+    @Override
+    CopyFlagSet getEmptyFlagSet() {
+        return CopyFlagSet.empty();
+    }
 
-    @Test
-    public void testEmpty() {
-        final CopyFlagSet copyFlagSet = CopyFlagSet.empty();
-        assertThat(copyFlagSet.getMask()).isEqualTo(0);
-        assertThat(copyFlagSet.size()).isEqualTo(0);
-        assertThat(copyFlagSet.isEmpty()).isEqualTo(true);
-        assertThat(copyFlagSet.isSet(CopyFlags.MDB_CP_COMPACT)).isEqualTo(false);
-        final CopyFlagSet copyFlagSet2 = CopyFlagSet.builder()
-            .build();
-        assertThat(copyFlagSet).isEqualTo(copyFlagSet2);
-        assertThat(copyFlagSet).isNotEqualTo(CopyFlagSet.of(CopyFlags.MDB_CP_COMPACT));
-        assertThat(copyFlagSet).isNotEqualTo(CopyFlagSet.builder()
-            .setFlag(CopyFlags.MDB_CP_COMPACT)
-            .build());
+    @Override
+    AbstractFlagSet.Builder<CopyFlags, CopyFlagSet> getBuilder() {
+        return CopyFlagSet.builder();
     }
 
-    @Test
-    public void testOf() {
-        final CopyFlags copyFlag = CopyFlags.MDB_CP_COMPACT;
-        final CopyFlagSet copyFlagSet = CopyFlagSet.of(copyFlag);
-        assertThat(copyFlagSet.getMask()).isEqualTo(MaskedFlag.mask(copyFlag));
-        assertThat(copyFlagSet.size()).isEqualTo(1);
-        for (CopyFlags flag : copyFlagSet) {
-            assertThat(copyFlagSet.isSet(flag)).isEqualTo(true);
-        }
+    @Override
+    CopyFlagSet getFlagSet(Collection<CopyFlags> flags) {
+        return CopyFlagSet.of(flags);
+    }
+
+    @Override
+    CopyFlagSet getFlagSet(CopyFlags[] flags) {
+        return CopyFlagSet.of(flags);
+    }
 
-        final CopyFlagSet copyFlagSet2 = CopyFlagSet.builder()
-            .setFlag(copyFlag)
-            .build();
-        assertThat(copyFlagSet).isEqualTo(copyFlagSet2);
+    @Override
+    CopyFlagSet getFlagSet(CopyFlags flag) {
+        return CopyFlagSet.of(flag);
     }
 
-    @Test
-    public void testBuilder() {
-        final CopyFlags copyFlag1 = CopyFlags.MDB_CP_COMPACT;
-        final CopyFlagSet copyFlagSet = CopyFlagSet.builder()
-                .setFlag(copyFlag1)
-                .build();
-        assertThat(copyFlagSet.getMask()).isEqualTo(MaskedFlag.mask(copyFlag1));
-        assertThat(copyFlagSet.size()).isEqualTo(1);
-        assertThat(copyFlagSet.isSet(CopyFlags.MDB_CP_COMPACT)).isEqualTo(true);
-        for (CopyFlags flag : copyFlagSet) {
-            assertThat(copyFlagSet.isSet(flag)).isEqualTo(true);
-        }
-        final CopyFlagSet copyFlagSet2 = CopyFlagSet.builder()
-                .withFlags(copyFlag1)
-                .build();
-        final CopyFlagSet copyFlagSet3 = CopyFlagSet.builder()
-                .withFlags(new HashSet<>(Collections.singletonList(copyFlag1)))
-                .build();
-        assertThat(copyFlagSet).isEqualTo(copyFlagSet2);
-        assertThat(copyFlagSet).isEqualTo(copyFlagSet3);
+    @Override
+    Class<CopyFlags> getFlagType() {
+        return CopyFlags.class;
     }
 }
diff --git a/src/test/java/org/lmdbjava/DbiFlagSetTest.java b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
index aa66313f..06236497 100644
--- a/src/test/java/org/lmdbjava/DbiFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
@@ -15,83 +15,46 @@
  */
 package org.lmdbjava;
 
-import static org.assertj.core.api.Assertions.assertThat;
-
 import java.util.Arrays;
-import java.util.HashSet;
-import org.junit.jupiter.api.Test;
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class DbiFlagSetTest extends AbstractFlagSetTest<DbiFlags, DbiFlagSet> {
+
+    @Override
+    List<DbiFlags> getAllFlags() {
+        return Arrays.stream(DbiFlags.values())
+            .collect(Collectors.toList());
+    }
 
-public class DbiFlagSetTest {
+    @Override
+    DbiFlagSet getEmptyFlagSet() {
+        return DbiFlagSet.empty();
+    }
 
-    @Test
-    public void testEmpty() {
-        final DbiFlagSet dbiFlagSet = DbiFlagSet.empty();
-        assertThat(dbiFlagSet.getMask()).isEqualTo(0);
-        assertThat(dbiFlagSet.size()).isEqualTo(0);
-        assertThat(dbiFlagSet.isEmpty()).isEqualTo(true);
-        assertThat(dbiFlagSet.isSet(DbiFlags.MDB_REVERSEDUP)).isEqualTo(false);
-        final DbiFlagSet dbiFlagSet2 = DbiFlagSet.builder()
-            .build();
-        assertThat(dbiFlagSet).isEqualTo(dbiFlagSet2);
-        assertThat(dbiFlagSet).isNotEqualTo(DbiFlagSet.of(DbiFlags.MDB_CREATE));
-        assertThat(dbiFlagSet).isNotEqualTo(DbiFlagSet.of(DbiFlags.MDB_CREATE, DbiFlags.MDB_DUPSORT));
-        assertThat(dbiFlagSet).isNotEqualTo(DbiFlagSet.builder()
-            .setFlag(DbiFlags.MDB_CREATE)
-            .setFlag(DbiFlags.MDB_DUPFIXED)
-            .build());
+    @Override
+    AbstractFlagSet.Builder<DbiFlags, DbiFlagSet> getBuilder() {
+        return DbiFlagSet.builder();
     }
 
-    @Test
-    public void testOf() {
-        final DbiFlags dbiFlag = DbiFlags.MDB_CREATE;
-        final DbiFlagSet dbiFlagSet = DbiFlagSet.of(dbiFlag);
-        assertThat(dbiFlagSet.getMask()).isEqualTo(MaskedFlag.mask(dbiFlag));
-        assertThat(dbiFlagSet.size()).isEqualTo(1);
-        assertThat(dbiFlagSet.isSet(DbiFlags.MDB_REVERSEDUP)).isEqualTo(false);
-        for (DbiFlags flag : dbiFlagSet) {
-            assertThat(dbiFlagSet.isSet(flag)).isEqualTo(true);
-        }
+    @Override
+    Class<DbiFlags> getFlagType() {
+        return DbiFlags.class;
+    }
 
-        final DbiFlagSet dbiFlagSet2 = DbiFlagSet.builder()
-            .setFlag(dbiFlag)
-            .build();
-        assertThat(dbiFlagSet).isEqualTo(dbiFlagSet2);
+    @Override
+    DbiFlagSet getFlagSet(Collection<DbiFlags> flags) {
+        return DbiFlagSet.of(flags);
     }
 
-    @Test
-    public void testOf2() {
-        final DbiFlags dbiFlag1 = DbiFlags.MDB_CREATE;
-        final DbiFlags dbiFlag2 = DbiFlags.MDB_INTEGERKEY;
-        final DbiFlagSet dbiFlagSet = DbiFlagSet.of(dbiFlag1, dbiFlag2);
-        assertThat(dbiFlagSet.getMask()).isEqualTo(MaskedFlag.mask(dbiFlag1, dbiFlag2));
-        assertThat(dbiFlagSet.size()).isEqualTo(2);
-        assertThat(dbiFlagSet.isSet(DbiFlags.MDB_REVERSEDUP)).isEqualTo(false);
-        for (DbiFlags flag : dbiFlagSet) {
-            assertThat(dbiFlagSet.isSet(flag)).isEqualTo(true);
-        }
+    @Override
+    DbiFlagSet getFlagSet(DbiFlags[] flags) {
+        return DbiFlagSet.of(flags);
     }
 
-    @Test
-    public void testBuilder() {
-        final DbiFlags dbiFlag1 = DbiFlags.MDB_CREATE;
-        final DbiFlags dbiFlag2 = DbiFlags.MDB_INTEGERKEY;
-        final DbiFlagSet dbiFlagSet = DbiFlagSet.builder()
-                .setFlag(dbiFlag1)
-                .setFlag(dbiFlag2)
-                .build();
-        assertThat(dbiFlagSet.getMask()).isEqualTo(MaskedFlag.mask(dbiFlag1, dbiFlag2));
-        assertThat(dbiFlagSet.size()).isEqualTo(2);
-        assertThat(dbiFlagSet.isSet(DbiFlags.MDB_REVERSEDUP)).isEqualTo(false);
-        for (DbiFlags flag : dbiFlagSet) {
-            assertThat(dbiFlagSet.isSet(flag)).isEqualTo(true);
-        }
-        final DbiFlagSet dbiFlagSet2 = DbiFlagSet.builder()
-                .withFlags(dbiFlag1, dbiFlag2)
-                .build();
-        final DbiFlagSet dbiFlagSet3 = DbiFlagSet.builder()
-                .withFlags(new HashSet<>(Arrays.asList(dbiFlag1, dbiFlag2)))
-                .build();
-        assertThat(dbiFlagSet).isEqualTo(dbiFlagSet2);
-        assertThat(dbiFlagSet).isEqualTo(dbiFlagSet3);
+    @Override
+    DbiFlagSet getFlagSet(DbiFlags flag) {
+        return DbiFlagSet.of(flag);
     }
 }
diff --git a/src/test/java/org/lmdbjava/EnvFlagSetTest.java b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
index 485aae13..98a033f5 100644
--- a/src/test/java/org/lmdbjava/EnvFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
@@ -15,83 +15,46 @@
  */
 package org.lmdbjava;
 
-import static org.assertj.core.api.Assertions.assertThat;
-
 import java.util.Arrays;
-import java.util.HashSet;
-import org.junit.jupiter.api.Test;
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class EnvFlagSetTest extends AbstractFlagSetTest<EnvFlags, EnvFlagSet> {
+
+    @Override
+    List<EnvFlags> getAllFlags() {
+        return Arrays.stream(EnvFlags.values())
+            .collect(Collectors.toList());
+    }
 
-public class EnvFlagSetTest {
+    @Override
+    EnvFlagSet getEmptyFlagSet() {
+        return EnvFlagSet.empty();
+    }
 
-    @Test
-    public void testEmpty() {
-        final EnvFlagSet envFlagSet = EnvFlagSet.empty();
-        assertThat(envFlagSet.getMask()).isEqualTo(0);
-        assertThat(envFlagSet.size()).isEqualTo(0);
-        assertThat(envFlagSet.isEmpty()).isEqualTo(true);
-        assertThat(envFlagSet.isSet(EnvFlags.MDB_NOSUBDIR)).isEqualTo(false);
-        final EnvFlagSet envFlagSet2 = EnvFlagSet.builder()
-            .build();
-        assertThat(envFlagSet).isEqualTo(envFlagSet2);
-        assertThat(envFlagSet).isNotEqualTo(EnvFlagSet.of(EnvFlags.MDB_FIXEDMAP));
-        assertThat(envFlagSet).isNotEqualTo(EnvFlagSet.of(EnvFlags.MDB_FIXEDMAP, EnvFlags.MDB_NORDAHEAD));
-        assertThat(envFlagSet).isNotEqualTo(EnvFlagSet.builder()
-            .setFlag(EnvFlags.MDB_FIXEDMAP)
-            .setFlag(EnvFlags.MDB_NORDAHEAD)
-            .build());
+    @Override
+    AbstractFlagSet.Builder<EnvFlags, EnvFlagSet> getBuilder() {
+        return EnvFlagSet.builder();
     }
 
-    @Test
-    public void testOf() {
-        final EnvFlags envFlag = EnvFlags.MDB_FIXEDMAP;
-        final EnvFlagSet envFlagSet = EnvFlagSet.of(envFlag);
-        assertThat(envFlagSet.getMask()).isEqualTo(MaskedFlag.mask(envFlag));
-        assertThat(envFlagSet.size()).isEqualTo(1);
-        assertThat(envFlagSet.isSet(EnvFlags.MDB_NOSUBDIR)).isEqualTo(false);
-        for (EnvFlags flag : envFlagSet) {
-            assertThat(envFlagSet.isSet(flag)).isEqualTo(true);
-        }
+    @Override
+    EnvFlagSet getFlagSet(Collection<EnvFlags> flags) {
+        return EnvFlagSet.of(flags);
+    }
 
-        final EnvFlagSet envFlagSet2 = EnvFlagSet.builder()
-            .setFlag(envFlag)
-            .build();
-        assertThat(envFlagSet).isEqualTo(envFlagSet2);
+    @Override
+    EnvFlagSet getFlagSet(EnvFlags[] flags) {
+        return EnvFlagSet.of(flags);
     }
 
-    @Test
-    public void testOf2() {
-        final EnvFlags envFlag1 = EnvFlags.MDB_FIXEDMAP;
-        final EnvFlags envFlag2 = EnvFlags.MDB_NORDAHEAD;
-        final EnvFlagSet envFlagSet = EnvFlagSet.of(envFlag1, envFlag2);
-        assertThat(envFlagSet.getMask()).isEqualTo(MaskedFlag.mask(envFlag1, envFlag2));
-        assertThat(envFlagSet.size()).isEqualTo(2);
-        assertThat(envFlagSet.isSet(EnvFlags.MDB_WRITEMAP)).isEqualTo(false);
-        for (EnvFlags flag : envFlagSet) {
-            assertThat(envFlagSet.isSet(flag)).isEqualTo(true);
-        }
+    @Override
+    EnvFlagSet getFlagSet(EnvFlags flag) {
+        return EnvFlagSet.of(flag);
     }
 
-    @Test
-    public void testBuilder() {
-        final EnvFlags envFlag1 = EnvFlags.MDB_FIXEDMAP;
-        final EnvFlags envFlag2 = EnvFlags.MDB_NORDAHEAD;
-        final EnvFlagSet envFlagSet = EnvFlagSet.builder()
-                .setFlag(envFlag1)
-                .setFlag(envFlag2)
-                .build();
-        assertThat(envFlagSet.getMask()).isEqualTo(MaskedFlag.mask(envFlag1, envFlag2));
-        assertThat(envFlagSet.size()).isEqualTo(2);
-        assertThat(envFlagSet.isSet(EnvFlags.MDB_NOTLS)).isEqualTo(false);
-        for (EnvFlags flag : envFlagSet) {
-            assertThat(envFlagSet.isSet(flag)).isEqualTo(true);
-        }
-        final EnvFlagSet envFlagSet2 = EnvFlagSet.builder()
-                .withFlags(envFlag1, envFlag2)
-                .build();
-        final EnvFlagSet envFlagSet3 = EnvFlagSet.builder()
-                .withFlags(new HashSet<>(Arrays.asList(envFlag1, envFlag2)))
-                .build();
-        assertThat(envFlagSet).isEqualTo(envFlagSet2);
-        assertThat(envFlagSet).isEqualTo(envFlagSet3);
+    @Override
+    Class<EnvFlags> getFlagType() {
+        return EnvFlags.class;
     }
 }
diff --git a/src/test/java/org/lmdbjava/PutFlagSetTest.java b/src/test/java/org/lmdbjava/PutFlagSetTest.java
index 23cf65a4..9991b870 100644
--- a/src/test/java/org/lmdbjava/PutFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/PutFlagSetTest.java
@@ -15,89 +15,51 @@
  */
 package org.lmdbjava;
 
-import static org.assertj.core.api.Assertions.assertThat;
-
 import java.time.Duration;
 import java.time.Instant;
 import java.util.Arrays;
-import java.util.HashSet;
+import java.util.Collection;
 import java.util.List;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 import org.junit.jupiter.api.Test;
 
-public class PutFlagSetTest {
+public class PutFlagSetTest extends AbstractFlagSetTest<PutFlags, PutFlagSet> {
 
-  @Test
-  public void testEmpty() {
-    final PutFlagSet putFlagSet = PutFlagSet.empty();
-    assertThat(putFlagSet.getMask()).isEqualTo(0);
-    assertThat(putFlagSet.size()).isEqualTo(0);
-    assertThat(putFlagSet.isEmpty()).isEqualTo(true);
-    assertThat(putFlagSet.isSet(PutFlags.MDB_MULTIPLE)).isEqualTo(false);
-    final PutFlagSet putFlagSet2 = PutFlagSet.builder()
-        .build();
-    assertThat(putFlagSet).isEqualTo(putFlagSet2);
-    assertThat(putFlagSet).isNotEqualTo(PutFlagSet.of(PutFlags.MDB_APPEND));
-    assertThat(putFlagSet).isNotEqualTo(PutFlagSet.of(PutFlags.MDB_APPEND, PutFlags.MDB_RESERVE));
-    assertThat(putFlagSet).isNotEqualTo(PutFlagSet.builder()
-        .setFlag(PutFlags.MDB_CURRENT)
-        .setFlag(PutFlags.MDB_MULTIPLE)
-        .build());
+  @Override
+  List<PutFlags> getAllFlags() {
+    return Arrays.stream(PutFlags.values())
+        .collect(Collectors.toList());
   }
 
-  @Test
-  public void testOf() {
-    final PutFlags putFlag = PutFlags.MDB_APPEND;
-    final PutFlagSet putFlagSet = PutFlagSet.of(putFlag);
-    assertThat(putFlagSet.getMask()).isEqualTo(MaskedFlag.mask(putFlag));
-    assertThat(putFlagSet.size()).isEqualTo(1);
-    assertThat(putFlagSet.isSet(PutFlags.MDB_MULTIPLE)).isEqualTo(false);
-    for (PutFlags flag : putFlagSet) {
-      assertThat(putFlagSet.isSet(flag)).isEqualTo(true);
-    }
+  @Override
+  PutFlagSet getEmptyFlagSet() {
+    return PutFlagSet.empty();
+  }
 
-    final PutFlagSet putFlagSet2 = PutFlagSet.builder()
-        .setFlag(putFlag)
-        .build();
-    assertThat(putFlagSet).isEqualTo(putFlagSet2);
+  @Override
+  AbstractFlagSet.Builder<PutFlags, PutFlagSet> getBuilder() {
+    return PutFlagSet.builder();
   }
 
-  @Test
-  public void testOf2() {
-    final PutFlags putFlag1 = PutFlags.MDB_APPEND;
-    final PutFlags putFlag2 = PutFlags.MDB_NOOVERWRITE;
-    final PutFlagSet putFlagSet = PutFlagSet.of(putFlag1, putFlag2);
-    assertThat(putFlagSet.getMask()).isEqualTo(MaskedFlag.mask(putFlag1, putFlag2));
-    assertThat(putFlagSet.size()).isEqualTo(2);
-    assertThat(putFlagSet.isSet(PutFlags.MDB_MULTIPLE)).isEqualTo(false);
-    for (PutFlags flag : putFlagSet) {
-      assertThat(putFlagSet.isSet(flag)).isEqualTo(true);
-    }
+  @Override
+  PutFlagSet getFlagSet(Collection<PutFlags> flags) {
+    return PutFlagSet.of(flags);
   }
 
-  @Test
-  public void testBuilder() {
-    final PutFlags putFlag1 = PutFlags.MDB_APPEND;
-    final PutFlags putFlag2 = PutFlags.MDB_NOOVERWRITE;
-    final PutFlagSet putFlagSet = PutFlagSet.builder()
-        .setFlag(putFlag1)
-        .setFlag(putFlag2)
-        .build();
-    assertThat(putFlagSet.getMask()).isEqualTo(MaskedFlag.mask(putFlag1, putFlag2));
-    assertThat(putFlagSet.size()).isEqualTo(2);
-    assertThat(putFlagSet.isSet(PutFlags.MDB_MULTIPLE)).isEqualTo(false);
-    for (PutFlags flag : putFlagSet) {
-      assertThat(putFlagSet.isSet(flag)).isEqualTo(true);
-    }
-    final PutFlagSet putFlagSet2 = PutFlagSet.builder()
-        .withFlags(putFlag1, putFlag2)
-        .build();
-    final PutFlagSet putFlagSet3 = PutFlagSet.builder()
-        .withFlags(new HashSet<>(Arrays.asList(putFlag1, putFlag2)))
-        .build();
-    assertThat(putFlagSet).isEqualTo(putFlagSet2);
-    assertThat(putFlagSet).isEqualTo(putFlagSet3);
+  @Override
+  PutFlagSet getFlagSet(PutFlags[] flags) {
+    return PutFlagSet.of(flags);
+  }
+
+  @Override
+  PutFlagSet getFlagSet(PutFlags flag) {
+    return PutFlagSet.of(flag);
+  }
+
+  @Override
+  Class<PutFlags> getFlagType() {
+    return PutFlags.class;
   }
 
   @Test
diff --git a/src/test/java/org/lmdbjava/TxnFlagSetTest.java b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
index 58f75aa6..87455cb7 100644
--- a/src/test/java/org/lmdbjava/TxnFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
@@ -15,82 +15,46 @@
  */
 package org.lmdbjava;
 
-import static org.assertj.core.api.Assertions.assertThat;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Collectors;
 
-import java.util.Collections;
-import java.util.HashSet;
-import org.junit.jupiter.api.Test;
+public class TxnFlagSetTest extends AbstractFlagSetTest<TxnFlags, TxnFlagSet> {
 
-public class TxnFlagSetTest {
+  @Override
+  List<TxnFlags> getAllFlags() {
+    return Arrays.stream(TxnFlags.values())
+        .collect(Collectors.toList());
+  }
 
-  @Test
-  void testSingleEnum() {
-    final TxnFlagSet txnFlagSet = TxnFlags.MDB_RDONLY_TXN;
-    assertThat(txnFlagSet.getMask()).isEqualTo(MaskedFlag.mask(TxnFlags.MDB_RDONLY_TXN));
-    assertThat(txnFlagSet.size()).isEqualTo(1);
-    for (TxnFlags flag : txnFlagSet) {
-      assertThat(txnFlagSet.isSet(flag)).isEqualTo(true);
-    }
+  @Override
+  TxnFlagSet getEmptyFlagSet() {
+    return TxnFlagSet.empty();
+  }
 
-    final TxnFlagSet txnFlagSet2 = TxnFlagSet.builder()
-        .setFlag(TxnFlags.MDB_RDONLY_TXN)
-        .build();
-    assertThat(txnFlagSet2.getFlags()).containsExactlyElementsOf(txnFlagSet.getFlags());
-    assertThat(txnFlagSet.areAnySet(TxnFlags.MDB_RDONLY_TXN)).isTrue();
-    assertThat(txnFlagSet.areAnySet(TxnFlagSet.empty())).isFalse();
+  @Override
+  AbstractFlagSet.Builder<TxnFlags, TxnFlagSet> getBuilder() {
+    return TxnFlagSet.builder();
   }
 
-  @Test
-  public void testEmpty() {
-    final TxnFlagSet txnFlagSet = TxnFlagSet.empty();
-    assertThat(txnFlagSet.getMask()).isEqualTo(0);
-    assertThat(txnFlagSet.size()).isEqualTo(0);
-    assertThat(txnFlagSet.isEmpty()).isEqualTo(true);
-    assertThat(txnFlagSet.isSet(TxnFlags.MDB_RDONLY_TXN)).isEqualTo(false);
-    final TxnFlagSet txnFlagSet2 = TxnFlagSet.builder()
-        .build();
-    assertThat(txnFlagSet).isEqualTo(txnFlagSet2);
-    assertThat(txnFlagSet).isNotEqualTo(TxnFlagSet.of(TxnFlags.MDB_RDONLY_TXN));
-    assertThat(txnFlagSet).isNotEqualTo(TxnFlagSet.builder()
-        .setFlag(TxnFlags.MDB_RDONLY_TXN)
-        .build());
+  @Override
+  TxnFlagSet getFlagSet(Collection<TxnFlags> flags) {
+    return TxnFlagSet.of(flags);
   }
 
-  @Test
-  public void testOf() {
-    final TxnFlags txnFlag = TxnFlags.MDB_RDONLY_TXN;
-    final TxnFlagSet txnFlagSet = TxnFlagSet.of(txnFlag);
-    assertThat(txnFlagSet.getMask()).isEqualTo(MaskedFlag.mask(txnFlag));
-    assertThat(txnFlagSet.size()).isEqualTo(1);
-    for (TxnFlags flag : txnFlagSet) {
-      assertThat(txnFlagSet.isSet(flag)).isEqualTo(true);
-    }
+  @Override
+  TxnFlagSet getFlagSet(TxnFlags[] flags) {
+    return TxnFlagSet.of(flags);
+  }
 
-    final TxnFlagSet txnFlagSet2 = TxnFlagSet.builder()
-        .setFlag(txnFlag)
-        .build();
-    assertThat(txnFlagSet).isEqualTo(txnFlagSet2);
+  @Override
+  TxnFlagSet getFlagSet(TxnFlags flag) {
+    return TxnFlagSet.of(flag);
   }
 
-  @Test
-  public void testBuilder() {
-    final TxnFlags txnFlag1 = TxnFlags.MDB_RDONLY_TXN;
-    final TxnFlagSet txnFlagSet = TxnFlagSet.builder()
-        .setFlag(txnFlag1)
-        .build();
-    assertThat(txnFlagSet.getMask()).isEqualTo(MaskedFlag.mask(txnFlag1));
-    assertThat(txnFlagSet.size()).isEqualTo(1);
-    assertThat(txnFlagSet.isSet(TxnFlags.MDB_RDONLY_TXN)).isEqualTo(true);
-    for (TxnFlags flag : txnFlagSet) {
-      assertThat(txnFlagSet.isSet(flag)).isEqualTo(true);
-    }
-    final TxnFlagSet txnFlagSet2 = TxnFlagSet.builder()
-        .withFlags(txnFlag1)
-        .build();
-    final TxnFlagSet txnFlagSet3 = TxnFlagSet.builder()
-        .withFlags(new HashSet<>(Collections.singletonList(txnFlag1)))
-        .build();
-    assertThat(txnFlagSet).isEqualTo(txnFlagSet2);
-    assertThat(txnFlagSet).isEqualTo(txnFlagSet3);
+  @Override
+  Class<TxnFlags> getFlagType() {
+    return TxnFlags.class;
   }
 }

From 7a6910b545363fabaa17b9a6f4017671c72968e6 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Thu, 6 Nov 2025 11:33:35 +0000
Subject: [PATCH 263/322] Add licence header

---
 .../java/org/lmdbjava/AbstractFlagSetTest.java    | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
index e09d72c6..298ee2fe 100644
--- a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
@@ -1,3 +1,18 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package org.lmdbjava;
 
 import static org.assertj.core.api.Assertions.assertThat;

From 167cdadf3059ad0626e13349a5f84a65d8f454be Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Thu, 6 Nov 2025 11:35:58 +0000
Subject: [PATCH 264/322] Rename buildDbi to createDbi to be consistent with
 Env.create()

---
 src/main/java/org/lmdbjava/Env.java           | 24 +++++++++----------
 .../org/lmdbjava/ByteBufferProxyTest.java     |  2 +-
 .../CursorIterableIntegerDupTest.java         | 10 ++++----
 .../CursorIterableIntegerKeyTest.java         | 10 ++++----
 .../org/lmdbjava/CursorIterablePerfTest.java  |  6 ++---
 .../java/org/lmdbjava/CursorIterableTest.java | 10 ++++----
 .../java/org/lmdbjava/DbiBuilderTest.java     | 12 +++++-----
 src/test/java/org/lmdbjava/DbiTest.java       |  6 ++---
 8 files changed, 40 insertions(+), 40 deletions(-)

diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 542b67c3..b414101a 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -282,7 +282,7 @@ public boolean isReadOnly() {
    *
    * @return A new builder instance for creating/opening a {@link Dbi}.
    */
-  public DbiBuilder<T> buildDbi() {
+  public DbiBuilder<T> createDbi() {
     return new DbiBuilder<>(this, proxy, readOnly);
   }
 
@@ -290,7 +290,7 @@ public DbiBuilder<T> buildDbi() {
    * Convenience method that opens a {@link Dbi} with a UTF-8 database name and default
    * {@link Comparator} that is not invoked from native code.
    * <p>
-   * For more options when opening a {@link Dbi} see {@link Env#buildDbi()}.
+   * For more options when opening a {@link Dbi} see {@link Env#createDbi()}.
    * </p>
    * @param name       name of the database (or null if no name is required)
    * @param dbiFlagSet Flags to open the database with
@@ -309,7 +309,7 @@ public Dbi<T> openDbi(final String name, final DbiFlagSet dbiFlagSet) {
    * Convenience method that opens a {@link Dbi} with a default
    * {@link Comparator} that is not invoked from native code.
    * <p>
-   * For more options when opening a {@link Dbi} see {@link Env#buildDbi()}.
+   * For more options when opening a {@link Dbi} see {@link Env#createDbi()}.
    * </p>
    * @param name       name of the database (or null if no name is required)
    * @param dbiFlagSet Flags to open the database with
@@ -328,7 +328,7 @@ public Dbi<T> openDbi(final byte[] name,
    * @param name  name of the database (or null if no name is required)
    * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#buildDbi()} or {@link Env#openDbi(String, DbiFlagSet)}
+   * @deprecated Instead use {@link Env#createDbi()} or {@link Env#openDbi(String, DbiFlagSet)}
    * Convenience method that opens a {@link Dbi} with a UTF-8 database name and default {@link
    * Comparator} that is not invoked from native code.
    */
@@ -344,7 +344,7 @@ public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
    *                   comparator will be used.
    * @param flags      to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#buildDbi()}
+   * @deprecated Instead use {@link Env#createDbi()}
    * Convenience method that opens a {@link Dbi} with a UTF-8 database name and associated {@link
    * Comparator} for use by {@link CursorIterable} when comparing start/stop keys.
    *
@@ -368,7 +368,7 @@ public Dbi<T> openDbi(final String name,
    * @param nativeCb   whether LMDB native code calls back to the Java comparator
    * @param flags      to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#buildDbi()}
+   * @deprecated Instead use {@link Env#createDbi()}
    * Convenience method that opens a {@link Dbi} with a UTF-8 database name and associated {@link
    * Comparator}. The comparator will be used by {@link CursorIterable} when comparing start/stop
    * keys as a minimum. If nativeCb is {@code true}, this comparator will also be called by LMDB to
@@ -388,7 +388,7 @@ public Dbi<T> openDbi(final String name,
    * @param name  name of the database (or null if no name is required)
    * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#buildDbi()}
+   * @deprecated Instead use {@link Env#createDbi()}
    * <hr>
    * Convenience method that opens a {@link Dbi} with a default {@link Comparator} that is not
    * invoked from native code.
@@ -396,7 +396,7 @@ public Dbi<T> openDbi(final String name,
   @Deprecated()
   public Dbi<T> openDbi(final byte[] name,
                         final DbiFlags... flags) {
-    return buildDbi()
+    return createDbi()
         .setDbName(name)
         .withDefaultComparator()
         .setDbiFlags(flags)
@@ -408,7 +408,7 @@ public Dbi<T> openDbi(final byte[] name,
    * @param comparator custom comparator callback (or null to use LMDB default)
    * @param flags      to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#buildDbi()}
+   * @deprecated Instead use {@link Env#createDbi()}
    * <hr>
    * Convenience method that opens a {@link Dbi} with an associated {@link Comparator} that is not
    * invoked from native code.
@@ -418,7 +418,7 @@ public Dbi<T> openDbi(final byte[] name,
                         final Comparator<T> comparator,
                         final DbiFlags... flags) {
     requireNonNull(comparator);
-    return buildDbi()
+    return createDbi()
         .setDbName(name)
         .withIteratorComparator(ignored -> comparator)
         .setDbiFlags(flags)
@@ -431,7 +431,7 @@ public Dbi<T> openDbi(final byte[] name,
    * @param nativeCb   whether native code calls back to the Java comparator
    * @param flags      to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#buildDbi()}
+   * @deprecated Instead use {@link Env#createDbi()}
    * <hr>
    * Convenience method that opens a {@link Dbi} with an associated {@link Comparator} that may be
    * invoked from native code if specified.
@@ -459,7 +459,7 @@ public Dbi<T> openDbi(
    * @param nativeCb   whether native LMDB code should call back to the Java comparator
    * @param flags      to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#buildDbi()}
+   * @deprecated Instead use {@link Env#createDbi()}
    * Open the {@link Dbi} using the passed {@link Txn}.
    *
    * <p>The caller must commit the transaction after this method returns in order to retain the
diff --git a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
index a91fbf75..d9312cce 100644
--- a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
+++ b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
@@ -67,7 +67,7 @@ void buffersMustBeDirect() {
                 try (Env<ByteBuffer> env = create()
                     .setMaxReaders(1)
                     .open(dir)) {
-                  final Dbi<ByteBuffer> db = env.buildDbi()
+                  final Dbi<ByteBuffer> db = env.createDbi()
                       .setDbName(DB_1)
                       .withDefaultComparator()
                       .setDbiFlags(MDB_CREATE)
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
index 1098ca5c..091f5768 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
@@ -337,7 +337,7 @@ public void openClosedBackwardTestWithGuava() {
           return guava.compare(array1, array2);
         };
 
-    final Dbi<ByteBuffer> guavaDbi = env.buildDbi()
+    final Dbi<ByteBuffer> guavaDbi = env.createDbi()
         .setDbName(DB_1).withIteratorComparator(ignored -> comparator)
         .setDbiFlags(MDB_CREATE)
         .open();
@@ -529,25 +529,25 @@ static class MyArgumentProvider implements ArgumentsProvider {
     public Stream<? extends Arguments> provideArguments(ParameterDeclarations parameters,
                                                         ExtensionContext context) throws Exception {
       final DbiFactory defaultComparatorDb = new DbiFactory("defaultComparator", env ->
-          env.buildDbi()
+          env.createDbi()
               .setDbName(DB_1)
               .withDefaultComparator()
               .setDbiFlags(DBI_FLAGS)
               .open());
       final DbiFactory nativeComparatorDb = new DbiFactory("nativeComparator", env ->
-          env.buildDbi()
+          env.createDbi()
               .setDbName(DB_2)
               .withNativeComparator()
               .setDbiFlags(DBI_FLAGS)
               .open());
       final DbiFactory callbackComparatorDb = new DbiFactory("callbackComparator", env ->
-          env.buildDbi()
+          env.createDbi()
               .setDbName(DB_3)
               .withCallbackComparator(MyArgumentProvider::buildComparator)
               .setDbiFlags(DBI_FLAGS)
               .open());
       final DbiFactory iteratorComparatorDb = new DbiFactory("iteratorComparator", env ->
-          env.buildDbi()
+          env.createDbi()
               .setDbName(DB_4)
               .withIteratorComparator(MyArgumentProvider::buildComparator)
               .setDbiFlags(DBI_FLAGS)
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
index 007b5e29..e4f89302 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
@@ -432,7 +432,7 @@ public void openClosedBackwardTestWithGuava() {
           bb2.reset();
           return guava.compare(array1, array2);
         };
-    final Dbi<ByteBuffer> guavaDbi = env.buildDbi()
+    final Dbi<ByteBuffer> guavaDbi = env.createDbi()
         .setDbName(DB_1)
         .withIteratorComparator(ignored -> comparator)
         .setDbiFlags(MDB_CREATE)
@@ -602,25 +602,25 @@ static class MyArgumentProvider implements ArgumentsProvider {
     public Stream<? extends Arguments> provideArguments(ParameterDeclarations parameters,
                                                         ExtensionContext context) throws Exception {
       final DbiFactory defaultComparatorDb = new DbiFactory("defaultComparator", env ->
-          env.buildDbi()
+          env.createDbi()
               .setDbName(DB_1)
               .withDefaultComparator()
               .setDbiFlags(DBI_FLAGS)
               .open());
       final DbiFactory nativeComparatorDb = new DbiFactory("nativeComparator", env ->
-          env.buildDbi()
+          env.createDbi()
               .setDbName(DB_2)
               .withNativeComparator()
               .setDbiFlags(DBI_FLAGS)
               .open());
       final DbiFactory callbackComparatorDb = new DbiFactory("callbackComparator", env ->
-          env.buildDbi()
+          env.createDbi()
               .setDbName(DB_3)
               .withCallbackComparator(MyArgumentProvider::buildComparator)
               .setDbiFlags(DBI_FLAGS)
               .open());
       final DbiFactory iteratorComparatorDb = new DbiFactory("iteratorComparator", env ->
-          env.buildDbi()
+          env.createDbi()
               .setDbName(DB_4)
               .withIteratorComparator(MyArgumentProvider::buildComparator)
               .setDbiFlags(DBI_FLAGS)
diff --git a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
index 80555966..cc91a8fb 100644
--- a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
@@ -59,20 +59,20 @@ public void before() throws IOException {
 
     final DbiFlagSet dbiFlagSet = MDB_CREATE;
     // Use a java comparator for start/stop keys only
-    Dbi<ByteBuffer> dbJavaComparator = env.buildDbi()
+    Dbi<ByteBuffer> dbJavaComparator = env.createDbi()
         .setDbName("JavaComparator")
         .withDefaultComparator()
         .setDbiFlags(dbiFlagSet)
         .open();
     // Use LMDB comparator for start/stop keys
-    Dbi<ByteBuffer> dbLmdbComparator = env.buildDbi()
+    Dbi<ByteBuffer> dbLmdbComparator = env.createDbi()
         .setDbName("LmdbComparator")
         .withNativeComparator()
         .setDbiFlags(dbiFlagSet)
         .open();
 
     // Use a java comparator for start/stop keys and as a callback comparator
-    Dbi<ByteBuffer> dbCallbackComparator = env.buildDbi()
+    Dbi<ByteBuffer> dbCallbackComparator = env.createDbi()
         .setDbName("CallBackComparator")
         .withCallbackComparator(bufferProxy::getComparator)
         .setDbiFlags(dbiFlagSet)
diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index e48f1e69..b991b809 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -308,7 +308,7 @@ void openClosedBackwardTestWithGuava() {
           bb2.reset();
           return guava.compare(array1, array2);
         };
-    final Dbi<ByteBuffer> guavaDbi = env.buildDbi()
+    final Dbi<ByteBuffer> guavaDbi = env.createDbi()
         .setDbName(DB_1)
         .withDefaultComparator()
         .setDbiFlags(MDB_CREATE)
@@ -537,25 +537,25 @@ static class MyArgumentProvider implements ArgumentsProvider {
     public Stream<? extends Arguments> provideArguments(ParameterDeclarations parameters,
                                                         ExtensionContext context) throws Exception {
       final DbiFactory defaultComparatorDb = new DbiFactory("defaultComparator", env ->
-          env.buildDbi()
+          env.createDbi()
               .setDbName(DB_1)
               .withDefaultComparator()
               .setDbiFlags(DBI_FLAGS)
               .open());
       final DbiFactory nativeComparatorDb = new DbiFactory("nativeComparator", env ->
-          env.buildDbi()
+          env.createDbi()
               .setDbName(DB_2)
               .withNativeComparator()
               .setDbiFlags(DBI_FLAGS)
               .open());
       final DbiFactory callbackComparatorDb = new DbiFactory("callbackComparator", env ->
-          env.buildDbi()
+          env.createDbi()
               .setDbName(DB_3)
               .withCallbackComparator(BUFFER_PROXY::getComparator)
               .setDbiFlags(DBI_FLAGS)
               .open());
       final DbiFactory iteratorComparatorDb = new DbiFactory("iteratorComparator", env ->
-          env.buildDbi()
+          env.createDbi()
               .setDbName(DB_4)
               .withIteratorComparator(BUFFER_PROXY::getComparator)
               .setDbiFlags(DBI_FLAGS)
diff --git a/src/test/java/org/lmdbjava/DbiBuilderTest.java b/src/test/java/org/lmdbjava/DbiBuilderTest.java
index d01f6417..87b1db46 100644
--- a/src/test/java/org/lmdbjava/DbiBuilderTest.java
+++ b/src/test/java/org/lmdbjava/DbiBuilderTest.java
@@ -57,7 +57,7 @@ public void after() {
 
   @Test
   public void unnamed() {
-    final Dbi<ByteBuffer> dbi = env.buildDbi()
+    final Dbi<ByteBuffer> dbi = env.createDbi()
         .withoutDbName()
         .withDefaultComparator()
         .setDbiFlags(DbiFlags.MDB_CREATE)
@@ -70,7 +70,7 @@ public void unnamed() {
 
   @Test
   public void named() {
-    final Dbi<ByteBuffer> dbi = env.buildDbi()
+    final Dbi<ByteBuffer> dbi = env.createDbi()
         .setDbName("foo")
         .withDefaultComparator()
         .setDbiFlags(DbiFlags.MDB_CREATE)
@@ -89,7 +89,7 @@ public void named() {
 
   @Test
   public void named2() {
-    final Dbi<ByteBuffer> dbi = env.buildDbi()
+    final Dbi<ByteBuffer> dbi = env.createDbi()
         .setDbName("foo".getBytes(StandardCharsets.US_ASCII))
         .withDefaultComparator()
         .setDbiFlags(DbiFlags.MDB_CREATE)
@@ -108,7 +108,7 @@ public void named2() {
 
   @Test
   public void nativeComparator() {
-    final Dbi<ByteBuffer> dbi = env.buildDbi()
+    final Dbi<ByteBuffer> dbi = env.createDbi()
         .setDbName("foo")
         .withNativeComparator()
         .addDbiFlags(DbiFlags.MDB_CREATE)
@@ -131,7 +131,7 @@ public void callback() {
       }
     };
 
-    final Dbi<ByteBuffer> dbi = env.buildDbi()
+    final Dbi<ByteBuffer> dbi = env.createDbi()
         .setDbName("foo")
         .withCallbackComparator(ignored -> comparator)
         .addDbiFlags(DbiFlags.MDB_CREATE)
@@ -163,7 +163,7 @@ public void callback() {
 
   @Test
   public void flags() {
-    final Dbi<ByteBuffer> dbi = env.buildDbi()
+    final Dbi<ByteBuffer> dbi = env.createDbi()
         .setDbName("foo")
         .withDefaultComparator()
         .setDbiFlags(DbiFlags.MDB_DUPSORT, DbiFlags.MDB_DUPFIXED) // Will get overwritten
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 6d86bd85..2d84b467 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -109,7 +109,7 @@ void afterEach() {
   void close() {
     assertThatThrownBy(
         () -> {
-          final Dbi<ByteBuffer> db = env.buildDbi()
+          final Dbi<ByteBuffer> db = env.createDbi()
               .setDbName(DB_1)
               .withDefaultComparator()
               .addDbiFlag(MDB_CREATE)
@@ -152,7 +152,7 @@ private <T> void doCustomComparator(
       Comparator<T> comparator,
       IntFunction<T> serializer,
       ToIntFunction<T> deserializer) {
-    final Dbi<T> db = env.buildDbi()
+    final Dbi<T> db = env.createDbi()
         .setDbName(DB_1)
         .withCallbackComparator(ignored -> comparator)
         .setDbiFlags(MDB_CREATE)
@@ -203,7 +203,7 @@ private <T> void doDbiWithComparatorThreadSafety(
       ToIntFunction<T> deserializer) {
     final DbiFlagSet flags = DbiFlagSet.of(MDB_CREATE, MDB_INTEGERKEY);
     final Comparator<T> comparator = comparatorSupplier.get();
-    final Dbi<T> db = env.buildDbi()
+    final Dbi<T> db = env.createDbi()
         .setDbName(DB_1)
         .withCallbackComparator(ignored -> comparator)
         .setDbiFlags(flags)

From d47694ec249c3b48d51090f566e3d7b20eefb84b Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Thu, 6 Nov 2025 12:20:47 +0000
Subject: [PATCH 265/322] Remove ByteUnits dep, add ByteUnit enum, add
 setMapSize() overload

---
 pom.xml                                       |  7 --
 src/main/java/org/lmdbjava/ByteUnit.java      | 90 +++++++++++++++++++
 src/main/java/org/lmdbjava/Env.java           | 66 ++++++--------
 src/test/java/org/lmdbjava/ByteUnitTest.java  | 64 +++++++++++++
 .../CursorIterableIntegerDupTest.java         |  3 +-
 .../CursorIterableIntegerKeyTest.java         |  3 +-
 .../org/lmdbjava/CursorIterablePerfTest.java  |  3 +-
 .../java/org/lmdbjava/CursorIterableTest.java |  3 +-
 .../java/org/lmdbjava/CursorParamTest.java    |  3 +-
 src/test/java/org/lmdbjava/CursorTest.java    |  3 +-
 .../java/org/lmdbjava/DbiBuilderTest.java     |  3 +-
 src/test/java/org/lmdbjava/DbiTest.java       | 27 +++---
 src/test/java/org/lmdbjava/EnvTest.java       | 42 ++++-----
 src/test/java/org/lmdbjava/TxnTest.java       |  3 +-
 src/test/java/org/lmdbjava/VerifierTest.java  | 17 ++--
 15 files changed, 228 insertions(+), 109 deletions(-)
 create mode 100644 src/main/java/org/lmdbjava/ByteUnit.java
 create mode 100644 src/test/java/org/lmdbjava/ByteUnitTest.java

diff --git a/pom.xml b/pom.xml
index 4d60b903..11dbdeb5 100644
--- a/pom.xml
+++ b/pom.xml
@@ -29,7 +29,6 @@
     <agrona.version>1.22.0</agrona.version>
     <assertj.version>3.27.6</assertj.version>
     <buildnumber-maven-plugin.version>3.2.1</buildnumber-maven-plugin.version>
-    <byteunits.version>0.9.1</byteunits.version>
     <central-publishing-maven-plugin.version>0.9.0</central-publishing-maven-plugin.version>
     <fmt-maven-plugin.version>2.29</fmt-maven-plugin.version>
     <google-java-format.version>1.28.0</google-java-format.version>
@@ -85,12 +84,6 @@
       <version>${guava.version}</version>
       <scope>test</scope>
     </dependency>
-    <dependency>
-      <groupId>com.jakewharton.byteunits</groupId>
-      <artifactId>byteunits</artifactId>
-      <version>${byteunits.version}</version>
-      <scope>test</scope>
-    </dependency>
     <dependency>
       <groupId>io.netty</groupId>
       <artifactId>netty-buffer</artifactId>
diff --git a/src/main/java/org/lmdbjava/ByteUnit.java b/src/main/java/org/lmdbjava/ByteUnit.java
new file mode 100644
index 00000000..96d0dba7
--- /dev/null
+++ b/src/main/java/org/lmdbjava/ByteUnit.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+/**
+ * Simple {@link Enum} for converting various IEC and SI byte units down a number of bytes.
+ */
+public enum ByteUnit {
+
+  BYTES(1L),
+
+  /**
+   * IEC byte unit for 1024 bytes.
+   */
+  KIBIBYTES(1024L),
+  /**
+   * IEC byte unit for 1024^2 bytes.
+   */
+  MEBIBYTES(1_0485_76L),
+  /**
+   * IEC byte unit for 1024^3 bytes.
+   */
+  GIBIBYTES(1_073_741_824L),
+  /**
+   * IEC byte unit for 1024^4 bytes.
+   */
+  TEBIBYTES(1_099_511_627_776L),
+  /**
+   * IEC byte unit for 1024^5 bytes.
+   */
+  PEBIBYTES(1_125_899_906_842_624L),
+
+  /**
+   * SI byte unit for 1000 bytes.
+   */
+  KILOBYTES(1_000L),
+  /**
+   * SI byte unit for 1000^2 bytes.
+   */
+  MEGABYTES(1_000_000L),
+  /**
+   * SI byte unit for 1000^3 bytes.
+   */
+  GIGABYTES(1_000_000_000L),
+  /**
+   * SI byte unit for 1000^4 bytes.
+   */
+  TERABYTES(1_000_000_000_000L),
+  /**
+   * SI byte unit for 1000^5 bytes.
+   */
+  PETABYTES(1_000_000_000_000_000L),
+  ;
+
+  private final long factor;
+
+  ByteUnit(long factor) {
+    this.factor = factor;
+  }
+
+  /**
+   * Convert the value in this byte unit into bytes.
+   *
+   * @param value The value to convert.
+   * @return The number of bytes.
+   */
+  public long toBytes(final long value) {
+    return value * factor;
+  }
+
+  /**
+   * @return The factor to apply when converting this unit into bytes.
+   */
+  public long getFactor() {
+    return factor;
+  }
+}
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index b414101a..2565bc65 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -63,11 +63,6 @@ public final class Env<T> implements AutoCloseable {
    */
   public static final boolean SHOULD_CHECK = !getBoolean(DISABLE_CHECKS_PROP);
 
-  private static final long KIBIBYTES = 1_024L;
-  private static final long MEBIBYTES = KIBIBYTES * 1_024L;
-  private static final long GIBIBYTES = MEBIBYTES * 1_024L;
-  private static final long TEBIBYTES = GIBIBYTES * 1_024L;
-
   private boolean closed;
   private final int maxKeySize;
   private final boolean noSubDir;
@@ -120,8 +115,9 @@ public static <T> Builder<T> create(final BufferProxy<T> proxy) {
    */
   @Deprecated
   public static Env<ByteBuffer> open(final File path, final int size, final EnvFlags... flags) {
+
     return new Builder<>(PROXY_OPTIMAL)
-        .setMapSize(size * MEBIBYTES)
+        .setMapSize(size, ByteUnit.MEBIBYTES)
         .open(path, flags);
   }
 
@@ -218,9 +214,22 @@ public List<byte[]> getDbiNames() {
    * @param mapSize the new size, in bytes
    */
   public void setMapSize(final long mapSize) {
+    if (mapSize < 0) {
+      throw new IllegalArgumentException("Negative value; overflow?");
+    }
     checkRc(LIB.mdb_env_set_mapsize(ptr, mapSize));
   }
 
+  /**
+   * Set the size of the data memory map.
+   *
+   * @param mapSize the new size, in bytes
+   */
+  public void setMapSize(final long mapSize, final ByteUnit byteUnit) {
+    requireNonNull(byteUnit);
+    setMapSize(byteUnit.toBytes(mapSize));
+  }
+
   /**
    * Get the maximum size of keys and MDB_DUPSORT data we can write.
    *
@@ -668,7 +677,8 @@ public AlreadyOpenException() {
   public static final class Builder<T> {
 
     static final int MAX_READERS_DEFAULT = 126;
-    private long mapSize = 1_024 * 1_024;
+    static final long MAP_SIZE_DEFAULT = ByteUnit.MEBIBYTES.toBytes(1);
+    private long mapSize = MAP_SIZE_DEFAULT;
     private int maxDbs = 1;
     private int maxReaders = MAX_READERS_DEFAULT;
     private boolean opened;
@@ -772,43 +782,17 @@ public Builder<T> setMapSize(final long mapSize) {
     }
 
     /**
-     * Sets the map size in kibibytes
-     *
-     * @param mapSizeKb new limit in kibibytes
-     * @return the builder
-     */
-    public Builder<T> setMapSizeKb(final long mapSizeKb) {
-      return setMapSize(mapSizeKb * KIBIBYTES);
-    }
-
-    /**
-     * Sets the map size in mebibytes.
+     * Sets the map size in the supplied unit.
      *
-     * @param mapSizeMb new limit in mebibytes.
+     * @param mapSize new limit in
      * @return the builder
      */
-    public Builder<T> setMapSizeMb(final long mapSizeMb) {
-      return setMapSize(mapSizeMb * MEBIBYTES);
-    }
-
-    /**
-     * Sets the map size in gibibytes
-     *
-     * @param mapSizeGb new limit in gibibytes
-     * @return the builder
-     */
-    public Builder<T> setMapSizeGb(final long mapSizeGb) {
-      return setMapSize(mapSizeGb * GIBIBYTES);
-    }
-
-    /**
-     * Sets the map size in tebibytes.
-     *
-     * @param mapSizeTb new limit in tebibytes.
-     * @return the builder
-     */
-    public Builder<T> setMapSizeTb(final long mapSizeTb) {
-      return setMapSize(mapSizeTb * TEBIBYTES);
+    public Builder<T> setMapSize(final long mapSize, final ByteUnit byteUnit) {
+      requireNonNull(byteUnit);
+      if (mapSize < 0) {
+        throw new IllegalArgumentException("Negative value; overflow?");
+      }
+      return setMapSize(byteUnit.toBytes(mapSize));
     }
 
     /**
diff --git a/src/test/java/org/lmdbjava/ByteUnitTest.java b/src/test/java/org/lmdbjava/ByteUnitTest.java
new file mode 100644
index 00000000..a899cbc3
--- /dev/null
+++ b/src/test/java/org/lmdbjava/ByteUnitTest.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+class ByteUnitTest {
+
+  @Test
+  void test() {
+    Assertions.assertThat(ByteUnit.BYTES.toBytes(2)).isEqualTo(2);
+
+    // BYTES
+    Assertions.assertThat(ByteUnit.BYTES.toBytes(2)).isEqualTo(2L);
+    Assertions.assertThat(ByteUnit.BYTES.toBytes(0)).isEqualTo(0L);
+
+    // IEC Units
+    Assertions.assertThat(ByteUnit.KIBIBYTES.toBytes(1)).isEqualTo(1024L);
+    Assertions.assertThat(ByteUnit.KIBIBYTES.toBytes(2)).isEqualTo(2048L);
+
+    Assertions.assertThat(ByteUnit.MEBIBYTES.toBytes(1)).isEqualTo(1048576L);
+    Assertions.assertThat(ByteUnit.MEBIBYTES.toBytes(2)).isEqualTo(2097152L);
+
+    Assertions.assertThat(ByteUnit.GIBIBYTES.toBytes(1)).isEqualTo(1073741824L);
+    Assertions.assertThat(ByteUnit.GIBIBYTES.toBytes(2)).isEqualTo(2147483648L);
+
+    Assertions.assertThat(ByteUnit.TEBIBYTES.toBytes(1)).isEqualTo(1099511627776L);
+    Assertions.assertThat(ByteUnit.TEBIBYTES.toBytes(2)).isEqualTo(2199023255552L);
+
+    Assertions.assertThat(ByteUnit.PEBIBYTES.toBytes(1)).isEqualTo(1125899906842624L);
+    Assertions.assertThat(ByteUnit.PEBIBYTES.toBytes(2)).isEqualTo(2251799813685248L);
+
+    // SI Units
+    Assertions.assertThat(ByteUnit.KILOBYTES.toBytes(1)).isEqualTo(1000L);
+    Assertions.assertThat(ByteUnit.KILOBYTES.toBytes(2)).isEqualTo(2000L);
+
+    Assertions.assertThat(ByteUnit.MEGABYTES.toBytes(1)).isEqualTo(1000000L);
+    Assertions.assertThat(ByteUnit.MEGABYTES.toBytes(2)).isEqualTo(2000000L);
+
+    Assertions.assertThat(ByteUnit.GIGABYTES.toBytes(1)).isEqualTo(1000000000L);
+    Assertions.assertThat(ByteUnit.GIGABYTES.toBytes(2)).isEqualTo(2000000000L);
+
+    Assertions.assertThat(ByteUnit.TERABYTES.toBytes(1)).isEqualTo(1000000000000L);
+    Assertions.assertThat(ByteUnit.TERABYTES.toBytes(2)).isEqualTo(2000000000000L);
+
+    Assertions.assertThat(ByteUnit.PETABYTES.toBytes(1)).isEqualTo(1000000000000000L);
+    Assertions.assertThat(ByteUnit.PETABYTES.toBytes(2)).isEqualTo(2000000000000000L);
+
+  }
+}
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
index 091f5768..0e3d4e3e 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
@@ -15,7 +15,6 @@
  */
 package org.lmdbjava;
 
-import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
 import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
@@ -123,7 +122,7 @@ public void before() throws IOException {
     final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
     env =
         create(bufferProxy)
-            .setMapSize(KIBIBYTES.toBytes(256))
+            .setMapSize(256, ByteUnit.KIBIBYTES)
             .setMaxReaders(1)
             .setMaxDbs(3)
             .setEnvFlags(MDB_NOSUBDIR)
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
index e4f89302..3ff4364f 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
@@ -15,7 +15,6 @@
  */
 package org.lmdbjava;
 
-import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
 import static java.util.Arrays.asList;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
@@ -104,7 +103,7 @@ public void before() throws IOException {
     file = FileUtil.createTempFile();
     final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
     env = Env.create(bufferProxy)
-        .setMapSize(KIBIBYTES.toBytes(256))
+        .setMapSize(256, ByteUnit.KIBIBYTES)
         .setMaxReaders(1)
         .setMaxDbs(3)
         .setEnvFlags(MDB_NOSUBDIR)
diff --git a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
index cc91a8fb..82bf337d 100644
--- a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
@@ -15,7 +15,6 @@
  */
 package org.lmdbjava;
 
-import static com.jakewharton.byteunits.BinaryByteUnit.GIBIBYTES;
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
 import static org.lmdbjava.Env.create;
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
@@ -51,7 +50,7 @@ public void before() throws IOException {
     final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
     env =
         create(bufferProxy)
-            .setMapSize(GIBIBYTES.toBytes(1))
+            .setMapSize(1, ByteUnit.GIBIBYTES)
             .setMaxReaders(1)
             .setMaxDbs(3)
             .setEnvFlags(MDB_NOSUBDIR)
diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index b991b809..e57e8ca4 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -16,7 +16,6 @@
 
 package org.lmdbjava;
 
-import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
 import static java.util.Arrays.asList;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
@@ -98,7 +97,7 @@ void beforeEach() {
     file = FileUtil.createTempFile();
     final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
     env = create(bufferProxy)
-        .setMapSize(KIBIBYTES.toBytes(256))
+        .setMapSize(256, ByteUnit.KIBIBYTES)
         .setMaxReaders(1)
         .setMaxDbs(3)
         .setEnvFlags(MDB_NOSUBDIR)
diff --git a/src/test/java/org/lmdbjava/CursorParamTest.java b/src/test/java/org/lmdbjava/CursorParamTest.java
index 4dd52b6f..f2fc5fbb 100644
--- a/src/test/java/org/lmdbjava/CursorParamTest.java
+++ b/src/test/java/org/lmdbjava/CursorParamTest.java
@@ -16,7 +16,6 @@
 
 package org.lmdbjava;
 
-import static com.jakewharton.byteunits.BinaryByteUnit.MEBIBYTES;
 import static java.lang.Long.BYTES;
 import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.assertj.core.api.Assertions.assertThat;
@@ -158,7 +157,7 @@ public final void execute(final Path tmp) {
 
     private Env<T> env(final Path tmp) {
       return create(proxy)
-          .setMapSize(MEBIBYTES.toBytes(1))
+          .setMapSize(1, ByteUnit.MEBIBYTES)
           .setMaxReaders(1)
           .setMaxDbs(1)
           .setEnvFlags(MDB_NOSUBDIR)
diff --git a/src/test/java/org/lmdbjava/CursorTest.java b/src/test/java/org/lmdbjava/CursorTest.java
index 9126026f..7177000a 100644
--- a/src/test/java/org/lmdbjava/CursorTest.java
+++ b/src/test/java/org/lmdbjava/CursorTest.java
@@ -16,7 +16,6 @@
 
 package org.lmdbjava;
 
-import static com.jakewharton.byteunits.BinaryByteUnit.MEBIBYTES;
 import static java.lang.Long.BYTES;
 import static java.lang.Long.MIN_VALUE;
 import static java.nio.ByteBuffer.allocateDirect;
@@ -61,7 +60,7 @@ void beforeEach() {
     file = FileUtil.createTempFile();
     env =
         create(PROXY_OPTIMAL)
-            .setMapSize(MEBIBYTES.toBytes(1))
+            .setMapSize(1, ByteUnit.MEBIBYTES)
             .setMaxReaders(1)
             .setMaxDbs(1)
             .setEnvFlags(MDB_NOSUBDIR)
diff --git a/src/test/java/org/lmdbjava/DbiBuilderTest.java b/src/test/java/org/lmdbjava/DbiBuilderTest.java
index 87b1db46..ede387c9 100644
--- a/src/test/java/org/lmdbjava/DbiBuilderTest.java
+++ b/src/test/java/org/lmdbjava/DbiBuilderTest.java
@@ -15,7 +15,6 @@
  */
 package org.lmdbjava;
 
-import static com.jakewharton.byteunits.BinaryByteUnit.MEBIBYTES;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.lmdbjava.Env.create;
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
@@ -42,7 +41,7 @@ public class DbiBuilderTest {
   public void before() {
     file = FileUtil.createTempFile();
     env = create()
-        .setMapSize(MEBIBYTES.toBytes(64))
+        .setMapSize(64, ByteUnit.MEBIBYTES)
         .setMaxReaders(2)
         .setMaxDbs(2)
         .setEnvFlags(MDB_NOSUBDIR)
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 2d84b467..8b8a461b 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -16,7 +16,6 @@
 
 package org.lmdbjava;
 
-import static com.jakewharton.byteunits.BinaryByteUnit.MEBIBYTES;
 import static java.lang.Long.MAX_VALUE;
 import static java.lang.System.getProperty;
 import static java.nio.ByteBuffer.allocateDirect;
@@ -82,19 +81,19 @@ public final class DbiTest {
   @BeforeEach
   void beforeEach() {
     file = FileUtil.createTempFile();
-    env =
-        create()
-            .setMapSize(MEBIBYTES.toBytes(64))
-            .setMaxReaders(2)
-            .setMaxDbs(2)
-            .open(file.toFile(), MDB_NOSUBDIR);
+    env = create()
+        .setMapSize(64, ByteUnit.MEBIBYTES)
+        .setMaxReaders(2)
+        .setMaxDbs(2)
+        .setEnvFlags(MDB_NOSUBDIR)
+        .open(file);
     fileBa = FileUtil.createTempFile();
-    envBa =
-        create(PROXY_BA)
-            .setMapSize(MEBIBYTES.toBytes(64))
-            .setMaxReaders(2)
-            .setMaxDbs(2)
-            .open(fileBa.toFile(), MDB_NOSUBDIR);
+    envBa = create(PROXY_BA)
+        .setMapSize(64, ByteUnit.MEBIBYTES)
+        .setMaxReaders(2)
+        .setMaxDbs(2)
+        .setEnvFlags(MDB_NOSUBDIR)
+        .open(fileBa);
   }
 
   @AfterEach
@@ -393,7 +392,7 @@ void putCommitGetByteArray() {
     FileUtil.useTempFile(
         file -> {
           try (Env<byte[]> envBa = create(PROXY_BA)
-              .setMapSize(MEBIBYTES.toBytes(64))
+              .setMapSize(64, ByteUnit.MEBIBYTES)
               .setMaxReaders(1)
               .setMaxDbs(2)
               .setEnvFlags(MDB_NOSUBDIR)
diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index 69c20c1b..6332ddc8 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -16,7 +16,6 @@
 
 package org.lmdbjava;
 
-import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
 import static com.jakewharton.byteunits.BinaryByteUnit.MEBIBYTES;
 import static java.nio.ByteBuffer.allocateDirect;
 import static org.assertj.core.api.Assertions.assertThat;
@@ -52,12 +51,11 @@ public final class EnvTest {
   void byteUnit() {
     FileUtil.useTempFile(
         file -> {
-          try (Env<ByteBuffer> env =
-                   Env.create()
-                       .setMaxReaders(1)
-                       .setMapSize(MEBIBYTES.toBytes(1))
-                       .setEnvFlags(MDB_NOSUBDIR)
-                       .open(file)) {
+          try (Env<ByteBuffer> env = Env.create()
+              .setMaxReaders(1)
+              .setMapSize(1, ByteUnit.MEBIBYTES)
+              .setEnvFlags(MDB_NOSUBDIR)
+              .open(file)) {
             final EnvInfo info = env.info();
             assertThat(info.mapSize).isEqualTo(MEBIBYTES.toBytes(1));
           }
@@ -342,13 +340,12 @@ void createAsDirectory() {
   void createAsFile() {
     FileUtil.useTempFile(
         file -> {
-          try (Env<ByteBuffer> env =
-                   Env.create()
-                       .setMapSize(MEBIBYTES.toBytes(1))
-                       .setMaxDbs(1)
-                       .setMaxReaders(1)
-                       .setEnvFlags(MDB_NOSUBDIR)
-                       .open(file)) {
+          try (Env<ByteBuffer> env = Env.create()
+              .setMapSize(1, ByteUnit.MEBIBYTES)
+              .setMaxDbs(1)
+              .setMaxReaders(1)
+              .setEnvFlags(MDB_NOSUBDIR)
+              .open(file)) {
             env.sync(true);
             assertThat(Files.isRegularFile(file)).isTrue();
           }
@@ -404,7 +401,7 @@ void mapFull() {
                 try (Env<ByteBuffer> env =
                          Env.create()
                              .setMaxReaders(1)
-                             .setMapSize(MEBIBYTES.toBytes(8))
+                             .setMapSize(8, ByteUnit.MEBIBYTES)
                              .setMaxDbs(1)
                              .open(dir)) {
                   final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
@@ -452,12 +449,11 @@ void setMapSize() {
           final ByteBuffer key = allocateDirect(500);
           final ByteBuffer val = allocateDirect(1_024);
           final Random rnd = new Random();
-          try (Env<ByteBuffer> env =
-                   Env.create()
-                       .setMaxReaders(1)
-                       .setMapSize(KIBIBYTES.toBytes(256))
-                       .setMaxDbs(1)
-                       .open(dir)) {
+          try (Env<ByteBuffer> env = Env.create()
+              .setMaxReaders(1)
+              .setMapSize(256, ByteUnit.KIBIBYTES)
+              .setMaxDbs(1)
+              .open(dir)) {
             final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
 
             db.put(bb(1), bb(42));
@@ -475,7 +471,7 @@ void setMapSize() {
             }
             assertThat(mapFullExThrown).isTrue();
 
-            env.setMapSize(KIBIBYTES.toBytes(1024));
+            env.setMapSize(1024, ByteUnit.KIBIBYTES);
 
             try (Txn<ByteBuffer> roTxn = env.txnRead()) {
               final ByteBuffer byteBuffer = db.get(roTxn, bb(1));
@@ -525,7 +521,7 @@ void stats() {
   void testDefaultOpen() {
     FileUtil.useTempDir(
         dir -> {
-          try (Env<ByteBuffer> env = Env.create().setMapSizeMb(10).open(dir)) {
+          try (Env<ByteBuffer> env = Env.create().setMapSize(10, ByteUnit.MEBIBYTES).open(dir)) {
             final EnvInfo info = env.info();
             assertThat(info.maxReaders).isEqualTo(MAX_READERS_DEFAULT);
             final Dbi<ByteBuffer> db = env.openDbi("test", MDB_CREATE);
diff --git a/src/test/java/org/lmdbjava/TxnTest.java b/src/test/java/org/lmdbjava/TxnTest.java
index f81b525e..ba8e55d3 100644
--- a/src/test/java/org/lmdbjava/TxnTest.java
+++ b/src/test/java/org/lmdbjava/TxnTest.java
@@ -16,7 +16,6 @@
 
 package org.lmdbjava;
 
-import static com.jakewharton.byteunits.BinaryByteUnit.KIBIBYTES;
 import static java.nio.ByteBuffer.allocateDirect;
 import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.assertj.core.api.Assertions.assertThat;
@@ -64,7 +63,7 @@ void beforeEach() {
     file = FileUtil.createTempFile();
     env =
         create()
-            .setMapSize(KIBIBYTES.toBytes(256))
+            .setMapSize(256, ByteUnit.KIBIBYTES)
             .setMaxReaders(1)
             .setMaxDbs(2)
             .setEnvFlags(MDB_NOSUBDIR)
diff --git a/src/test/java/org/lmdbjava/VerifierTest.java b/src/test/java/org/lmdbjava/VerifierTest.java
index 64214568..75812e18 100644
--- a/src/test/java/org/lmdbjava/VerifierTest.java
+++ b/src/test/java/org/lmdbjava/VerifierTest.java
@@ -16,7 +16,6 @@
 
 package org.lmdbjava;
 
-import static com.jakewharton.byteunits.BinaryByteUnit.MEBIBYTES;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.lmdbjava.Env.create;
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
@@ -25,19 +24,21 @@
 import java.util.concurrent.TimeUnit;
 import org.junit.jupiter.api.Test;
 
-/** Test {@link Verifier}. */
+/**
+ * Test {@link Verifier}.
+ */
 public final class VerifierTest {
 
   @Test
   void verification() {
     FileUtil.useTempFile(
         file -> {
-          try (Env<ByteBuffer> env =
-              create()
-                  .setMaxReaders(1)
-                  .setMaxDbs(Verifier.DBI_COUNT)
-                  .setMapSize(MEBIBYTES.toBytes(10))
-                  .open(file.toFile(), MDB_NOSUBDIR)) {
+          try (Env<ByteBuffer> env = create()
+              .setMaxReaders(1)
+              .setMaxDbs(Verifier.DBI_COUNT)
+              .setMapSize(10, ByteUnit.MEBIBYTES)
+              .setEnvFlags(MDB_NOSUBDIR)
+              .open(file)) {
             final Verifier v = new Verifier(env);
             final int seconds = Integer.getInteger("verificationSeconds", 2);
             assertThat(v.runFor(seconds, TimeUnit.SECONDS)).isGreaterThan(1L);

From fb087797f5154dfe77d568253ea1c72e11817973 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Thu, 6 Nov 2025 12:25:47 +0000
Subject: [PATCH 266/322] Fix compile errors

---
 src/test/java/org/lmdbjava/EnvTest.java | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index 6332ddc8..a2e3cb47 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -16,7 +16,6 @@
 
 package org.lmdbjava;
 
-import static com.jakewharton.byteunits.BinaryByteUnit.MEBIBYTES;
 import static java.nio.ByteBuffer.allocateDirect;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
@@ -57,7 +56,7 @@ void byteUnit() {
               .setEnvFlags(MDB_NOSUBDIR)
               .open(file)) {
             final EnvInfo info = env.info();
-            assertThat(info.mapSize).isEqualTo(MEBIBYTES.toBytes(1));
+            assertThat(info.mapSize).isEqualTo(ByteUnit.MEBIBYTES.toBytes(1));
           }
         });
   }

From a82d7f234d33f35ae15cf0340fe9068af6d967c1 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Thu, 6 Nov 2025 12:38:47 +0000
Subject: [PATCH 267/322] Add more test coverage

---
 src/main/java/org/lmdbjava/Env.java            |  7 ++++---
 src/main/java/org/lmdbjava/FlagSet.java        | 15 ++++++---------
 .../java/org/lmdbjava/AbstractFlagSetTest.java | 18 ++++++++++++++----
 3 files changed, 24 insertions(+), 16 deletions(-)

diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 2565bc65..9b2a4360 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -115,7 +115,6 @@ public static <T> Builder<T> create(final BufferProxy<T> proxy) {
    */
   @Deprecated
   public static Env<ByteBuffer> open(final File path, final int size, final EnvFlags... flags) {
-
     return new Builder<>(PROXY_OPTIMAL)
         .setMapSize(size, ByteUnit.MEBIBYTES)
         .open(path, flags);
@@ -678,13 +677,15 @@ public static final class Builder<T> {
 
     static final int MAX_READERS_DEFAULT = 126;
     static final long MAP_SIZE_DEFAULT = ByteUnit.MEBIBYTES.toBytes(1);
+    static final int POSIX_MODE_DEFAULT = 0664;
+
     private long mapSize = MAP_SIZE_DEFAULT;
     private int maxDbs = 1;
     private int maxReaders = MAX_READERS_DEFAULT;
     private boolean opened;
     private final BufferProxy<T> proxy;
-    private int mode = 0664;
-    private AbstractFlagSet.Builder<EnvFlags, EnvFlagSet> flagSetBuilder = EnvFlagSet.builder();
+    private int mode = POSIX_MODE_DEFAULT;
+    private final AbstractFlagSet.Builder<EnvFlags, EnvFlagSet> flagSetBuilder = EnvFlagSet.builder();
 
     Builder(final BufferProxy<T> proxy) {
       requireNonNull(proxy);
diff --git a/src/main/java/org/lmdbjava/FlagSet.java b/src/main/java/org/lmdbjava/FlagSet.java
index a9cffd47..94cb3dca 100644
--- a/src/main/java/org/lmdbjava/FlagSet.java
+++ b/src/main/java/org/lmdbjava/FlagSet.java
@@ -55,6 +55,11 @@ default int getMaskWith(final FlagSet<T> other) {
    */
   boolean isSet(T flag);
 
+  /**
+   * @return The number of flags in this set.
+   */
+  int size();
+
   /**
    * @return True if at least one of flags are included in thie {@link FlagSet}
    */
@@ -71,19 +76,11 @@ default boolean areAnySet(final FlagSet<T> flags) {
     return false;
   }
 
-  /**
-   * @return The size of this {@link FlagSet}
-   */
-  default int size() {
-    return getFlags().size();
-  }
 
   /**
    * @return True if this {@link FlagSet} is empty.
    */
-  default boolean isEmpty() {
-    return getFlags().isEmpty();
-  }
+  boolean isEmpty();
 
   /**
    * @return The {@link Iterator} (in no particular order) for the flags in this {@link FlagSet}.
diff --git a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
index 298ee2fe..011d3efd 100644
--- a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
@@ -45,10 +45,6 @@ T getFirst() {
     return getAllFlags().get(0);
   }
 
-  int getFlagCount() {
-    return getAllFlags().size();
-  }
-
   @Test
   void testEmpty() {
     final F emptyFlagSet = getEmptyFlagSet();
@@ -81,6 +77,12 @@ void testSingleFlagSet() {
           .containsExactly(flag);
       assertThat(flagSet.size())
           .isEqualTo(1);
+      assertThat(FlagSet.equals(flagSet, new Object()))
+          .isFalse();
+      assertThat(FlagSet.equals(flagSet, null))
+          .isFalse();
+      assertThat(FlagSet.equals(flag, flag))
+          .isTrue();
       assertThat(FlagSet.equals(flagSet, flag))
           .isTrue();
       assertThat(FlagSet.equals(flagSet, getFlagSet(flag)))
@@ -89,6 +91,10 @@ void testSingleFlagSet() {
           .isTrue();
       assertThat(flagSet.areAnySet(flag))
           .isTrue();
+      assertThat(flagSet.areAnySet(null))
+          .isFalse();
+      assertThat(flagSet.areAnySet(getEmptyFlagSet()))
+          .isFalse();
       assertThat(flagSet.isSet(getFirst()))
           .isEqualTo(getFirst() == flag);
       if (getFirst() == flag) {
@@ -97,11 +103,15 @@ void testSingleFlagSet() {
       } else {
         assertThat(flagSet.getMask())
             .isNotEqualTo(MaskedFlag.mask(getFirst()));
+        assertThat(flagSet.getMaskWith(getFirst()))
+            .isEqualTo(MaskedFlag.mask(flag, getFirst()));
       }
       assertThat(flagSet.toString())
           .isNotNull();
       assertThat(flag.name())
           .isNotNull();
+      assertThat(flagSet.getMaskWith(null))
+          .isEqualTo(flagSet.getMask());
     }
   }
 

From 534b76ba3ba890810a99f2c4a13c5db4de672a23 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Thu, 6 Nov 2025 18:34:20 +0000
Subject: [PATCH 268/322] Fix codeQL issue

---
 src/main/java/org/lmdbjava/DbiBuilder.java | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
index b478c9df..7824458b 100644
--- a/src/main/java/org/lmdbjava/DbiBuilder.java
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -393,10 +393,10 @@ public Dbi<T> open() {
       if (txn != null) {
         return openDbi(txn, dbiBuilder);
       } else {
-        try (final Txn<T> txn = getTxn(dbiBuilder)) {
-          final Dbi<T> dbi = openDbi(txn, dbiBuilder);
+        try (final Txn<T> localTxn = getTxn(dbiBuilder)) {
+          final Dbi<T> dbi = openDbi(localTxn, dbiBuilder);
           // even RO Txns require a commit to retain Dbi in Env
-          txn.commit();
+          localTxn.commit();
           return dbi;
         }
       }

From e9f9ac4f8879ac9f0ca667b66a0cf4eacf7b424e Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Thu, 6 Nov 2025 18:46:25 +0000
Subject: [PATCH 269/322] Add test coverage on FlagSet

---
 src/main/java/org/lmdbjava/CopyFlagSet.java   |  2 +-
 .../org/lmdbjava/AbstractFlagSetTest.java     | 33 +++++++++++++++++++
 2 files changed, 34 insertions(+), 1 deletion(-)

diff --git a/src/main/java/org/lmdbjava/CopyFlagSet.java b/src/main/java/org/lmdbjava/CopyFlagSet.java
index e21680dd..5350bada 100644
--- a/src/main/java/org/lmdbjava/CopyFlagSet.java
+++ b/src/main/java/org/lmdbjava/CopyFlagSet.java
@@ -21,7 +21,7 @@
 
 public interface CopyFlagSet extends FlagSet<CopyFlags> {
 
-  static CopyFlagSet EMPTY = CopyFlagSetImpl.EMPTY;
+  CopyFlagSet EMPTY = CopyFlagSetImpl.EMPTY;
 
   static CopyFlagSet empty() {
     return CopyFlagSetImpl.EMPTY;
diff --git a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
index 011d3efd..7358416b 100644
--- a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
@@ -159,6 +159,39 @@ void testAllFlags() {
     }
   }
 
+  /**
+   * Test as an enum instance rather than a {@link FlagSet}
+   */
+  @Test
+  void testAsFlag() {
+    final T flag = getFirst();
+    assertThat(flag.size())
+        .isEqualTo(1);
+    assertThat(flag.getFlags())
+        .hasSize(1);
+    final T flag2 = flag.getFlags().iterator().next();
+    assertThat(flag2 == flag)
+        .isTrue();
+    assertThat(flag.getMask())
+        .isEqualTo(MaskedFlag.mask(flag));
+    assertThat(flag.isEmpty())
+        .isFalse();
+    assertThat(flag.toString())
+        .isNotNull();
+    assertThat(flag.isSet(flag))
+        .isTrue();
+    assertThat(flag.isSet(flag2))
+        .isTrue();
+    assertThat(flag.isSet(null))
+        .isFalse();
+    final List<T> allFlags = getAllFlags();
+    if (allFlags.size() > 1) {
+      T secondFlag = allFlags.get(1);
+      assertThat(flag.isSet(secondFlag))
+          .isFalse();
+    }
+  }
+
   private T[] toArray(final int cnt) {
     //noinspection unchecked
     return (T[]) Array.newInstance(getFlagType(), cnt);

From b0112bb788347043ba4d19c3f138c06404d0fb35 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Thu, 6 Nov 2025 19:02:00 +0000
Subject: [PATCH 270/322] Add tests

---
 src/test/java/org/lmdbjava/EnvTest.java | 52 ++++++++++++++++++++++++-
 1 file changed, 50 insertions(+), 2 deletions(-)

diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index a2e3cb47..e1e72401 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -32,6 +32,7 @@
 import java.nio.ByteBuffer;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.util.List;
 import java.util.Random;
 import org.junit.jupiter.api.Test;
 import org.lmdbjava.Env.AlreadyClosedException;
@@ -371,8 +372,11 @@ void detectTransactionThreadViolation() {
   void info() {
     FileUtil.useTempFile(
         file -> {
-          try (Env<ByteBuffer> env =
-                   Env.create().setMaxReaders(4).setMapSize(123_456).setEnvFlags(MDB_NOSUBDIR).open(file)) {
+          try (Env<ByteBuffer> env = Env.create()
+              .setMaxReaders(4)
+              .setMapSize(123_456)
+              .setEnvFlags(MDB_NOSUBDIR)
+              .open(file)) {
             final EnvInfo info = env.info();
             assertThat(info).isNotNull();
             assertThat(info.lastPageNumber).isEqualTo(1L);
@@ -470,6 +474,10 @@ void setMapSize() {
             }
             assertThat(mapFullExThrown).isTrue();
 
+            assertThatThrownBy(() -> {
+              env.setMapSize(-1, ByteUnit.KIBIBYTES);
+            }).isInstanceOf(IllegalArgumentException.class);
+
             env.setMapSize(1024, ByteUnit.KIBIBYTES);
 
             try (Txn<ByteBuffer> roTxn = env.txnRead()) {
@@ -528,4 +536,44 @@ void testDefaultOpen() {
           }
         });
   }
+
+  @Test
+  void testDefaultOpenNoName1() {
+    FileUtil.useTempDir(
+        dir -> {
+          try (Env<ByteBuffer> env = Env.create().setMapSize(10, ByteUnit.MEBIBYTES).open(dir)) {
+            final EnvInfo info = env.info();
+            assertThat(info.maxReaders).isEqualTo(MAX_READERS_DEFAULT);
+            final Dbi<ByteBuffer> db = env.openDbi((String) null, MDB_CREATE);
+            db.put(bb("abc"), allocateDirect(1));
+            db.put(bb("def"), allocateDirect(1));
+
+            // As this is the unnamed database it returns all keys in the unnamed db
+            final List<byte[]> dbiNames = env.getDbiNames();
+            assertThat(dbiNames)
+                .hasSize(2);
+            assertThat(dbiNames.get(0))
+                .isEqualTo("abc".getBytes(Env.DEFAULT_NAME_CHARSET));
+          }
+        });
+  }
+
+  @Test
+  void testDefaultOpenNoName2() {
+    FileUtil.useTempDir(
+        dir -> {
+          try (Env<ByteBuffer> env = Env.create().setMapSize(10, ByteUnit.MEBIBYTES).open(dir)) {
+            final EnvInfo info = env.info();
+            assertThat(info.maxReaders).isEqualTo(MAX_READERS_DEFAULT);
+            final Dbi<ByteBuffer> db = env.openDbi((byte[]) null, MDB_CREATE);
+
+            // As this is the unnamed database it returns all keys in the unnamed db
+            final List<byte[]> dbiNames = env.getDbiNames();
+            assertThat(dbiNames)
+                .hasSize(1);
+            assertThat(dbiNames.get(0))
+                .isEqualTo(new byte[0]);
+          }
+        });
+  }
 }

From c25a7d243d2ca9103f527f784185d35ceae4c330 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 7 Nov 2025 10:09:54 +0000
Subject: [PATCH 271/322] Run format plugin

---
 .../java/org/lmdbjava/AbstractFlagSet.java    |  28 +-
 src/main/java/org/lmdbjava/BufferProxy.java   |   1 -
 src/main/java/org/lmdbjava/ByteBufProxy.java  |  15 +-
 .../java/org/lmdbjava/ByteBufferProxy.java    |  36 +-
 src/main/java/org/lmdbjava/ByteUnit.java      |  45 +-
 src/main/java/org/lmdbjava/CopyFlagSet.java   |  21 +-
 src/main/java/org/lmdbjava/Cursor.java        |  85 ++--
 .../java/org/lmdbjava/CursorIterable.java     |   4 -
 src/main/java/org/lmdbjava/Dbi.java           |  83 ++--
 src/main/java/org/lmdbjava/DbiBuilder.java    | 305 +++++-------
 src/main/java/org/lmdbjava/DbiFlagSet.java    |  25 +-
 src/main/java/org/lmdbjava/DbiFlags.java      |  36 +-
 .../java/org/lmdbjava/DirectBufferProxy.java  |  18 +-
 src/main/java/org/lmdbjava/Env.java           | 306 +++++-------
 src/main/java/org/lmdbjava/EnvFlagSet.java    |  21 +-
 src/main/java/org/lmdbjava/FlagSet.java       |  33 +-
 src/main/java/org/lmdbjava/MaskedFlag.java    |   4 +-
 src/main/java/org/lmdbjava/PutFlagSet.java    |  65 ++-
 src/main/java/org/lmdbjava/Txn.java           |   4 +-
 src/main/java/org/lmdbjava/TxnFlagSet.java    |  26 +-
 .../org/lmdbjava/AbstractFlagSetTest.java     | 156 ++----
 .../org/lmdbjava/ByteBufferProxyTest.java     | 124 ++---
 src/test/java/org/lmdbjava/ByteUnitTest.java  |   1 -
 .../lmdbjava/ComparatorIntegerKeyTest.java    | 101 ++--
 .../java/org/lmdbjava/CopyFlagSetTest.java    |  69 ++-
 .../CursorIterableIntegerDupTest.java         | 310 ++++++------
 .../CursorIterableIntegerKeyTest.java         | 335 ++++++-------
 .../org/lmdbjava/CursorIterablePerfTest.java  |  33 +-
 .../java/org/lmdbjava/CursorIterableTest.java | 368 ++++++++-------
 .../java/org/lmdbjava/CursorParamTest.java    |   3 +-
 src/test/java/org/lmdbjava/CursorTest.java    |   3 +-
 .../java/org/lmdbjava/DbiBuilderTest.java     | 182 +++----
 .../java/org/lmdbjava/DbiFlagSetTest.java     |  69 ++-
 src/test/java/org/lmdbjava/DbiTest.java       | 225 ++++-----
 .../java/org/lmdbjava/EnvFlagSetTest.java     |  69 ++-
 src/test/java/org/lmdbjava/EnvTest.java       | 444 +++++++++---------
 .../org/lmdbjava/GarbageCollectionTest.java   |   5 +-
 .../java/org/lmdbjava/PutFlagSetTest.java     |  15 +-
 src/test/java/org/lmdbjava/TestUtils.java     |  15 +-
 src/test/java/org/lmdbjava/TutorialTest.java  |  50 +-
 .../java/org/lmdbjava/TxnFlagSetTest.java     |   3 +-
 src/test/java/org/lmdbjava/TxnTest.java       |   6 +-
 src/test/java/org/lmdbjava/VerifierTest.java  |  17 +-
 43 files changed, 1736 insertions(+), 2028 deletions(-)

diff --git a/src/main/java/org/lmdbjava/AbstractFlagSet.java b/src/main/java/org/lmdbjava/AbstractFlagSet.java
index 849bbe73..fbaa4c6f 100644
--- a/src/main/java/org/lmdbjava/AbstractFlagSet.java
+++ b/src/main/java/org/lmdbjava/AbstractFlagSet.java
@@ -24,9 +24,7 @@
 import java.util.function.Function;
 import java.util.function.Supplier;
 
-/**
- * Encapsulates an immutable set of flags and the associated bit mask for the flags in the set.
- */
+/** Encapsulates an immutable set of flags and the associated bit mask for the flags in the set. */
 public abstract class AbstractFlagSet<T extends Enum<T> & MaskedFlag> implements FlagSet<T> {
 
   private final Set<T> flags;
@@ -60,8 +58,7 @@ public Set<T> getFlags() {
   @Override
   public boolean isSet(final T flag) {
     // Probably cheaper to compare the masks than to use EnumSet.contains()
-    return flag != null
-        && MaskedFlag.isSet(mask, flag);
+    return flag != null && MaskedFlag.isSet(mask, flag);
   }
 
   /**
@@ -103,11 +100,10 @@ public String toString() {
     return FlagSet.asString(this);
   }
 
-
   // --------------------------------------------------------------------------------
 
-
-  static abstract class AbstractSingleFlagSet<T extends Enum<T> & MaskedFlag> implements FlagSet<T> {
+  abstract static class AbstractSingleFlagSet<T extends Enum<T> & MaskedFlag>
+      implements FlagSet<T> {
 
     private final T flag;
     // Only holding this for iterator() and getFlags() so make it lazy.
@@ -186,10 +182,8 @@ private Set<T> initSet() {
     }
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   static class AbstractEmptyFlagSet<T extends MaskedFlag> implements FlagSet<T> {
 
     @Override
@@ -243,10 +237,8 @@ public int hashCode() {
     }
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   /**
    * A builder for creating a {@link AbstractFlagSet}.
    *
@@ -261,10 +253,11 @@ public static class Builder<E extends Enum<E> & MaskedFlag, S extends FlagSet<E>
     final Function<E, S> singletonSetConstructor;
     final Supplier<S> emptySetSupplier;
 
-    protected Builder(final Class<E> type,
-                      final Function<EnumSet<E>, S> constructor,
-                      final Function<E, S> singletonSetConstructor,
-                      final Supplier<S> emptySetSupplier) {
+    protected Builder(
+        final Class<E> type,
+        final Function<EnumSet<E>, S> constructor,
+        final Function<E, S> singletonSetConstructor,
+        final Supplier<S> emptySetSupplier) {
       this.type = type;
       this.enumSet = EnumSet.noneOf(type);
       this.constructor = Objects.requireNonNull(constructor);
@@ -273,7 +266,8 @@ protected Builder(final Class<E> type,
     }
 
     /**
-     * Replaces any flags already set in the builder with the contents of the passed flags {@link Collection}
+     * Replaces any flags already set in the builder with the contents of the passed flags {@link
+     * Collection}
      *
      * @param flags The flags to set in the builder.
      * @return this builder instance.
diff --git a/src/main/java/org/lmdbjava/BufferProxy.java b/src/main/java/org/lmdbjava/BufferProxy.java
index f857ade7..a3c339bf 100644
--- a/src/main/java/org/lmdbjava/BufferProxy.java
+++ b/src/main/java/org/lmdbjava/BufferProxy.java
@@ -40,7 +40,6 @@ public abstract class BufferProxy<T> {
   /** Offset from a pointer of the <code>MDB_val.mv_size</code> field. */
   protected static final int STRUCT_FIELD_OFFSET_SIZE = 0;
 
-
   /** Explicitly-defined default constructor to avoid warnings. */
   protected BufferProxy() {}
 
diff --git a/src/main/java/org/lmdbjava/ByteBufProxy.java b/src/main/java/org/lmdbjava/ByteBufProxy.java
index 19d94392..bcbb6ebf 100644
--- a/src/main/java/org/lmdbjava/ByteBufProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufProxy.java
@@ -89,8 +89,8 @@ public static int compareLexicographically(final ByteBuf o1, final ByteBuf o2) {
   }
 
   /**
-   * Buffer comparator specifically for 4/8 byte keys that are unsigned ints/longs,
-   * i.e. when using MDB_INTEGER_KEY/MDB_INTEGERDUP. Compares the buffers numerically.
+   * Buffer comparator specifically for 4/8 byte keys that are unsigned ints/longs, i.e. when using
+   * MDB_INTEGER_KEY/MDB_INTEGERDUP. Compares the buffers numerically.
    *
    * @param o1 left operand (required)
    * @param o2 right operand (required)
@@ -101,12 +101,17 @@ public static int compareAsIntegerKeys(final ByteBuf o1, final ByteBuf o2) {
     requireNonNull(o2);
     // Both buffers should be same length according to LMDB API.
     // From the LMDB docs for MDB_INTEGER_KEY
-    // numeric keys in native byte order: either unsigned int or size_t. The keys must all be of the same size.
+    // numeric keys in native byte order: either unsigned int or size_t. The keys must all be of the
+    // same size.
     final int len1 = o1.readableBytes();
     final int len2 = o2.readableBytes();
     if (len1 != len2) {
-      throw new RuntimeException("Length mismatch, len1: " + len1 + ", len2: " + len2
-          + ". Lengths must be identical and either 4 or 8 bytes.");
+      throw new RuntimeException(
+          "Length mismatch, len1: "
+              + len1
+              + ", len2: "
+              + len2
+              + ". Lengths must be identical and either 4 or 8 bytes.");
     }
     if (len1 == 8) {
       final long lw;
diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
index 1f82e953..52bfc924 100644
--- a/src/main/java/org/lmdbjava/ByteBufferProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -55,9 +55,7 @@ public final class ByteBufferProxy {
    */
   public static final BufferProxy<ByteBuffer> PROXY_OPTIMAL;
 
-  /**
-   * The safe, reflective {@link ByteBuffer} proxy for this system. Guaranteed to never be null.
-   */
+  /** The safe, reflective {@link ByteBuffer} proxy for this system. Guaranteed to never be null. */
   public static final BufferProxy<ByteBuffer> PROXY_SAFE;
 
   private static final ByteOrder NATIVE_ORDER = ByteOrder.nativeOrder();
@@ -67,8 +65,7 @@ public final class ByteBufferProxy {
     PROXY_OPTIMAL = getProxyOptimal();
   }
 
-  private ByteBufferProxy() {
-  }
+  private ByteBufferProxy() {}
 
   private static BufferProxy<ByteBuffer> getProxyOptimal() {
     try {
@@ -78,25 +75,19 @@ private static BufferProxy<ByteBuffer> getProxyOptimal() {
     }
   }
 
-  /**
-   * The buffer must be a direct buffer (not heap allocated).
-   */
+  /** The buffer must be a direct buffer (not heap allocated). */
   public static final class BufferMustBeDirectException extends LmdbException {
 
     private static final long serialVersionUID = 1L;
 
-    /**
-     * Creates a new instance.
-     */
+    /** Creates a new instance. */
     public BufferMustBeDirectException() {
       super("The buffer must be a direct buffer (not heap allocated");
     }
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   /**
    * Provides {@link ByteBuffer} pooling and address resolution for concrete {@link BufferProxy}
    * implementations.
@@ -150,8 +141,8 @@ public static int compareLexicographically(final ByteBuffer o1, final ByteBuffer
     }
 
     /**
-     * Buffer comparator specifically for 4/8 byte keys that are unsigned ints/longs,
-     * i.e. when using MDB_INTEGER_KEY/MDB_INTEGERDUP. Compares the buffers numerically.
+     * Buffer comparator specifically for 4/8 byte keys that are unsigned ints/longs, i.e. when
+     * using MDB_INTEGER_KEY/MDB_INTEGERDUP. Compares the buffers numerically.
      *
      * @param o1 left operand (required)
      * @param o2 right operand (required)
@@ -162,12 +153,17 @@ public static int compareAsIntegerKeys(final ByteBuffer o1, final ByteBuffer o2)
       requireNonNull(o2);
       // Both buffers should be same length according to LMDB API.
       // From the LMDB docs for MDB_INTEGER_KEY
-      // numeric keys in native byte order: either unsigned int or size_t. The keys must all be of the same size.
+      // numeric keys in native byte order: either unsigned int or size_t. The keys must all be of
+      // the same size.
       final int len1 = o1.limit();
       final int len2 = o2.limit();
       if (len1 != len2) {
-        throw new RuntimeException("Length mismatch, len1: " + len1 + ", len2: " + len2
-            + ". Lengths must be identical and either 4 or 8 bytes.");
+        throw new RuntimeException(
+            "Length mismatch, len1: "
+                + len1
+                + ", len2: "
+                + len2
+                + ". Lengths must be identical and either 4 or 8 bytes.");
       }
       // Keys for MDB_INTEGER_KEY are written in native order so ensure we read them in that order
       o1.order(NATIVE_ORDER);
@@ -250,10 +246,8 @@ protected byte[] getBytes(final ByteBuffer buffer) {
     }
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   /**
    * A proxy that uses Java reflection to modify byte buffer fields, and official JNR-FFF methods to
    * manipulate native pointers.
@@ -298,10 +292,8 @@ protected ByteBuffer out(final ByteBuffer buffer, final Pointer ptr) {
     }
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   /**
    * A proxy that uses Java's "unsafe" class to directly manipulate byte buffer fields and JNR-FFF
    * allocated memory pointers.
diff --git a/src/main/java/org/lmdbjava/ByteUnit.java b/src/main/java/org/lmdbjava/ByteUnit.java
index 96d0dba7..ed4b1ca8 100644
--- a/src/main/java/org/lmdbjava/ByteUnit.java
+++ b/src/main/java/org/lmdbjava/ByteUnit.java
@@ -15,53 +15,30 @@
  */
 package org.lmdbjava;
 
-/**
- * Simple {@link Enum} for converting various IEC and SI byte units down a number of bytes.
- */
+/** Simple {@link Enum} for converting various IEC and SI byte units down a number of bytes. */
 public enum ByteUnit {
-
   BYTES(1L),
 
-  /**
-   * IEC byte unit for 1024 bytes.
-   */
+  /** IEC byte unit for 1024 bytes. */
   KIBIBYTES(1024L),
-  /**
-   * IEC byte unit for 1024^2 bytes.
-   */
+  /** IEC byte unit for 1024^2 bytes. */
   MEBIBYTES(1_0485_76L),
-  /**
-   * IEC byte unit for 1024^3 bytes.
-   */
+  /** IEC byte unit for 1024^3 bytes. */
   GIBIBYTES(1_073_741_824L),
-  /**
-   * IEC byte unit for 1024^4 bytes.
-   */
+  /** IEC byte unit for 1024^4 bytes. */
   TEBIBYTES(1_099_511_627_776L),
-  /**
-   * IEC byte unit for 1024^5 bytes.
-   */
+  /** IEC byte unit for 1024^5 bytes. */
   PEBIBYTES(1_125_899_906_842_624L),
 
-  /**
-   * SI byte unit for 1000 bytes.
-   */
+  /** SI byte unit for 1000 bytes. */
   KILOBYTES(1_000L),
-  /**
-   * SI byte unit for 1000^2 bytes.
-   */
+  /** SI byte unit for 1000^2 bytes. */
   MEGABYTES(1_000_000L),
-  /**
-   * SI byte unit for 1000^3 bytes.
-   */
+  /** SI byte unit for 1000^3 bytes. */
   GIGABYTES(1_000_000_000L),
-  /**
-   * SI byte unit for 1000^4 bytes.
-   */
+  /** SI byte unit for 1000^4 bytes. */
   TERABYTES(1_000_000_000_000L),
-  /**
-   * SI byte unit for 1000^5 bytes.
-   */
+  /** SI byte unit for 1000^5 bytes. */
   PETABYTES(1_000_000_000_000_000L),
   ;
 
diff --git a/src/main/java/org/lmdbjava/CopyFlagSet.java b/src/main/java/org/lmdbjava/CopyFlagSet.java
index 5350bada..1aed9878 100644
--- a/src/main/java/org/lmdbjava/CopyFlagSet.java
+++ b/src/main/java/org/lmdbjava/CopyFlagSet.java
@@ -33,29 +33,20 @@ static CopyFlagSet of(final CopyFlags dbiFlag) {
   }
 
   static CopyFlagSet of(final CopyFlags... CopyFlags) {
-    return builder()
-        .setFlags(CopyFlags)
-        .build();
+    return builder().setFlags(CopyFlags).build();
   }
 
   static CopyFlagSet of(final Collection<CopyFlags> CopyFlags) {
-    return builder()
-        .setFlags(CopyFlags)
-        .build();
+    return builder().setFlags(CopyFlags).build();
   }
 
   static AbstractFlagSet.Builder<CopyFlags, CopyFlagSet> builder() {
     return new AbstractFlagSet.Builder<>(
-        CopyFlags.class,
-        CopyFlagSetImpl::new,
-        copyFlag -> copyFlag,
-        () -> CopyFlagSetImpl.EMPTY);
+        CopyFlags.class, CopyFlagSetImpl::new, copyFlag -> copyFlag, () -> CopyFlagSetImpl.EMPTY);
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   class CopyFlagSetImpl extends AbstractFlagSet<CopyFlags> implements CopyFlagSet {
 
     static final CopyFlagSet EMPTY = new EmptyCopyFlagSet();
@@ -65,10 +56,8 @@ private CopyFlagSetImpl(final EnumSet<CopyFlags> flags) {
     }
   }
 
-
   // --------------------------------------------------------------------------------
 
-
-  class EmptyCopyFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<CopyFlags> implements CopyFlagSet {
-  }
+  class EmptyCopyFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<CopyFlags>
+      implements CopyFlagSet {}
 }
diff --git a/src/main/java/org/lmdbjava/Cursor.java b/src/main/java/org/lmdbjava/Cursor.java
index 245a5a9a..09c461e2 100644
--- a/src/main/java/org/lmdbjava/Cursor.java
+++ b/src/main/java/org/lmdbjava/Cursor.java
@@ -95,13 +95,10 @@ public long count() {
     checkRc(LIB.mdb_cursor_count(ptrCursor, longByReference));
     return longByReference.longValue();
   }
+
   /**
-   * @deprecated Instead use {@link Cursor#delete(PutFlagSet)}.
-   * <hr>
-   * Delete current key/data pair.
-   *
-   * <p>This function deletes the key/data pair to which the cursor refers.
-   *
+   * @deprecated Instead use {@link Cursor#delete(PutFlagSet)}. <hr> Delete current key/data pair.
+   *     <p>This function deletes the key/data pair to which the cursor refers.
    * @param flags flags (either null or {@link PutFlags#MDB_NODUPDATA}
    */
   @Deprecated
@@ -132,9 +129,7 @@ public void delete(final PutFlagSet flags) {
       txn.checkReady();
       txn.checkWritesAllowed();
     }
-    final PutFlagSet putFlagSet = flags != null
-        ? flags
-        : PutFlagSet.EMPTY;
+    final PutFlagSet putFlagSet = flags != null ? flags : PutFlagSet.EMPTY;
     checkRc(LIB.mdb_cursor_del(ptrCursor, putFlagSet.getMask()));
   }
 
@@ -257,12 +252,8 @@ public boolean prev() {
   }
 
   /**
-   * @deprecated Use {@link Cursor#put(Object, Object, PutFlagSet)} instead.
-   * <hr>
-   * Store by cursor.
-   *
-   * <p>This function stores key/data pairs into the database.
-   *
+   * @deprecated Use {@link Cursor#put(Object, Object, PutFlagSet)} instead. <hr> Store by cursor.
+   *     <p>This function stores key/data pairs into the database.
    * @param key key to store
    * @param val data to store
    * @param flags options for this operation
@@ -310,10 +301,9 @@ public boolean put(final T key, final T val, final PutFlagSet flags) {
     }
     final Pointer transientKey = kv.keyIn(key);
     final Pointer transientVal = kv.valIn(val);
-    final PutFlagSet putFlagSet = flags != null
-        ? flags
-        : PutFlagSet.EMPTY;
-    final int rc = LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(), putFlagSet.getMask());
+    final PutFlagSet putFlagSet = flags != null ? flags : PutFlagSet.EMPTY;
+    final int rc =
+        LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(), putFlagSet.getMask());
     if (rc == MDB_KEYEXIST) {
       if (putFlagSet.isSet(MDB_NOOVERWRITE)) {
         kv.valOut(); // marked as in,out in LMDB C docs
@@ -331,15 +321,12 @@ public boolean put(final T key, final T val, final PutFlagSet flags) {
   }
 
   /**
-   * @deprecated Use {@link Cursor#put(Object, Object, PutFlagSet)} instead.
-   * <hr>
-   * Put multiple values into the database in one <code>MDB_MULTIPLE</code> operation.
-   *
-   * <p>The database must have been opened with {@link DbiFlags#MDB_DUPFIXED}. The buffer must
-   * contain fixed-sized values to be inserted. The size of each element is calculated from the
-   * buffer's size divided by the given element count. For example, to populate 10 X 4 byte integers
-   * at once, present a buffer of 40 bytes and specify the element as 10.
-   *
+   * @deprecated Use {@link Cursor#put(Object, Object, PutFlagSet)} instead. <hr> Put multiple
+   *     values into the database in one <code>MDB_MULTIPLE</code> operation.
+   *     <p>The database must have been opened with {@link DbiFlags#MDB_DUPFIXED}. The buffer must
+   *     contain fixed-sized values to be inserted. The size of each element is calculated from the
+   *     buffer's size divided by the given element count. For example, to populate 10 X 4 byte
+   *     integers at once, present a buffer of 40 bytes and specify the element as 10.
    * @param key key to store in the database (not null)
    * @param val value to store in the database (not null)
    * @param elements number of elements contained in the passed value buffer
@@ -377,8 +364,8 @@ public void putMultiple(final T key, final T val, final int elements) {
    * @param key key to store in the database (not null)
    * @param val value to store in the database (not null)
    * @param elements number of elements contained in the passed value buffer
-   * @param flags options for operation (must set <code>MDB_MULTIPLE</code>)
-   *              Either a {@link PutFlagSet} or a single {@link PutFlags}.
+   * @param flags options for operation (must set <code>MDB_MULTIPLE</code>) Either a {@link
+   *     PutFlagSet} or a single {@link PutFlags}.
    */
   public void putMultiple(final T key, final T val, final int elements, final PutFlagSet flags) {
     if (SHOULD_CHECK) {
@@ -389,15 +376,14 @@ public void putMultiple(final T key, final T val, final int elements, final PutF
       txn.checkReady();
       txn.checkWritesAllowed();
     }
-    final PutFlagSet putFlagSet = flags != null
-        ? flags
-        : PutFlagSet.EMPTY;
+    final PutFlagSet putFlagSet = flags != null ? flags : PutFlagSet.EMPTY;
     if (SHOULD_CHECK && !putFlagSet.isSet(MDB_MULTIPLE)) {
       throw new IllegalArgumentException("Must set " + MDB_MULTIPLE + " flag");
     }
     final Pointer transientKey = txn.kv().keyIn(key);
     final Pointer dataPtr = txn.kv().valInMulti(val, elements);
-    final int rc = LIB.mdb_cursor_put(ptrCursor, txn.kv().pointerKey(), dataPtr, putFlagSet.getMask());
+    final int rc =
+        LIB.mdb_cursor_put(ptrCursor, txn.kv().pointerKey(), dataPtr, putFlagSet.getMask());
     checkRc(rc);
     ReferenceUtil.reachabilityFence0(transientKey);
     ReferenceUtil.reachabilityFence0(dataPtr);
@@ -429,16 +415,13 @@ public void renew(final Txn<T> newTxn) {
   }
 
   /**
-   * @deprecated Use {@link Cursor#reserve(Object, int, PutFlagSet)} instead.
-   * <hr>
-   * Reserve space for data of the given size, but don't copy the given val. Instead, return a
-   * pointer to the reserved space, which the caller can fill in later - before the next update
-   * operation or the transaction ends. This saves an extra memcpy if the data is being generated
-   * later. LMDB does nothing else with this memory, the caller is expected to modify all of the
-   * space requested.
-   *
-   * <p>This flag must not be specified if the database was opened with MDB_DUPSORT
-   *
+   * @deprecated Use {@link Cursor#reserve(Object, int, PutFlagSet)} instead. <hr> Reserve space for
+   *     data of the given size, but don't copy the given val. Instead, return a pointer to the
+   *     reserved space, which the caller can fill in later - before the next update operation or
+   *     the transaction ends. This saves an extra memcpy if the data is being generated later. LMDB
+   *     does nothing else with this memory, the caller is expected to modify all of the space
+   *     requested.
+   *     <p>This flag must not be specified if the database was opened with MDB_DUPSORT
    * @param key key to store in the database (not null)
    * @param size size of the value to be stored in the database (not null)
    * @param flags options for this operation
@@ -452,9 +435,9 @@ public T reserve(final T key, final int size, final PutFlags... flags) {
   /**
    * Reserve space for data of the given size, but don't copy the given val. Instead, return a
    * pointer to the reserved space, which the caller can fill in later - before the next update
-   * operation or the transaction ends. This saves an extra {@code memcpy} if the data is being generated
-   * later. LMDB does nothing else with this memory, the caller is expected to modify all the
-   * space requested.
+   * operation or the transaction ends. This saves an extra {@code memcpy} if the data is being
+   * generated later. LMDB does nothing else with this memory, the caller is expected to modify all
+   * the space requested.
    *
    * <p>This flag must not be specified if the database was opened with MDB_DUPSORT
    *
@@ -470,8 +453,8 @@ public T reserve(final T key, final int size) {
    * Reserve space for data of the given size, but don't copy the given val. Instead, return a
    * pointer to the reserved space, which the caller can fill in later - before the next update
    * operation or the transaction ends. This saves an extra memcpy if the data is being generated
-   * later. LMDB does nothing else with this memory, the caller is expected to modify all the
-   * space requested.
+   * later. LMDB does nothing else with this memory, the caller is expected to modify all the space
+   * requested.
    *
    * <p>This flag must not be specified if the database was opened with MDB_DUPSORT
    *
@@ -490,9 +473,7 @@ public T reserve(final T key, final int size, final PutFlagSet flags) {
     }
     final Pointer transientKey = kv.keyIn(key);
     final Pointer transientVal = kv.valIn(size);
-    final PutFlagSet putFlagSet = flags != null
-        ? flags
-        : PutFlagSet.EMPTY;
+    final PutFlagSet putFlagSet = flags != null ? flags : PutFlagSet.EMPTY;
     // This is inconsistent with putMultiple which require MDB_MULTIPLE to be in the set.
     final int flagsMask = putFlagSet.getMaskWith(MDB_RESERVE);
     checkRc(LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(), flagsMask));
diff --git a/src/main/java/org/lmdbjava/CursorIterable.java b/src/main/java/org/lmdbjava/CursorIterable.java
index 89dc5e84..2289f130 100644
--- a/src/main/java/org/lmdbjava/CursorIterable.java
+++ b/src/main/java/org/lmdbjava/CursorIterable.java
@@ -239,10 +239,8 @@ enum State {
     TERMINATED
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   static class JavaRangeComparator<T> implements RangeComparator {
 
     private final Comparator<T> comparator;
@@ -276,10 +274,8 @@ public void close() throws Exception {
     }
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   /**
    * Calls down to mdb_cmp to make use of the comparator that LMDB uses for insertion order. Has a
    * very slight overhead as compared to {@link JavaRangeComparator}.
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index 65527224..12ff6a36 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -51,6 +51,7 @@ public final class Dbi<T> {
 
   @SuppressWarnings("FieldCanBeLocal") // Needs to be instance variable for FFI
   private final ComparatorCallback callbackComparator;
+
   private boolean cleaned;
   // Used for CursorIterable KeyRange testing and/or native callbacks
   private final Comparator<T> comparator;
@@ -60,7 +61,8 @@ public final class Dbi<T> {
   private final BufferProxy<T> proxy;
   private final DbiFlagSet dbiFlagSet;
 
-  Dbi(final Env<T> env,
+  Dbi(
+      final Env<T> env,
       final Txn<T> txn,
       final byte[] name,
       final BufferProxy<T> proxy,
@@ -218,7 +220,7 @@ public void drop(final Txn<T> txn) {
    * closed. See {@link #close()} for implication of handle close. Otherwise, only the data in this
    * database will be dropped.
    *
-   * @param txn    transaction handle (not null; not committed; must be R-W)
+   * @param txn transaction handle (not null; not committed; must be R-W)
    * @param delete whether database should be deleted.
    */
   public void drop(final Txn<T> txn, final boolean delete) {
@@ -280,12 +282,11 @@ public String getNameAsString() {
     return getNameAsString(Env.DEFAULT_NAME_CHARSET);
   }
 
-
   /**
    * Obtains the name of this database, using the supplied {@link Charset}.
    *
-   * @return The name of the database. If this is the unnamed database an empty
-   * string will be returned.
+   * @return The name of the database. If this is the unnamed database an empty string will be
+   *     returned.
    * @throws RuntimeException if the name can't be decoded.
    */
   public String getNameAsString(final Charset charset) {
@@ -314,7 +315,7 @@ public CursorIterable<T> iterate(final Txn<T> txn) {
   /**
    * Iterate the database in accordance with the provided {@link KeyRange}.
    *
-   * @param txn   transaction handle (not null; not committed)
+   * @param txn transaction handle (not null; not committed)
    * @param range range of acceptable keys (not null)
    * @return iterator (never null)
    */
@@ -395,21 +396,18 @@ public void put(final T key, final T val) {
   }
 
   /**
-   * @param txn   transaction handle (not null; not committed; must be R-W)
-   * @param key   key to store in the database (not null)
-   * @param val   value to store in the database (not null)
+   * @param txn transaction handle (not null; not committed; must be R-W)
+   * @param key key to store in the database (not null)
+   * @param val value to store in the database (not null)
    * @param flags Special options for this operation
    * @return true if the value was put, false if MDB_NOOVERWRITE or MDB_NODUPDATA were set and the
-   * key/value existed already.
+   *     key/value existed already.
    * @deprecated Use {@link Dbi#put(Txn, Object, Object, PutFlagSet)} instead, with a statically
-   * held {@link PutFlagSet}.
-   * <hr>
-   * <p>
-   * Store a key/value pair in the database.
-   * </p>
-   * <p>This function stores key/data pairs in the database. The default behavior is to enter the
-   * new key/data pair, replacing any previously existing key if duplicates are disallowed, or
-   * adding a duplicate data item if duplicates are allowed ({@link DbiFlags#MDB_DUPSORT}).
+   *     held {@link PutFlagSet}. <hr>
+   *     <p>Store a key/value pair in the database.
+   *     <p>This function stores key/data pairs in the database. The default behavior is to enter
+   *     the new key/data pair, replacing any previously existing key if duplicates are disallowed,
+   *     or adding a duplicate data item if duplicates are allowed ({@link DbiFlags#MDB_DUPSORT}).
    */
   @Deprecated
   public boolean put(final Txn<T> txn, final T key, final T val, final PutFlags... flags) {
@@ -423,7 +421,7 @@ public boolean put(final Txn<T> txn, final T key, final T val, final PutFlags...
    * @param key key to store in the database (not null)
    * @param val value to store in the database (not null)
    * @return true if the value was put, false if MDB_NOOVERWRITE or MDB_NODUPDATA were set and the
-   * key/value existed already.
+   *     key/value existed already.
    * @see #put(Txn, Object, Object, PutFlagSet)
    */
   public boolean put(final Txn<T> txn, final T key, final T val) {
@@ -437,12 +435,12 @@ public boolean put(final Txn<T> txn, final T key, final T val) {
    * new key/data pair, replacing any previously existing key if duplicates are disallowed, or
    * adding a duplicate data item if duplicates are allowed ({@link DbiFlags#MDB_DUPSORT}).
    *
-   * @param txn   transaction handle (not null; not committed; must be R-W)
-   * @param key   key to store in the database (not null)
-   * @param val   value to store in the database (not null)
+   * @param txn transaction handle (not null; not committed; must be R-W)
+   * @param key key to store in the database (not null)
+   * @param val value to store in the database (not null)
    * @param flags Special options for this operation.
    * @return true if the value was put, false if MDB_NOOVERWRITE or MDB_NODUPDATA were set and the
-   * key/value existed already.
+   *     key/value existed already.
    */
   public boolean put(final Txn<T> txn, final T key, final T val, final PutFlagSet flags) {
     if (SHOULD_CHECK) {
@@ -456,7 +454,9 @@ public boolean put(final Txn<T> txn, final T key, final T val, final PutFlagSet
     final PutFlagSet flagSet = flags != null ? flags : PutFlagSet.empty();
     final Pointer transientKey = txn.kv().keyIn(key);
     final Pointer transientVal = txn.kv().valIn(val);
-    final int rc = LIB.mdb_put(txn.pointer(), ptr, txn.kv().pointerKey(), txn.kv().pointerVal(), flagSet.getMask());
+    final int rc =
+        LIB.mdb_put(
+            txn.pointer(), ptr, txn.kv().pointerKey(), txn.kv().pointerVal(), flagSet.getMask());
     if (rc == MDB_KEYEXIST) {
       if (flagSet.isSet(MDB_NOOVERWRITE)) {
         txn.kv().valOut(); // marked as in,out in LMDB C docs
@@ -482,10 +482,10 @@ public boolean put(final Txn<T> txn, final T key, final T val, final PutFlagSet
    *
    * <p>This flag must not be specified if the database was opened with MDB_DUPSORT
    *
-   * @param txn  transaction handle (not null; not committed; must be R-W)
-   * @param key  key to store in the database (not null)
+   * @param txn transaction handle (not null; not committed; must be R-W)
+   * @param key key to store in the database (not null)
    * @param size size of the value to be stored in the database
-   * @param op   options for this operation
+   * @param op options for this operation
    * @return a buffer that can be used to modify the value
    */
   public T reserve(final Txn<T> txn, final T key, final int size, final PutFlags... op) {
@@ -545,15 +545,10 @@ public String toString() {
     } catch (Exception e) {
       name = "?";
     }
-    return "Dbi{" +
-        "name='" + name +
-        "', dbiFlagSet=" + dbiFlagSet +
-        '}';
+    return "Dbi{" + "name='" + name + "', dbiFlagSet=" + dbiFlagSet + '}';
   }
 
-  /**
-   * The specified DBI was changed unexpectedly.
-   */
+  /** The specified DBI was changed unexpectedly. */
   public static final class BadDbiException extends LmdbNativeException {
 
     static final int MDB_BAD_DBI = -30_780;
@@ -564,9 +559,7 @@ public static final class BadDbiException extends LmdbNativeException {
     }
   }
 
-  /**
-   * Unsupported size of key/DB name/data, or wrong DUPFIXED size.
-   */
+  /** Unsupported size of key/DB name/data, or wrong DUPFIXED size. */
   public static final class BadValueSizeException extends LmdbNativeException {
 
     static final int MDB_BAD_VALSIZE = -30_781;
@@ -577,9 +570,7 @@ public static final class BadValueSizeException extends LmdbNativeException {
     }
   }
 
-  /**
-   * Environment maxdbs reached.
-   */
+  /** Environment maxdbs reached. */
   public static final class DbFullException extends LmdbNativeException {
 
     static final int MDB_DBS_FULL = -30_791;
@@ -612,9 +603,7 @@ public static final class IncompatibleException extends LmdbNativeException {
     }
   }
 
-  /**
-   * Key/data pair already exists.
-   */
+  /** Key/data pair already exists. */
   public static final class KeyExistsException extends LmdbNativeException {
 
     static final int MDB_KEYEXIST = -30_799;
@@ -625,9 +614,7 @@ public static final class KeyExistsException extends LmdbNativeException {
     }
   }
 
-  /**
-   * Key/data pair not found (EOF).
-   */
+  /** Key/data pair not found (EOF). */
   public static final class KeyNotFoundException extends LmdbNativeException {
 
     static final int MDB_NOTFOUND = -30_798;
@@ -638,9 +625,7 @@ public static final class KeyNotFoundException extends LmdbNativeException {
     }
   }
 
-  /**
-   * Database contents grew beyond environment mapsize.
-   */
+  /** Database contents grew beyond environment mapsize. */
   public static final class MapResizedException extends LmdbNativeException {
 
     static final int MDB_MAP_RESIZED = -30_785;
diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
index 7824458b..d5d1af8c 100644
--- a/src/main/java/org/lmdbjava/DbiBuilder.java
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -28,37 +28,29 @@
  */
 public class DbiBuilder<T> {
 
-
   private final Env<T> env;
   private final BufferProxy<T> proxy;
   private final boolean readOnly;
   private byte[] name;
 
-  DbiBuilder(final Env<T> env,
-             final BufferProxy<T> proxy,
-             final boolean readOnly) {
+  DbiBuilder(final Env<T> env, final BufferProxy<T> proxy, final boolean readOnly) {
     this.env = Objects.requireNonNull(env);
     this.proxy = Objects.requireNonNull(proxy);
     this.readOnly = readOnly;
   }
 
   /**
-   * <p>
    * Create the {@link Dbi} with the passed name.
-   * </p>
-   * <p>
-   * The name will be converted into bytes using {@link StandardCharsets#UTF_8}.
-   * </p>
    *
-   * @param name The name of the database or null for the unnamed database
-   *             (see also {@link DbiBuilder#withoutDbName()})
+   * <p>The name will be converted into bytes using {@link StandardCharsets#UTF_8}.
+   *
+   * @param name The name of the database or null for the unnamed database (see also {@link
+   *     DbiBuilder#withoutDbName()})
    * @return The next builder stage.
    */
   public DbiBuilderStage2<T> setDbName(final String name) {
     // Null name is allowed so no null check
-    final byte[] nameBytes = name == null
-        ? null
-        : name.getBytes(Env.DEFAULT_NAME_CHARSET);
+    final byte[] nameBytes = name == null ? null : name.getBytes(Env.DEFAULT_NAME_CHARSET);
     return setDbName(nameBytes);
   }
 
@@ -75,16 +67,14 @@ public DbiBuilderStage2<T> setDbName(final byte[] name) {
   }
 
   /**
-   * <p>
    * Create the {@link Dbi} without a name.
-   * </p>
-   * <p>
-   * Equivalent to passing null to
-   * {@link DbiBuilder#setDbName(String)} or {@link DbiBuilder#setDbName(byte[])}.
-   * </p>
-   * <p>Note: The 'unnamed database' is used by LMDB to store the names of named databases, with
-   * the database name being the key. Use of the unnamed database is intended for simple applications
-   * with only one database.</p>
+   *
+   * <p>Equivalent to passing null to {@link DbiBuilder#setDbName(String)} or {@link
+   * DbiBuilder#setDbName(byte[])}.
+   *
+   * <p>Note: The 'unnamed database' is used by LMDB to store the names of named databases, with the
+   * database name being the key. Use of the unnamed database is intended for simple applications
+   * with only one database.
    *
    * @return The next builder stage.
    */
@@ -92,10 +82,8 @@ public DbiBuilderStage2<T> withoutDbName() {
     return setDbName((byte[]) null);
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   /**
    * Intermediate builder stage for constructing a {@link Dbi}.
    *
@@ -113,29 +101,24 @@ private DbiBuilderStage2(final DbiBuilder<T> dbiBuilder) {
     }
 
     /**
-     * <p>
-     * This is the <strong>default</strong> choice when it comes to choosing a comparator.
-     * If you are not sure of the implications of the other methods then use this one as it
-     * is likely what you want and also probably the most performant.
-     * </p>
-     * <p>
-     * With this option, {@link CursorIterable} will make use of the LmdbJava's default
-     * Java-side comparators when comparing iteration keys to the start/stop keys.
-     * LMDB will use its own comparator for controlling insertion order in the database.
-     * The two comparators are functionally identical.
-     * </p>
-     * <p>
-     * This option may be slightly more performant than when using
-     * {@link DbiBuilderStage2#withNativeComparator()} which calls down to LMDB for ALL
-     * comparison operations.
-     * </p>
-     * <p>
-     * If you do not intend to use {@link CursorIterable} then it doesn't matter whether
-     * you choose {@link DbiBuilderStage2#withNativeComparator()},
-     * {@link DbiBuilderStage2#withDefaultComparator()} or
-     * {@link DbiBuilderStage2#withIteratorComparator(ComparatorFactory)} as these comparators will
-     * never be used.
-     * </p>
+     * This is the <strong>default</strong> choice when it comes to choosing a comparator. If you
+     * are not sure of the implications of the other methods then use this one as it is likely what
+     * you want and also probably the most performant.
+     *
+     * <p>With this option, {@link CursorIterable} will make use of the LmdbJava's default Java-side
+     * comparators when comparing iteration keys to the start/stop keys. LMDB will use its own
+     * comparator for controlling insertion order in the database. The two comparators are
+     * functionally identical.
+     *
+     * <p>This option may be slightly more performant than when using {@link
+     * DbiBuilderStage2#withNativeComparator()} which calls down to LMDB for ALL comparison
+     * operations.
+     *
+     * <p>If you do not intend to use {@link CursorIterable} then it doesn't matter whether you
+     * choose {@link DbiBuilderStage2#withNativeComparator()}, {@link
+     * DbiBuilderStage2#withDefaultComparator()} or {@link
+     * DbiBuilderStage2#withIteratorComparator(ComparatorFactory)} as these comparators will never
+     * be used.
      *
      * @return The next builder stage.
      */
@@ -145,24 +128,20 @@ public DbiBuilderStage3<T> withDefaultComparator() {
     }
 
     /**
-     * <p>
      * With this option, {@link CursorIterable} will call down to LMDB's {@code mdb_cmp} method when
      * comparing iteration keys to start/stop keys. This ensures LmdbJava is comparing start/stop
      * keys using the same comparator that is used for insertion order into the db.
-     * </p>
-     * <p>
-     * This option may be slightly less performant than when using
-     * {@link DbiBuilderStage2#withDefaultComparator()} as it needs to call down
-     * to LMDB to perform the comparisons, however it guarantees that {@link CursorIterable}
-     * key comparison matches LMDB key comparison.
-     * </p>
-     * <p>
-     * If you do not intend to use {@link CursorIterable} then it doesn't matter whether
-     * you choose {@link DbiBuilderStage2#withNativeComparator()},
-     * {@link DbiBuilderStage2#withDefaultComparator()} or
-     * {@link DbiBuilderStage2#withIteratorComparator(ComparatorFactory)} as these comparators will
-     * never be used.
-     * </p>
+     *
+     * <p>This option may be slightly less performant than when using {@link
+     * DbiBuilderStage2#withDefaultComparator()} as it needs to call down to LMDB to perform the
+     * comparisons, however it guarantees that {@link CursorIterable} key comparison matches LMDB
+     * key comparison.
+     *
+     * <p>If you do not intend to use {@link CursorIterable} then it doesn't matter whether you
+     * choose {@link DbiBuilderStage2#withNativeComparator()}, {@link
+     * DbiBuilderStage2#withDefaultComparator()} or {@link
+     * DbiBuilderStage2#withIteratorComparator(ComparatorFactory)} as these comparators will never
+     * be used.
      *
      * @return The next builder stage.
      */
@@ -171,30 +150,27 @@ public DbiBuilderStage3<T> withNativeComparator() {
       return new DbiBuilderStage3<>(this);
     }
 
-
     /**
      * Provide a java-side {@link Comparator} that LMDB will call back to for <strong>all</strong>
-     * comparison operations.
-     * Therefore, it will be called by LMDB to manage database insertion/iteration order.
-     * It will also be used for {@link CursorIterable} start/stop key comparisons.
-     * <p>
-     * It can be useful if you need to sort your database using some other method,
-     * e.g. signed keys or case-insensitive order.
-     * Note, if you need keys stored in reverse order, see {@link DbiFlags#MDB_REVERSEKEY}
-     * and {@link DbiFlags#MDB_REVERSEDUP}.
-     * </p>
-     * <p>
-     * As this requires LMDB to call back to java, this will be less performant than using LMDB's
-     * default comparators, but allows for total control over the order in which entries
-     * are stored in the database.
-     * </p>
+     * comparison operations. Therefore, it will be called by LMDB to manage database
+     * insertion/iteration order. It will also be used for {@link CursorIterable} start/stop key
+     * comparisons.
+     *
+     * <p>It can be useful if you need to sort your database using some other method, e.g. signed
+     * keys or case-insensitive order. Note, if you need keys stored in reverse order, see {@link
+     * DbiFlags#MDB_REVERSEKEY} and {@link DbiFlags#MDB_REVERSEDUP}.
      *
-     * @param comparatorFactory A factory to create a comparator. {@link ComparatorFactory#create(DbiFlagSet)}
-     *                          will be called once during the initialisation of the {@link Dbi}. It must
-     *                          not return null.
+     * <p>As this requires LMDB to call back to java, this will be less performant than using LMDB's
+     * default comparators, but allows for total control over the order in which entries are stored
+     * in the database.
+     *
+     * @param comparatorFactory A factory to create a comparator. {@link
+     *     ComparatorFactory#create(DbiFlagSet)} will be called once during the initialisation of
+     *     the {@link Dbi}. It must not return null.
      * @return The next builder stage.
      */
-    public DbiBuilderStage3<T> withCallbackComparator(final ComparatorFactory<T> comparatorFactory) {
+    public DbiBuilderStage3<T> withCallbackComparator(
+        final ComparatorFactory<T> comparatorFactory) {
       this.comparatorFactory = Objects.requireNonNull(comparatorFactory);
       this.comparatorType = ComparatorType.CALLBACK;
       return new DbiBuilderStage3<>(this);
@@ -202,44 +178,39 @@ public DbiBuilderStage3<T> withCallbackComparator(final ComparatorFactory<T> com
 
     /**
      * <hr>
-     * <p>
-     * <strong>WARNING</strong>: Only use this if you fully understand the risks and implications.
-     * </p>
-     * <hr>
-     * <p>
-     * With this option, {@link CursorIterable} will make use of the passed comparator for
+     *
+     * <p><strong>WARNING</strong>: Only use this if you fully understand the risks and
+     * implications. <hr>
+     *
+     * <p>With this option, {@link CursorIterable} will make use of the passed comparator for
      * comparing iteration keys to start/stop keys. It has <strong>NO</strong> bearing on the
      * insert/iteration order of the database (which is controlled by LMDB's own comparators).
-     * </p>
-     * <p>
-     * It is <strong>vital</strong> that this comparator is functionally identical to the one
+     *
+     * <p>It is <strong>vital</strong> that this comparator is functionally identical to the one
      * used internally in LMDB for insertion/iteration order, else you will see unexpected behaviour
      * when using {@link CursorIterable}.
-     * </p>
-     * <p>
-     * If you do not intend to use {@link CursorIterable} then it doesn't matter whether
-     * you choose {@link DbiBuilderStage2#withNativeComparator()},
-     * {@link DbiBuilderStage2#withDefaultComparator()} or
-     * {@link DbiBuilderStage2#withIteratorComparator(ComparatorFactory)} as these comparators will
-     * never be used.
-     * </p>
      *
-     * @param comparatorFactory The comparator to use with {@link CursorIterable}.
-     *                          {@link ComparatorFactory#create(DbiFlagSet)} will be called once during the
-     *                          initialisation of the {@link Dbi}. It must not return null.
+     * <p>If you do not intend to use {@link CursorIterable} then it doesn't matter whether you
+     * choose {@link DbiBuilderStage2#withNativeComparator()}, {@link
+     * DbiBuilderStage2#withDefaultComparator()} or {@link
+     * DbiBuilderStage2#withIteratorComparator(ComparatorFactory)} as these comparators will never
+     * be used.
+     *
+     * @param comparatorFactory The comparator to use with {@link CursorIterable}. {@link
+     *     ComparatorFactory#create(DbiFlagSet)} will be called once during the initialisation of
+     *     the {@link Dbi}. It must not return null.
      * @return The next builder stage.
      */
-    public DbiBuilderStage3<T> withIteratorComparator(final ComparatorFactory<T> comparatorFactory) {
+    public DbiBuilderStage3<T> withIteratorComparator(
+        final ComparatorFactory<T> comparatorFactory) {
       this.comparatorFactory = Objects.requireNonNull(comparatorFactory);
       this.comparatorType = ComparatorType.ITERATOR;
       return new DbiBuilderStage3<>(this);
     }
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   /**
    * Final stage builder for constructing a {@link Dbi}.
    *
@@ -248,7 +219,8 @@ public DbiBuilderStage3<T> withIteratorComparator(final ComparatorFactory<T> com
   public static class DbiBuilderStage3<T> {
 
     private final DbiBuilderStage2<T> dbiBuilderStage2;
-    private final AbstractFlagSet.Builder<DbiFlags, DbiFlagSet> flagSetBuilder = DbiFlagSet.builder();
+    private final AbstractFlagSet.Builder<DbiFlags, DbiFlagSet> flagSetBuilder =
+        DbiFlagSet.builder();
     private Txn<T> txn = null;
 
     private DbiBuilderStage3(DbiBuilderStage2<T> dbiBuilderStage2) {
@@ -256,68 +228,49 @@ private DbiBuilderStage3(DbiBuilderStage2<T> dbiBuilderStage2) {
     }
 
     /**
-     * <p>
      * Apply all the dbi flags supplied in dbiFlags.
-     * </p>
-     * <p>
-     * Clears all flags currently set by previous calls to
-     * {@link DbiBuilderStage3#setDbiFlags(Collection)},
-     * {@link DbiBuilderStage3#setDbiFlags(DbiFlags...)}
+     *
+     * <p>Clears all flags currently set by previous calls to {@link
+     * DbiBuilderStage3#setDbiFlags(Collection)}, {@link DbiBuilderStage3#setDbiFlags(DbiFlags...)}
      * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
-     * </p>
      *
-     * @param dbiFlags to open the database with.
-     *                 A null {@link Collection} will just clear all set flags.
-     *                 Null items are ignored.
+     * @param dbiFlags to open the database with. A null {@link Collection} will just clear all set
+     *     flags. Null items are ignored.
      */
     public DbiBuilderStage3<T> setDbiFlags(final Collection<DbiFlags> dbiFlags) {
       flagSetBuilder.clear();
       if (dbiFlags != null) {
-        dbiFlags.stream()
-            .filter(Objects::nonNull)
-            .forEach(dbiFlags::add);
+        dbiFlags.stream().filter(Objects::nonNull).forEach(dbiFlags::add);
       }
       return this;
     }
 
     /**
-     * <p>
      * Apply all the dbi flags supplied in dbiFlags.
-     * </p>
-     * <p>
-     * Clears all flags currently set by previous calls to
-     * {@link DbiBuilderStage3#setDbiFlags(Collection)},
-     * {@link DbiBuilderStage3#setDbiFlags(DbiFlags...)}
+     *
+     * <p>Clears all flags currently set by previous calls to {@link
+     * DbiBuilderStage3#setDbiFlags(Collection)}, {@link DbiBuilderStage3#setDbiFlags(DbiFlags...)}
      * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
-     * </p>
      *
-     * @param dbiFlags to open the database with.
-     *                 A null array will just clear all set flags.
-     *                 Null items are ignored.
+     * @param dbiFlags to open the database with. A null array will just clear all set flags. Null
+     *     items are ignored.
      */
     public DbiBuilderStage3<T> setDbiFlags(final DbiFlags... dbiFlags) {
       flagSetBuilder.clear();
       if (dbiFlags != null) {
-        Arrays.stream(dbiFlags)
-            .filter(Objects::nonNull)
-            .forEach(this.flagSetBuilder::addFlag);
+        Arrays.stream(dbiFlags).filter(Objects::nonNull).forEach(this.flagSetBuilder::addFlag);
       }
       return this;
     }
 
     /**
-     * <p>
      * Apply all the dbi flags supplied in dbiFlags.
-     * </p>
-     * <p>
-     * Clears all flags currently set by previous calls to
-     * {@link DbiBuilderStage3#setDbiFlags(Collection)},
-     * {@link DbiBuilderStage3#setDbiFlags(DbiFlags...)}
+     *
+     * <p>Clears all flags currently set by previous calls to {@link
+     * DbiBuilderStage3#setDbiFlags(Collection)}, {@link DbiBuilderStage3#setDbiFlags(DbiFlags...)}
      * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
-     * </p>
      *
-     * @param dbiFlagSet to open the database with.
-     *                   A null value will just clear all set flags.
+     * @param dbiFlagSet to open the database with. A null value will just clear all set flags.
      */
     public DbiBuilderStage3<T> setDbiFlags(final DbiFlagSet dbiFlagSet) {
       flagSetBuilder.clear();
@@ -328,9 +281,8 @@ public DbiBuilderStage3<T> setDbiFlags(final DbiFlagSet dbiFlagSet) {
     }
 
     /**
-     * Adds a dbiFlag to those flags already added to this builder by
-     * {@link DbiBuilderStage3#setDbiFlags(DbiFlags...)},
-     * {@link DbiBuilderStage3#setDbiFlags(Collection)}
+     * Adds a dbiFlag to those flags already added to this builder by {@link
+     * DbiBuilderStage3#setDbiFlags(DbiFlags...)}, {@link DbiBuilderStage3#setDbiFlags(Collection)}
      * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
      *
      * @param dbiFlag to add to any existing flags. A null value is a no-op.
@@ -342,9 +294,8 @@ public DbiBuilderStage3<T> addDbiFlag(final DbiFlags dbiFlag) {
     }
 
     /**
-     * Adds a dbiFlag to those flags already added to this builder by
-     * {@link DbiBuilderStage3#setDbiFlags(DbiFlags...)},
-     * {@link DbiBuilderStage3#setDbiFlags(Collection)}
+     * Adds a dbiFlag to those flags already added to this builder by {@link
+     * DbiBuilderStage3#setDbiFlags(DbiFlags...)}, {@link DbiBuilderStage3#setDbiFlags(Collection)}
      * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
      *
      * @param dbiFlagSet to add to any existing flags. A null value is a no-op.
@@ -359,19 +310,17 @@ public DbiBuilderStage3<T> addDbiFlags(final DbiFlagSet dbiFlagSet) {
 
     /**
      * Use the supplied transaction to open the {@link Dbi}.
-     * <p>
-     * The caller MUST commit the transaction after calling {@link DbiBuilderStage3#open()},
-     * in order to retain the <code>Dbi</code> in the <code>Env</code>.
-     * </p>
-     * <p>
-     * If you don't call this method to supply a {@link Txn}, a {@link Txn} will be opened for the purpose
-     * of creating and opening the {@link Dbi}, then closed. Therefore, if you already have a transaction
-     * open, you should supply that to avoid one blocking the other.
-     * </p>
      *
-     * @param txn transaction to use (required; not closed). If the {@link Env} was opened
-     *            with the {@link EnvFlags#MDB_RDONLY_ENV} flag, the {@link Txn} can be read-only,
-     *            else it needs to be a read/write {@link Txn}.
+     * <p>The caller MUST commit the transaction after calling {@link DbiBuilderStage3#open()}, in
+     * order to retain the <code>Dbi</code> in the <code>Env</code>.
+     *
+     * <p>If you don't call this method to supply a {@link Txn}, a {@link Txn} will be opened for
+     * the purpose of creating and opening the {@link Dbi}, then closed. Therefore, if you already
+     * have a transaction open, you should supply that to avoid one blocking the other.
+     *
+     * @param txn transaction to use (required; not closed). If the {@link Env} was opened with the
+     *     {@link EnvFlags#MDB_RDONLY_ENV} flag, the {@link Txn} can be read-only, else it needs to
+     *     be a read/write {@link Txn}.
      * @return this builder instance.
      */
     public DbiBuilderStage3<T> setTxn(final Txn<T> txn) {
@@ -381,10 +330,9 @@ public DbiBuilderStage3<T> setTxn(final Txn<T> txn) {
 
     /**
      * Construct and open the {@link Dbi}.
-     * <p>
-     * If a {@link Txn} was supplied to the builder, it is the callers responsibility to
-     * commit and close the txn upon return from this method, else the created DB won't be retained.
-     * </p>
+     *
+     * <p>If a {@link Txn} was supplied to the builder, it is the callers responsibility to commit
+     * and close the txn upon return from this method, else the created DB won't be retained.
      *
      * @return A newly constructed and opened {@link Dbi}.
      */
@@ -403,14 +351,13 @@ public Dbi<T> open() {
     }
 
     private Txn<T> getTxn(final DbiBuilder<T> dbiBuilder) {
-      return dbiBuilder.readOnly
-          ? dbiBuilder.env.txnRead()
-          : dbiBuilder.env.txnWrite();
+      return dbiBuilder.readOnly ? dbiBuilder.env.txnRead() : dbiBuilder.env.txnWrite();
     }
 
-    private Comparator<T> getComparator(final DbiBuilder<T> dbiBuilder,
-                                        final ComparatorType comparatorType,
-                                        final DbiFlagSet dbiFlagSet) {
+    private Comparator<T> getComparator(
+        final DbiBuilder<T> dbiBuilder,
+        final ComparatorType comparatorType,
+        final DbiFlagSet dbiFlagSet) {
       Comparator<T> comparator = null;
       switch (comparatorType) {
         case DEFAULT:
@@ -431,8 +378,7 @@ private Comparator<T> getComparator(final DbiBuilder<T> dbiBuilder,
       return comparator;
     }
 
-    private Dbi<T> openDbi(final Txn<T> txn,
-                           final DbiBuilder<T> dbiBuilder) {
+    private Dbi<T> openDbi(final Txn<T> txn, final DbiBuilder<T> dbiBuilder) {
       final DbiFlagSet dbiFlagSet = flagSetBuilder.build();
       final ComparatorType comparatorType = dbiBuilderStage2.comparatorType;
       final Comparator<T> comparator = getComparator(dbiBuilder, comparatorType, dbiFlagSet);
@@ -448,23 +394,17 @@ private Dbi<T> openDbi(final Txn<T> txn,
     }
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   private enum ComparatorType {
     /**
-     * Default Java comparator for {@link CursorIterable} KeyRange testing,
-     * LMDB comparator for insertion/iteration order.
+     * Default Java comparator for {@link CursorIterable} KeyRange testing, LMDB comparator for
+     * insertion/iteration order.
      */
     DEFAULT,
-    /**
-     * Use LMDB native comparator for everything.
-     */
+    /** Use LMDB native comparator for everything. */
     NATIVE,
-    /**
-     * Use the supplied custom Java-side comparator for everything.
-     */
+    /** Use the supplied custom Java-side comparator for everything. */
     CALLBACK,
     /**
      * Use the supplied custom Java-side comparator for {@link CursorIterable} KeyRange testing,
@@ -474,14 +414,11 @@ private enum ComparatorType {
     ;
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   @FunctionalInterface
   public interface ComparatorFactory<T> {
 
     Comparator<T> create(final DbiFlagSet dbiFlagSet);
-
   }
 }
diff --git a/src/main/java/org/lmdbjava/DbiFlagSet.java b/src/main/java/org/lmdbjava/DbiFlagSet.java
index 8ffd2499..6f2d3c81 100644
--- a/src/main/java/org/lmdbjava/DbiFlagSet.java
+++ b/src/main/java/org/lmdbjava/DbiFlagSet.java
@@ -25,9 +25,7 @@ public interface DbiFlagSet extends FlagSet<DbiFlags> {
   DbiFlagSet EMPTY = DbiFlagSetImpl.EMPTY;
 
   /** The set of {@link DbiFlags} that indicate unsigned integer keys are being used. */
-  DbiFlagSet INTEGER_KEY_FLAGS = DbiFlagSet.of(
-      DbiFlags.MDB_INTEGERKEY,
-      DbiFlags.MDB_INTEGERDUP);
+  DbiFlagSet INTEGER_KEY_FLAGS = DbiFlagSet.of(DbiFlags.MDB_INTEGERKEY, DbiFlags.MDB_INTEGERDUP);
 
   static DbiFlagSet empty() {
     return DbiFlagSetImpl.EMPTY;
@@ -39,29 +37,20 @@ static DbiFlagSet of(final DbiFlags dbiFlag) {
   }
 
   static DbiFlagSet of(final DbiFlags... DbiFlags) {
-    return builder()
-        .setFlags(DbiFlags)
-        .build();
+    return builder().setFlags(DbiFlags).build();
   }
 
   static DbiFlagSet of(final Collection<DbiFlags> DbiFlags) {
-    return builder()
-        .setFlags(DbiFlags)
-        .build();
+    return builder().setFlags(DbiFlags).build();
   }
 
   static AbstractFlagSet.Builder<DbiFlags, DbiFlagSet> builder() {
     return new AbstractFlagSet.Builder<>(
-        DbiFlags.class,
-        DbiFlagSetImpl::new,
-        dbiFlag -> dbiFlag,
-        () -> DbiFlagSetImpl.EMPTY);
+        DbiFlags.class, DbiFlagSetImpl::new, dbiFlag -> dbiFlag, () -> DbiFlagSetImpl.EMPTY);
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   class DbiFlagSetImpl extends AbstractFlagSet<DbiFlags> implements DbiFlagSet {
 
     static final DbiFlagSet EMPTY = new EmptyDbiFlagSet();
@@ -71,10 +60,8 @@ private DbiFlagSetImpl(final EnumSet<DbiFlags> flags) {
     }
   }
 
-
   // --------------------------------------------------------------------------------
 
-
-  class EmptyDbiFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<DbiFlags> implements DbiFlagSet {
-  }
+  class EmptyDbiFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<DbiFlags>
+      implements DbiFlagSet {}
 }
diff --git a/src/main/java/org/lmdbjava/DbiFlags.java b/src/main/java/org/lmdbjava/DbiFlags.java
index 7c4b6794..f8ccbe20 100644
--- a/src/main/java/org/lmdbjava/DbiFlags.java
+++ b/src/main/java/org/lmdbjava/DbiFlags.java
@@ -32,30 +32,26 @@ public enum DbiFlags implements MaskedFlag, DbiFlagSet {
    * Use sorted duplicates.
    *
    * <p>Duplicate keys may be used in the database. Or, from another perspective, keys may have
-   * multiple data items, stored in sorted order. By default, keys must be unique and may have only a
-   * single data item.
-   * <p>
+   * multiple data items, stored in sorted order. By default, keys must be unique and may have only
+   * a single data item.
    *
-   * </p>
+   * <p>
    */
   MDB_DUPSORT(0x04),
   /**
-   * Numeric keys in native byte order: either unsigned int or size_t.
-   * <strong>The keys must all be of the same size.</strong>
-   * <p>
-   * This is an optimisation that is available when your keys are 4 or 8 byte unsigned numeric values.
-   * There are performance benefits for both ordered and un-ordered puts as compared to not using
-   * this flag.
-   * </p>
-   * <p>
-   * When writing the key to the buffer you must write it in native order and subsequently read any
-   * keys retrieved from LMDB (via cursor or get method) also using native order.
-   * </p>
-   * <p>
-   * For more information, see
-   * <a href="https://github.com/lmdbjava/lmdbjava/wiki/Keys#numeric-keys">Numeric Keys</a>
-   * in the LmdbJava wiki.
-   * </p>
+   * Numeric keys in native byte order: either unsigned int or size_t. <strong>The keys must all be
+   * of the same size.</strong>
+   *
+   * <p>This is an optimisation that is available when your keys are 4 or 8 byte unsigned numeric
+   * values. There are performance benefits for both ordered and un-ordered puts as compared to not
+   * using this flag.
+   *
+   * <p>When writing the key to the buffer you must write it in native order and subsequently read
+   * any keys retrieved from LMDB (via cursor or get method) also using native order.
+   *
+   * <p>For more information, see <a
+   * href="https://github.com/lmdbjava/lmdbjava/wiki/Keys#numeric-keys">Numeric Keys</a> in the
+   * LmdbJava wiki.
    */
   MDB_INTEGERKEY(0x08),
   /**
diff --git a/src/main/java/org/lmdbjava/DirectBufferProxy.java b/src/main/java/org/lmdbjava/DirectBufferProxy.java
index 3ddda467..af918943 100644
--- a/src/main/java/org/lmdbjava/DirectBufferProxy.java
+++ b/src/main/java/org/lmdbjava/DirectBufferProxy.java
@@ -91,11 +91,11 @@ public static int compareLexicographically(final DirectBuffer o1, final DirectBu
   }
 
   /**
-   * Buffer comparator specifically for 4/8 byte keys that are unsigned ints/longs,
-   * i.e. when using MDB_INTEGER_KEY/MDB_INTEGERDUP. Compares the buffers numerically.
-   * <p>
-   * Both buffer must have 4 or 8 bytes remaining
-   * </p>
+   * Buffer comparator specifically for 4/8 byte keys that are unsigned ints/longs, i.e. when using
+   * MDB_INTEGER_KEY/MDB_INTEGERDUP. Compares the buffers numerically.
+   *
+   * <p>Both buffer must have 4 or 8 bytes remaining
+   *
    * @param o1 left operand (required)
    * @param o2 right operand (required)
    * @return as specified by {@link Comparable} interface
@@ -107,8 +107,12 @@ public static int compareAsIntegerKeys(final DirectBuffer o1, final DirectBuffer
     final int len1 = o1.capacity();
     final int len2 = o2.capacity();
     if (len1 != len2) {
-      throw new RuntimeException("Length mismatch, len1: " + len1 + ", len2: " + len2
-          + ". Lengths must be identical and either 4 or 8 bytes.");
+      throw new RuntimeException(
+          "Length mismatch, len1: "
+              + len1
+              + ", len2: "
+              + len2
+              + ". Lengths must be identical and either 4 or 8 bytes.");
     }
     if (len1 == 8) {
       final long lw = o1.getLong(0, NATIVE_ORDER);
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 9b2a4360..54115b33 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -50,10 +50,9 @@
  */
 public final class Env<T> implements AutoCloseable {
 
-  /**
-   * Java system property name that can be set to disable optional checks.
-   */
+  /** Java system property name that can be set to disable optional checks. */
   public static final String DISABLE_CHECKS_PROP = "lmdbjava.disable.checks";
+
   public static final Charset DEFAULT_NAME_CHARSET = StandardCharsets.UTF_8;
 
   /**
@@ -95,7 +94,7 @@ public static Builder<ByteBuffer> create() {
   /**
    * Create an {@link Env} using the passed {@link BufferProxy}.
    *
-   * @param <T>   buffer type
+   * @param <T> buffer type
    * @param proxy the proxy to use (required)
    * @return the environment (never null)
    */
@@ -104,20 +103,17 @@ public static <T> Builder<T> create(final BufferProxy<T> proxy) {
   }
 
   /**
-   * @param path  file system destination
-   * @param size  size in megabytes
+   * @param path file system destination
+   * @param size size in megabytes
    * @param flags the flags for this new environment
    * @return env the environment (never null)
    * @deprecated Instead use {@link Env#create()} or {@link Env#create(BufferProxy)}
-   * <p>
-   * Opens an environment with a single default database in 0664 mode using the {@link
-   * ByteBufferProxy#PROXY_OPTIMAL}.
+   *     <p>Opens an environment with a single default database in 0664 mode using the {@link
+   *     ByteBufferProxy#PROXY_OPTIMAL}.
    */
   @Deprecated
   public static Env<ByteBuffer> open(final File path, final int size, final EnvFlags... flags) {
-    return new Builder<>(PROXY_OPTIMAL)
-        .setMapSize(size, ByteUnit.MEBIBYTES)
-        .open(path, flags);
+    return new Builder<>(PROXY_OPTIMAL).setMapSize(size, ByteUnit.MEBIBYTES).open(path, flags);
   }
 
   /**
@@ -170,7 +166,7 @@ public void copy(final File path) {
    * transactions, because it employs a read-only transaction. See long-lived transactions under
    * "Caveats" in the LMDB native documentation.
    *
-   * @param path  writable destination path as described above
+   * @param path writable destination path as described above
    * @param flags special options for this copy
    */
   public void copy(final File path, final CopyFlagSet flags) {
@@ -195,7 +191,7 @@ public List<byte[]> getDbiNames() {
     // The unnamed DB is special so the names of the named DBs are held as keys in it.
     final Dbi<T> unnamedDb = openDbi((byte[]) null, DbiFlagSet.EMPTY);
     try (final Txn<T> txn = txnRead();
-         final Cursor<T> cursor = unnamedDb.openCursor(txn)) {
+        final Cursor<T> cursor = unnamedDb.openCursor(txn)) {
       if (!cursor.first()) {
         return Collections.emptyList();
       }
@@ -285,8 +281,8 @@ public boolean isReadOnly() {
   }
 
   /**
-   * Open (and optionally creates, if {@link DbiFlags#MDB_CREATE} is set)
-   * a {@link Dbi} using a builder.
+   * Open (and optionally creates, if {@link DbiFlags#MDB_CREATE} is set) a {@link Dbi} using a
+   * builder.
    *
    * @return A new builder instance for creating/opening a {@link Dbi}.
    */
@@ -295,12 +291,12 @@ public DbiBuilder<T> createDbi() {
   }
 
   /**
-   * Convenience method that opens a {@link Dbi} with a UTF-8 database name and default
-   * {@link Comparator} that is not invoked from native code.
-   * <p>
-   * For more options when opening a {@link Dbi} see {@link Env#createDbi()}.
-   * </p>
-   * @param name       name of the database (or null if no name is required)
+   * Convenience method that opens a {@link Dbi} with a UTF-8 database name and default {@link
+   * Comparator} that is not invoked from native code.
+   *
+   * <p>For more options when opening a {@link Dbi} see {@link Env#createDbi()}.
+   *
+   * @param name name of the database (or null if no name is required)
    * @param dbiFlagSet Flags to open the database with
    * @return a database that is ready to use
    */
@@ -314,17 +310,16 @@ public Dbi<T> openDbi(final String name, final DbiFlagSet dbiFlagSet) {
   }
 
   /**
-   * Convenience method that opens a {@link Dbi} with a default
-   * {@link Comparator} that is not invoked from native code.
-   * <p>
-   * For more options when opening a {@link Dbi} see {@link Env#createDbi()}.
-   * </p>
-   * @param name       name of the database (or null if no name is required)
+   * Convenience method that opens a {@link Dbi} with a default {@link Comparator} that is not
+   * invoked from native code.
+   *
+   * <p>For more options when opening a {@link Dbi} see {@link Env#createDbi()}.
+   *
+   * @param name name of the database (or null if no name is required)
    * @param dbiFlagSet Flags to open the database with
    * @return a database that is ready to use
    */
-  public Dbi<T> openDbi(final byte[] name,
-                        final DbiFlagSet dbiFlagSet) {
+  public Dbi<T> openDbi(final byte[] name, final DbiFlagSet dbiFlagSet) {
     try (Txn<T> txn = readOnly ? txnRead() : txnWrite()) {
       final Dbi<T> dbi = new Dbi<>(this, txn, name, proxy, dbiFlagSet);
       txn.commit(); // even RO Txns require a commit to retain Dbi in Env
@@ -333,12 +328,12 @@ public Dbi<T> openDbi(final byte[] name,
   }
 
   /**
-   * @param name  name of the database (or null if no name is required)
+   * @param name name of the database (or null if no name is required)
    * @param flags to open the database with
    * @return a database that is ready to use
    * @deprecated Instead use {@link Env#createDbi()} or {@link Env#openDbi(String, DbiFlagSet)}
-   * Convenience method that opens a {@link Dbi} with a UTF-8 database name and default {@link
-   * Comparator} that is not invoked from native code.
+   *     Convenience method that opens a {@link Dbi} with a UTF-8 database name and default {@link
+   *     Comparator} that is not invoked from native code.
    */
   @Deprecated()
   public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
@@ -347,84 +342,73 @@ public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
   }
 
   /**
-   * @param name       name of the database (or null if no name is required)
+   * @param name name of the database (or null if no name is required)
    * @param comparator custom comparator for cursor start/stop key comparisons. If null, LMDB's
-   *                   comparator will be used.
-   * @param flags      to open the database with
+   *     comparator will be used.
+   * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#createDbi()}
-   * Convenience method that opens a {@link Dbi} with a UTF-8 database name and associated {@link
-   * Comparator} for use by {@link CursorIterable} when comparing start/stop keys.
-   *
-   * <p>It is very important that the passed comparator behaves in the same way as the comparator
-   * LMDB uses for its insertion order (for the type of data that will be stored in the database),
-   * or you fully understand the implications of them behaving differently. LMDB's comparator is
-   * unsigned lexicographical, unless {@link DbiFlags#MDB_INTEGERKEY} is used.
+   * @deprecated Instead use {@link Env#createDbi()} Convenience method that opens a {@link Dbi}
+   *     with a UTF-8 database name and associated {@link Comparator} for use by {@link
+   *     CursorIterable} when comparing start/stop keys.
+   *     <p>It is very important that the passed comparator behaves in the same way as the
+   *     comparator LMDB uses for its insertion order (for the type of data that will be stored in
+   *     the database), or you fully understand the implications of them behaving differently.
+   *     LMDB's comparator is unsigned lexicographical, unless {@link DbiFlags#MDB_INTEGERKEY} is
+   *     used.
    */
   @Deprecated()
-  public Dbi<T> openDbi(final String name,
-                        final Comparator<T> comparator,
-                        final DbiFlags... flags) {
+  public Dbi<T> openDbi(
+      final String name, final Comparator<T> comparator, final DbiFlags... flags) {
     final byte[] nameBytes = name == null ? null : name.getBytes(DEFAULT_NAME_CHARSET);
     return openDbi(nameBytes, comparator, false, flags);
   }
 
   /**
-   * @param name       name of the database (or null if no name is required)
+   * @param name name of the database (or null if no name is required)
    * @param comparator custom comparator for cursor start/stop key comparisons and optionally for
-   *                   LMDB to call back to. If null, LMDB's comparator will be used.
-   * @param nativeCb   whether LMDB native code calls back to the Java comparator
-   * @param flags      to open the database with
+   *     LMDB to call back to. If null, LMDB's comparator will be used.
+   * @param nativeCb whether LMDB native code calls back to the Java comparator
+   * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#createDbi()}
-   * Convenience method that opens a {@link Dbi} with a UTF-8 database name and associated {@link
-   * Comparator}. The comparator will be used by {@link CursorIterable} when comparing start/stop
-   * keys as a minimum. If nativeCb is {@code true}, this comparator will also be called by LMDB to
-   * determine insertion/iteration order. Calling back to a java comparator may significantly impact
-   * performance.
+   * @deprecated Instead use {@link Env#createDbi()} Convenience method that opens a {@link Dbi}
+   *     with a UTF-8 database name and associated {@link Comparator}. The comparator will be used
+   *     by {@link CursorIterable} when comparing start/stop keys as a minimum. If nativeCb is
+   *     {@code true}, this comparator will also be called by LMDB to determine insertion/iteration
+   *     order. Calling back to a java comparator may significantly impact performance.
    */
   @Deprecated()
-  public Dbi<T> openDbi(final String name,
-                        final Comparator<T> comparator,
-                        final boolean nativeCb,
-                        final DbiFlags... flags) {
+  public Dbi<T> openDbi(
+      final String name,
+      final Comparator<T> comparator,
+      final boolean nativeCb,
+      final DbiFlags... flags) {
     final byte[] nameBytes = name == null ? null : name.getBytes(DEFAULT_NAME_CHARSET);
     return openDbi(nameBytes, comparator, nativeCb, flags);
   }
 
   /**
-   * @param name  name of the database (or null if no name is required)
+   * @param name name of the database (or null if no name is required)
    * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#createDbi()}
-   * <hr>
-   * Convenience method that opens a {@link Dbi} with a default {@link Comparator} that is not
-   * invoked from native code.
+   * @deprecated Instead use {@link Env#createDbi()} <hr> Convenience method that opens a {@link
+   *     Dbi} with a default {@link Comparator} that is not invoked from native code.
    */
   @Deprecated()
-  public Dbi<T> openDbi(final byte[] name,
-                        final DbiFlags... flags) {
-    return createDbi()
-        .setDbName(name)
-        .withDefaultComparator()
-        .setDbiFlags(flags)
-        .open();
+  public Dbi<T> openDbi(final byte[] name, final DbiFlags... flags) {
+    return createDbi().setDbName(name).withDefaultComparator().setDbiFlags(flags).open();
   }
 
   /**
-   * @param name       name of the database (or null if no name is required)
+   * @param name name of the database (or null if no name is required)
    * @param comparator custom comparator callback (or null to use LMDB default)
-   * @param flags      to open the database with
+   * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#createDbi()}
-   * <hr>
-   * Convenience method that opens a {@link Dbi} with an associated {@link Comparator} that is not
-   * invoked from native code.
+   * @deprecated Instead use {@link Env#createDbi()} <hr> Convenience method that opens a {@link
+   *     Dbi} with an associated {@link Comparator} that is not invoked from native code.
    */
   @Deprecated()
-  public Dbi<T> openDbi(final byte[] name,
-                        final Comparator<T> comparator,
-                        final DbiFlags... flags) {
+  public Dbi<T> openDbi(
+      final byte[] name, final Comparator<T> comparator, final DbiFlags... flags) {
     requireNonNull(comparator);
     return createDbi()
         .setDbName(name)
@@ -434,18 +418,16 @@ public Dbi<T> openDbi(final byte[] name,
   }
 
   /**
-   * @param name       name of the database (or null if no name is required)
+   * @param name name of the database (or null if no name is required)
    * @param comparator custom comparator callback (or null to use LMDB default)
-   * @param nativeCb   whether native code calls back to the Java comparator
-   * @param flags      to open the database with
+   * @param nativeCb whether native code calls back to the Java comparator
+   * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#createDbi()}
-   * <hr>
-   * Convenience method that opens a {@link Dbi} with an associated {@link Comparator} that may be
-   * invoked from native code if specified.
-   *
-   * <p>This method will automatically commit the private transaction before returning. This ensures
-   * the <code>Dbi</code> is available in the <code>Env</code>.
+   * @deprecated Instead use {@link Env#createDbi()} <hr> Convenience method that opens a {@link
+   *     Dbi} with an associated {@link Comparator} that may be invoked from native code if
+   *     specified.
+   *     <p>This method will automatically commit the private transaction before returning. This
+   *     ensures the <code>Dbi</code> is available in the <code>Env</code>.
    */
   @Deprecated()
   public Dbi<T> openDbi(
@@ -461,31 +443,27 @@ public Dbi<T> openDbi(
   }
 
   /**
-   * @param txn        transaction to use (required; not closed)
-   * @param name       name of the database (or null if no name is required)
+   * @param txn transaction to use (required; not closed)
+   * @param name name of the database (or null if no name is required)
    * @param comparator custom comparator callback (or null to use LMDB default)
-   * @param nativeCb   whether native LMDB code should call back to the Java comparator
-   * @param flags      to open the database with
+   * @param nativeCb whether native LMDB code should call back to the Java comparator
+   * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#createDbi()}
-   * Open the {@link Dbi} using the passed {@link Txn}.
-   *
-   * <p>The caller must commit the transaction after this method returns in order to retain the
-   * <code>Dbi</code> in the <code>Env</code>.
-   *
-   * <p>A {@link Comparator} may be provided when calling this method. Such comparator is primarily
-   * used by {@link CursorIterable} instances. A secondary (but uncommon) use of the comparator is
-   * to act as a callback from the native library if <code>nativeCb</code> is <code>true</code>.
-   * This is usually avoided due to the overhead of native code calling back into Java. It is
-   * instead highly recommended to set the correct {@link DbiFlags} to allow the native library to
-   * correctly order the intended keys.
-   *
-   * <p>A default comparator will be provided if <code>null</code> is passed as the comparator. If a
-   * custom comparator is provided, it must strictly match the lexicographical order of keys in the
-   * native LMDB database.
-   *
-   * <p>This method (and its overloaded convenience variants) must not be called from concurrent
-   * threads.
+   * @deprecated Instead use {@link Env#createDbi()} Open the {@link Dbi} using the passed {@link
+   *     Txn}.
+   *     <p>The caller must commit the transaction after this method returns in order to retain the
+   *     <code>Dbi</code> in the <code>Env</code>.
+   *     <p>A {@link Comparator} may be provided when calling this method. Such comparator is
+   *     primarily used by {@link CursorIterable} instances. A secondary (but uncommon) use of the
+   *     comparator is to act as a callback from the native library if <code>nativeCb</code> is
+   *     <code>true</code>. This is usually avoided due to the overhead of native code calling back
+   *     into Java. It is instead highly recommended to set the correct {@link DbiFlags} to allow
+   *     the native library to correctly order the intended keys.
+   *     <p>A default comparator will be provided if <code>null</code> is passed as the comparator.
+   *     If a custom comparator is provided, it must strictly match the lexicographical order of
+   *     keys in the native LMDB database.
+   *     <p>This method (and its overloaded convenience variants) must not be called from concurrent
+   *     threads.
    */
   @Deprecated()
   public Dbi<T> openDbi(
@@ -521,7 +499,7 @@ public Stat stat() {
    * Flushes the data buffers to disk.
    *
    * @param force force a synchronous flush (otherwise if the environment has the MDB_NOSYNC flag
-   *              set the flushes will be omitted, and with MDB_MAPASYNC they will be asynchronous)
+   *     set the flushes will be omitted, and with MDB_MAPASYNC they will be asynchronous)
    */
   public void sync(final boolean force) {
     if (closed) {
@@ -533,11 +511,10 @@ public void sync(final boolean force) {
 
   /**
    * @param parent parent transaction (may be null if no parent)
-   * @param flags  applicable flags (eg for a reusable, read-only transaction)
+   * @param flags applicable flags (eg for a reusable, read-only transaction)
    * @return a transaction (never null)
    * @deprecated Instead use {@link Env#txn(Txn, TxnFlagSet)}
-   * <p>
-   * Obtain a transaction with the requested parent and flags.
+   *     <p>Obtain a transaction with the requested parent and flags.
    */
   @Deprecated
   public Txn<T> txn(final Txn<T> parent, final TxnFlags... flags) {
@@ -560,9 +537,9 @@ public Txn<T> txn(final Txn<T> parent) {
    * Obtain a transaction with the requested parent and flags.
    *
    * @param parent parent transaction (may be null if no parent)
-   * @param flags  applicable flags (e.g. for a reusable, read-only transaction).
-   *               If the set of flags is used frequently it is recommended to hold
-   *               a static instance of the {@link TxnFlagSet} for re-use.
+   * @param flags applicable flags (e.g. for a reusable, read-only transaction). If the set of flags
+   *     is used frequently it is recommended to hold a static instance of the {@link TxnFlagSet}
+   *     for re-use.
    * @return a transaction (never null)
    */
   public Txn<T> txn(final Txn<T> parent, final TxnFlagSet flags) {
@@ -634,40 +611,30 @@ public int readerCheck() {
     return resultPtr.intValue();
   }
 
-  /**
-   * Object has already been closed and the operation is therefore prohibited.
-   */
+  /** Object has already been closed and the operation is therefore prohibited. */
   public static final class AlreadyClosedException extends LmdbException {
 
     private static final long serialVersionUID = 1L;
 
-    /**
-     * Creates a new instance.
-     */
+    /** Creates a new instance. */
     public AlreadyClosedException() {
       super("Environment has already been closed");
     }
   }
 
-  /**
-   * Object has already been opened and the operation is therefore prohibited.
-   */
+  /** Object has already been opened and the operation is therefore prohibited. */
   public static final class AlreadyOpenException extends LmdbException {
 
     private static final long serialVersionUID = 1L;
 
-    /**
-     * Creates a new instance.
-     */
+    /** Creates a new instance. */
     public AlreadyOpenException() {
       super("Environment has already been opened");
     }
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   /**
    * Builder for configuring and opening Env.
    *
@@ -685,7 +652,8 @@ public static final class Builder<T> {
     private boolean opened;
     private final BufferProxy<T> proxy;
     private int mode = POSIX_MODE_DEFAULT;
-    private final AbstractFlagSet.Builder<EnvFlags, EnvFlagSet> flagSetBuilder = EnvFlagSet.builder();
+    private final AbstractFlagSet.Builder<EnvFlags, EnvFlagSet> flagSetBuilder =
+        EnvFlagSet.builder();
 
     Builder(final BufferProxy<T> proxy) {
       requireNonNull(proxy);
@@ -695,12 +663,12 @@ public static final class Builder<T> {
     /**
      * Opens the environment.
      *
-     * @param path  file system destination
-     * @param mode  Unix permissions to set on created files and semaphores
+     * @param path file system destination
+     * @param mode Unix permissions to set on created files and semaphores
      * @param flags the flags for this new environment
      * @return an environment ready for use
      * @deprecated Instead use {@link Builder#open(Path)}, {@link Builder#setFilePermissions(int)}
-     * and {@link Builder#setEnvFlags(EnvFlags...)}.
+     *     and {@link Builder#setEnvFlags(EnvFlags...)}.
      */
     @Deprecated
     public Env<T> open(final File path, final int mode, final EnvFlags... flags) {
@@ -724,10 +692,11 @@ public Env<T> open(final File path) {
     /**
      * Opens the environment with 0664 mode.
      *
-     * @param path  file system destination
+     * @param path file system destination
      * @param flags the flags for this new environment
      * @return an environment ready for use
-     * @deprecated Instead use {@link Builder#open(Path)} and {@link Builder#setEnvFlags(EnvFlags...)}.
+     * @deprecated Instead use {@link Builder#open(Path)} and {@link
+     *     Builder#setEnvFlags(EnvFlags...)}.
      */
     @Deprecated
     public Env<T> open(final File path, final EnvFlags... flags) {
@@ -825,8 +794,8 @@ public Builder<T> setMaxReaders(final int readers) {
     }
 
     /**
-     * Sets the Unix file permissions to use on created files and semaphores, e.g. {@code 0664}.
-     * If this method is not called, the default of {@code 0664} will be used.
+     * Sets the Unix file permissions to use on created files and semaphores, e.g. {@code 0664}. If
+     * this method is not called, the default of {@code 0664} will be used.
      *
      * @param mode Unix permissions to set on created files and semaphores
      * @return the builder
@@ -842,17 +811,14 @@ public Builder<T> setFilePermissions(final int mode) {
     /**
      * Sets all the flags used to open this {@link Env}.
      *
-     * @param envFlags The flags to use.
-     *                 Clears any existing flags.
-     *                 A null value results in no flags being set.
+     * @param envFlags The flags to use. Clears any existing flags. A null value results in no flags
+     *     being set.
      * @return this builder instance.
      */
     public Builder<T> setEnvFlags(final Collection<EnvFlags> envFlags) {
       flagSetBuilder.clear();
       if (envFlags != null) {
-        envFlags.stream()
-            .filter(Objects::nonNull)
-            .forEach(envFlags::add);
+        envFlags.stream().filter(Objects::nonNull).forEach(envFlags::add);
       }
       return this;
     }
@@ -860,17 +826,14 @@ public Builder<T> setEnvFlags(final Collection<EnvFlags> envFlags) {
     /**
      * Sets all the flags used to open this {@link Env}.
      *
-     * @param envFlags The flags to use.
-     *                 Clears any existing flags.
-     *                 A null value results in no flags being set.
+     * @param envFlags The flags to use. Clears any existing flags. A null value results in no flags
+     *     being set.
      * @return this builder instance.
      */
     public Builder<T> setEnvFlags(final EnvFlags... envFlags) {
       flagSetBuilder.clear();
       if (envFlags != null) {
-        Arrays.stream(envFlags)
-            .filter(Objects::nonNull)
-            .forEach(this.flagSetBuilder::addFlag);
+        Arrays.stream(envFlags).filter(Objects::nonNull).forEach(this.flagSetBuilder::addFlag);
       }
       return this;
     }
@@ -878,9 +841,8 @@ public Builder<T> setEnvFlags(final EnvFlags... envFlags) {
     /**
      * Sets all the flags used to open this {@link Env}.
      *
-     * @param envFlagSet The flags to use.
-     *                   Clears any existing flags.
-     *                   A null value results in no flags being set.
+     * @param envFlagSet The flags to use. Clears any existing flags. A null value results in no
+     *     flags being set.
      * @return this builder instance.
      */
     public Builder<T> setEnvFlags(final EnvFlagSet envFlagSet) {
@@ -894,8 +856,7 @@ public Builder<T> setEnvFlags(final EnvFlagSet envFlagSet) {
     /**
      * Adds a single {@link EnvFlags} to any existing flags.
      *
-     * @param dbiFlag The flag to add to any existing flags.
-     *                A null value is a no-op.
+     * @param dbiFlag The flag to add to any existing flags. A null value is a no-op.
      * @return this builder instance.
      */
     public Builder<T> addEnvFlag(final EnvFlags dbiFlag) {
@@ -906,8 +867,7 @@ public Builder<T> addEnvFlag(final EnvFlags dbiFlag) {
     /**
      * Adds a set of {@link EnvFlags} to any existing flags.
      *
-     * @param dbiFlagSet The set of flags to add to any existing flags.
-     *                   A null value is a no-op.
+     * @param dbiFlagSet The set of flags to add to any existing flags. A null value is a no-op.
      * @return this builder instance.
      */
     public Builder<T> addEnvFlags(final EnvFlagSet dbiFlagSet) {
@@ -918,9 +878,7 @@ public Builder<T> addEnvFlags(final EnvFlagSet dbiFlagSet) {
     }
   }
 
-  /**
-   * File is not a valid LMDB file.
-   */
+  /** File is not a valid LMDB file. */
   public static final class FileInvalidException extends LmdbNativeException {
 
     static final int MDB_INVALID = -30_793;
@@ -931,9 +889,7 @@ public static final class FileInvalidException extends LmdbNativeException {
     }
   }
 
-  /**
-   * The specified copy destination is invalid.
-   */
+  /** The specified copy destination is invalid. */
   public static final class InvalidCopyDestination extends LmdbException {
 
     private static final long serialVersionUID = 1L;
@@ -948,9 +904,7 @@ public InvalidCopyDestination(final String message) {
     }
   }
 
-  /**
-   * Environment mapsize reached.
-   */
+  /** Environment mapsize reached. */
   public static final class MapFullException extends LmdbNativeException {
 
     static final int MDB_MAP_FULL = -30_792;
@@ -961,9 +915,7 @@ public static final class MapFullException extends LmdbNativeException {
     }
   }
 
-  /**
-   * Environment maxreaders reached.
-   */
+  /** Environment maxreaders reached. */
   public static final class ReadersFullException extends LmdbNativeException {
 
     static final int MDB_READERS_FULL = -30_790;
@@ -974,9 +926,7 @@ public static final class ReadersFullException extends LmdbNativeException {
     }
   }
 
-  /**
-   * Environment version mismatch.
-   */
+  /** Environment version mismatch. */
   public static final class VersionMismatchException extends LmdbNativeException {
 
     static final int MDB_VERSION_MISMATCH = -30_794;
diff --git a/src/main/java/org/lmdbjava/EnvFlagSet.java b/src/main/java/org/lmdbjava/EnvFlagSet.java
index c104edd9..771f5e2c 100644
--- a/src/main/java/org/lmdbjava/EnvFlagSet.java
+++ b/src/main/java/org/lmdbjava/EnvFlagSet.java
@@ -33,29 +33,20 @@ static EnvFlagSet of(final EnvFlags envFlag) {
   }
 
   static EnvFlagSet of(final EnvFlags... EnvFlags) {
-    return builder()
-        .setFlags(EnvFlags)
-        .build();
+    return builder().setFlags(EnvFlags).build();
   }
 
   static EnvFlagSet of(final Collection<EnvFlags> EnvFlags) {
-    return builder()
-        .setFlags(EnvFlags)
-        .build();
+    return builder().setFlags(EnvFlags).build();
   }
 
   static AbstractFlagSet.Builder<EnvFlags, EnvFlagSet> builder() {
     return new AbstractFlagSet.Builder<>(
-        EnvFlags.class,
-        EnvFlagSetImpl::new,
-        envFlag -> envFlag,
-        () -> EnvFlagSetImpl.EMPTY);
+        EnvFlags.class, EnvFlagSetImpl::new, envFlag -> envFlag, () -> EnvFlagSetImpl.EMPTY);
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   class EnvFlagSetImpl extends AbstractFlagSet<EnvFlags> implements EnvFlagSet {
 
     static final EnvFlagSet EMPTY = new EmptyEnvFlagSet();
@@ -65,10 +56,8 @@ private EnvFlagSetImpl(final EnumSet<EnvFlags> flags) {
     }
   }
 
-
   // --------------------------------------------------------------------------------
 
-
-  class EmptyEnvFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<EnvFlags> implements EnvFlagSet {
-  }
+  class EmptyEnvFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<EnvFlags>
+      implements EnvFlagSet {}
 }
diff --git a/src/main/java/org/lmdbjava/FlagSet.java b/src/main/java/org/lmdbjava/FlagSet.java
index 94cb3dca..e5e1c6a4 100644
--- a/src/main/java/org/lmdbjava/FlagSet.java
+++ b/src/main/java/org/lmdbjava/FlagSet.java
@@ -22,8 +22,9 @@
 import java.util.stream.Collectors;
 
 /**
- * A set of flags, each with a bit mask value.
- * Flags can be combined in a set such that the set has a combined bit mask value.
+ * A set of flags, each with a bit mask value. Flags can be combined in a set such that the set has
+ * a combined bit mask value.
+ *
  * @param <T>
  */
 public interface FlagSet<T extends MaskedFlag> extends Iterable<T> {
@@ -34,8 +35,8 @@ public interface FlagSet<T extends MaskedFlag> extends Iterable<T> {
   int getMask();
 
   /**
-   * @return The result of combining the mask of this {@link FlagSet}
-   * with the mask of the other {@link FlagSet}.
+   * @return The result of combining the mask of this {@link FlagSet} with the mask of the other
+   *     {@link FlagSet}.
    */
   default int getMaskWith(final FlagSet<T> other) {
     if (other != null) {
@@ -76,7 +77,6 @@ default boolean areAnySet(final FlagSet<T> flags) {
     return false;
   }
 
-
   /**
    * @return True if this {@link FlagSet} is empty.
    */
@@ -90,24 +90,18 @@ default Iterator<T> iterator() {
     return getFlags().iterator();
   }
 
-  /**
-   * Convert this {@link FlagSet} to a string for use in toString methods.
-   */
+  /** Convert this {@link FlagSet} to a string for use in toString methods. */
   static <T extends MaskedFlag> String asString(final FlagSet<T> flagSet) {
     Objects.requireNonNull(flagSet);
-    final String flagsStr = flagSet.getFlags()
-        .stream()
-        .sorted(Comparator.comparing(MaskedFlag::getMask))
-        .map(MaskedFlag::name)
-        .collect(Collectors.joining(", "));
-    return "FlagSet{" +
-        "flags=[" + flagsStr +
-        "], mask=" + flagSet.getMask() +
-        '}';
+    final String flagsStr =
+        flagSet.getFlags().stream()
+            .sorted(Comparator.comparing(MaskedFlag::getMask))
+            .map(MaskedFlag::name)
+            .collect(Collectors.joining(", "));
+    return "FlagSet{" + "flags=[" + flagsStr + "], mask=" + flagSet.getMask() + '}';
   }
 
-  static boolean equals(final FlagSet<?> flagSet,
-                        final Object other) {
+  static boolean equals(final FlagSet<?> flagSet, final Object other) {
     if (other instanceof FlagSet) {
       final FlagSet<?> flagSet2 = (FlagSet<?>) other;
       if (flagSet == flagSet2) {
@@ -122,5 +116,4 @@ static boolean equals(final FlagSet<?> flagSet,
       return false;
     }
   }
-
 }
diff --git a/src/main/java/org/lmdbjava/MaskedFlag.java b/src/main/java/org/lmdbjava/MaskedFlag.java
index 1c531ac8..400f2f30 100644
--- a/src/main/java/org/lmdbjava/MaskedFlag.java
+++ b/src/main/java/org/lmdbjava/MaskedFlag.java
@@ -59,9 +59,7 @@ static <M extends MaskedFlag> int mask(final M... flags) {
     }
   }
 
-  /**
-   * Combine the two masks into a single mask value, i.e. when combining two {@link FlagSet}s.
-   */
+  /** Combine the two masks into a single mask value, i.e. when combining two {@link FlagSet}s. */
   static <M extends MaskedFlag> int mask(final int mask1, final int mask2) {
     return mask1 | mask2;
   }
diff --git a/src/main/java/org/lmdbjava/PutFlagSet.java b/src/main/java/org/lmdbjava/PutFlagSet.java
index aaba7cb7..ee2a9826 100644
--- a/src/main/java/org/lmdbjava/PutFlagSet.java
+++ b/src/main/java/org/lmdbjava/PutFlagSet.java
@@ -21,54 +21,43 @@
 
 public interface PutFlagSet extends FlagSet<PutFlags> {
 
-    PutFlagSet EMPTY = PutFlagSetImpl.EMPTY;
+  PutFlagSet EMPTY = PutFlagSetImpl.EMPTY;
 
-    static PutFlagSet empty() {
-        return PutFlagSetImpl.EMPTY;
-    }
-
-    static PutFlagSet of(final PutFlags putFlag) {
-        Objects.requireNonNull(putFlag);
-        return putFlag;
-    }
-
-    static PutFlagSet of(final PutFlags... putFlags) {
-        return builder()
-                .setFlags(putFlags)
-                .build();
-    }
+  static PutFlagSet empty() {
+    return PutFlagSetImpl.EMPTY;
+  }
 
-    static PutFlagSet of(final Collection<PutFlags> putFlags) {
-        return builder()
-            .setFlags(putFlags)
-            .build();
-    }
+  static PutFlagSet of(final PutFlags putFlag) {
+    Objects.requireNonNull(putFlag);
+    return putFlag;
+  }
 
-    static AbstractFlagSet.Builder<PutFlags, PutFlagSet> builder() {
-        return new AbstractFlagSet.Builder<>(
-            PutFlags.class,
-            PutFlagSetImpl::new,
-            putFlag -> putFlag,
-            EmptyPutFlagSet::new);
-    }
+  static PutFlagSet of(final PutFlags... putFlags) {
+    return builder().setFlags(putFlags).build();
+  }
 
+  static PutFlagSet of(final Collection<PutFlags> putFlags) {
+    return builder().setFlags(putFlags).build();
+  }
 
-    // --------------------------------------------------------------------------------
+  static AbstractFlagSet.Builder<PutFlags, PutFlagSet> builder() {
+    return new AbstractFlagSet.Builder<>(
+        PutFlags.class, PutFlagSetImpl::new, putFlag -> putFlag, EmptyPutFlagSet::new);
+  }
 
+  // --------------------------------------------------------------------------------
 
-    class PutFlagSetImpl extends AbstractFlagSet<PutFlags> implements PutFlagSet {
+  class PutFlagSetImpl extends AbstractFlagSet<PutFlags> implements PutFlagSet {
 
-        public static final PutFlagSet EMPTY = new EmptyPutFlagSet();
+    public static final PutFlagSet EMPTY = new EmptyPutFlagSet();
 
-        private PutFlagSetImpl(final EnumSet<PutFlags> flags) {
-            super(flags);
-        }
+    private PutFlagSetImpl(final EnumSet<PutFlags> flags) {
+      super(flags);
     }
+  }
 
+  // --------------------------------------------------------------------------------
 
-    // --------------------------------------------------------------------------------
-
-
-    class EmptyPutFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<PutFlags> implements PutFlagSet {
-    }
+  class EmptyPutFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<PutFlags>
+      implements PutFlagSet {}
 }
diff --git a/src/main/java/org/lmdbjava/Txn.java b/src/main/java/org/lmdbjava/Txn.java
index 99439bf7..432b47a8 100644
--- a/src/main/java/org/lmdbjava/Txn.java
+++ b/src/main/java/org/lmdbjava/Txn.java
@@ -46,9 +46,7 @@ public final class Txn<T> implements AutoCloseable {
   private State state;
 
   Txn(final Env<T> env, final Txn<T> parent, final BufferProxy<T> proxy, final TxnFlagSet flags) {
-    this.flags = flags != null
-        ? flags
-        : TxnFlagSet.EMPTY;
+    this.flags = flags != null ? flags : TxnFlagSet.EMPTY;
     this.proxy = proxy;
     this.keyVal = proxy.keyVal();
     this.readOnly = this.flags.isSet(MDB_RDONLY_TXN);
diff --git a/src/main/java/org/lmdbjava/TxnFlagSet.java b/src/main/java/org/lmdbjava/TxnFlagSet.java
index 0943b362..1fa34d32 100644
--- a/src/main/java/org/lmdbjava/TxnFlagSet.java
+++ b/src/main/java/org/lmdbjava/TxnFlagSet.java
@@ -33,29 +33,20 @@ static TxnFlagSet of(final TxnFlags putflag) {
   }
 
   static TxnFlagSet of(final TxnFlags... TxnFlags) {
-    return builder()
-        .setFlags(TxnFlags)
-        .build();
+    return builder().setFlags(TxnFlags).build();
   }
 
   static TxnFlagSet of(final Collection<TxnFlags> txnFlags) {
-    return builder()
-        .setFlags(txnFlags)
-        .build();
+    return builder().setFlags(txnFlags).build();
   }
 
   static AbstractFlagSet.Builder<TxnFlags, TxnFlagSet> builder() {
     return new AbstractFlagSet.Builder<>(
-        TxnFlags.class,
-        TxnFlagSetImpl::new,
-        SingleTxnFlagSet::new,
-        () -> TxnFlagSetImpl.EMPTY);
+        TxnFlags.class, TxnFlagSetImpl::new, SingleTxnFlagSet::new, () -> TxnFlagSetImpl.EMPTY);
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   class TxnFlagSetImpl extends AbstractFlagSet<TxnFlags> implements TxnFlagSet {
 
     static final TxnFlagSet EMPTY = new EmptyTxnFlagSet();
@@ -65,21 +56,18 @@ private TxnFlagSetImpl(final EnumSet<TxnFlags> flags) {
     }
   }
 
-
   // --------------------------------------------------------------------------------
 
-
-  class SingleTxnFlagSet extends AbstractFlagSet.AbstractSingleFlagSet<TxnFlags> implements TxnFlagSet {
+  class SingleTxnFlagSet extends AbstractFlagSet.AbstractSingleFlagSet<TxnFlags>
+      implements TxnFlagSet {
 
     SingleTxnFlagSet(final TxnFlags flag) {
       super(flag);
     }
   }
 
-
   // --------------------------------------------------------------------------------
 
-
-  class EmptyTxnFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<TxnFlags> implements TxnFlagSet {
-  }
+  class EmptyTxnFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<TxnFlags>
+      implements TxnFlagSet {}
 }
diff --git a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
index 7358416b..dbe32e14 100644
--- a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
@@ -25,7 +25,8 @@
 import java.util.Set;
 import org.junit.jupiter.api.Test;
 
-public abstract class AbstractFlagSetTest<T extends Enum<T> & MaskedFlag & FlagSet<T>, F extends FlagSet<T>> {
+public abstract class AbstractFlagSetTest<
+    T extends Enum<T> & MaskedFlag & FlagSet<T>, F extends FlagSet<T>> {
 
   abstract List<T> getAllFlags();
 
@@ -48,70 +49,42 @@ T getFirst() {
   @Test
   void testEmpty() {
     final F emptyFlagSet = getEmptyFlagSet();
-    assertThat(emptyFlagSet.getMask())
-        .isEqualTo(0);
-    assertThat(emptyFlagSet.getFlags())
-        .isEmpty();
-    assertThat(emptyFlagSet.isEmpty())
-        .isTrue();
-    assertThat(emptyFlagSet.size())
-        .isEqualTo(0);
-    assertThat(emptyFlagSet.isSet(getFirst()))
-        .isFalse();
-    assertThat(getBuilder().build().getFlags())
-        .isEqualTo(emptyFlagSet.getFlags());
+    assertThat(emptyFlagSet.getMask()).isEqualTo(0);
+    assertThat(emptyFlagSet.getFlags()).isEmpty();
+    assertThat(emptyFlagSet.isEmpty()).isTrue();
+    assertThat(emptyFlagSet.size()).isEqualTo(0);
+    assertThat(emptyFlagSet.isSet(getFirst())).isFalse();
+    assertThat(getBuilder().build().getFlags()).isEqualTo(emptyFlagSet.getFlags());
   }
 
   @Test
   void testSingleFlagSet() {
     final List<T> allFlags = getAllFlags();
     for (T flag : allFlags) {
-      final F flagSet = getBuilder()
-          .addFlag(flag)
-          .build();
-      assertThat(flagSet.getMask())
-          .isEqualTo(flag.getMask());
-      assertThat(flagSet.getMask())
-          .isEqualTo(MaskedFlag.mask(flag));
-      assertThat(flagSet.getFlags())
-          .containsExactly(flag);
-      assertThat(flagSet.size())
-          .isEqualTo(1);
-      assertThat(FlagSet.equals(flagSet, new Object()))
-          .isFalse();
-      assertThat(FlagSet.equals(flagSet, null))
-          .isFalse();
-      assertThat(FlagSet.equals(flag, flag))
-          .isTrue();
-      assertThat(FlagSet.equals(flagSet, flag))
-          .isTrue();
-      assertThat(FlagSet.equals(flagSet, getFlagSet(flag)))
-          .isTrue();
-      assertThat(FlagSet.equals(flagSet, getFlagSet(flagSet.getFlags())))
-          .isTrue();
-      assertThat(flagSet.areAnySet(flag))
-          .isTrue();
-      assertThat(flagSet.areAnySet(null))
-          .isFalse();
-      assertThat(flagSet.areAnySet(getEmptyFlagSet()))
-          .isFalse();
-      assertThat(flagSet.isSet(getFirst()))
-          .isEqualTo(getFirst() == flag);
+      final F flagSet = getBuilder().addFlag(flag).build();
+      assertThat(flagSet.getMask()).isEqualTo(flag.getMask());
+      assertThat(flagSet.getMask()).isEqualTo(MaskedFlag.mask(flag));
+      assertThat(flagSet.getFlags()).containsExactly(flag);
+      assertThat(flagSet.size()).isEqualTo(1);
+      assertThat(FlagSet.equals(flagSet, new Object())).isFalse();
+      assertThat(FlagSet.equals(flagSet, null)).isFalse();
+      assertThat(FlagSet.equals(flag, flag)).isTrue();
+      assertThat(FlagSet.equals(flagSet, flag)).isTrue();
+      assertThat(FlagSet.equals(flagSet, getFlagSet(flag))).isTrue();
+      assertThat(FlagSet.equals(flagSet, getFlagSet(flagSet.getFlags()))).isTrue();
+      assertThat(flagSet.areAnySet(flag)).isTrue();
+      assertThat(flagSet.areAnySet(null)).isFalse();
+      assertThat(flagSet.areAnySet(getEmptyFlagSet())).isFalse();
+      assertThat(flagSet.isSet(getFirst())).isEqualTo(getFirst() == flag);
       if (getFirst() == flag) {
-        assertThat(flagSet.getMask())
-            .isEqualTo(MaskedFlag.mask(getFirst()));
+        assertThat(flagSet.getMask()).isEqualTo(MaskedFlag.mask(getFirst()));
       } else {
-        assertThat(flagSet.getMask())
-            .isNotEqualTo(MaskedFlag.mask(getFirst()));
-        assertThat(flagSet.getMaskWith(getFirst()))
-            .isEqualTo(MaskedFlag.mask(flag, getFirst()));
+        assertThat(flagSet.getMask()).isNotEqualTo(MaskedFlag.mask(getFirst()));
+        assertThat(flagSet.getMaskWith(getFirst())).isEqualTo(MaskedFlag.mask(flag, getFirst()));
       }
-      assertThat(flagSet.toString())
-          .isNotNull();
-      assertThat(flag.name())
-          .isNotNull();
-      assertThat(flagSet.getMaskWith(null))
-          .isEqualTo(flagSet.getMask());
+      assertThat(flagSet.toString()).isNotNull();
+      assertThat(flag.name()).isNotNull();
+      assertThat(flagSet.getMaskWith(null)).isEqualTo(flagSet.getMask());
     }
   }
 
@@ -123,72 +96,47 @@ void testAllFlags() {
     final T firstFlag = getFirst();
     for (T flag : allFlags) {
       flags.add(flag);
-      final F flagSet = getBuilder()
-          .setFlags(flags)
-          .build();
+      final F flagSet = getBuilder().setFlags(flags).build();
       final int flagSetMask = flagSet.getMask();
 
-      assertThat(masks)
-          .doesNotContain(flagSetMask);
+      assertThat(masks).doesNotContain(flagSetMask);
       masks.add(flagSetMask);
-      assertThat(flagSetMask)
-          .isEqualTo(MaskedFlag.mask(flags));
+      assertThat(flagSetMask).isEqualTo(MaskedFlag.mask(flags));
       final T[] flagsArr = flags.stream().toArray(this::toArray);
-      assertThat(flagSetMask)
-          .isEqualTo(MaskedFlag.mask(flagsArr));
-      assertThat(flagSet.getFlags())
-          .containsExactlyElementsOf(flags);
-      assertThat(flagSet)
-          .isNotEmpty();
-      assertThat(FlagSet.equals(flagSet, getBuilder().setFlags(flagsArr).build()))
-          .isTrue();
-      assertThat(FlagSet.equals(flagSet, getFlagSet(flags)))
-          .isTrue();
-      assertThat(FlagSet.equals(flagSet, getFlagSet(flagsArr)))
-          .isTrue();
-      assertThat(flagSet.size())
-          .isEqualTo(flags.size());
-      assertThat(flagSet.isSet(getFirst()))
-          .isEqualTo(true);
+      assertThat(flagSetMask).isEqualTo(MaskedFlag.mask(flagsArr));
+      assertThat(flagSet.getFlags()).containsExactlyElementsOf(flags);
+      assertThat(flagSet).isNotEmpty();
+      assertThat(FlagSet.equals(flagSet, getBuilder().setFlags(flagsArr).build())).isTrue();
+      assertThat(FlagSet.equals(flagSet, getFlagSet(flags))).isTrue();
+      assertThat(FlagSet.equals(flagSet, getFlagSet(flagsArr))).isTrue();
+      assertThat(flagSet.size()).isEqualTo(flags.size());
+      assertThat(flagSet.isSet(getFirst())).isEqualTo(true);
 
       final int maskWith = flagSet.getMaskWith(firstFlag);
       final List<T> combinedList = new ArrayList<>(flags);
       combinedList.add(firstFlag);
-      assertThat(maskWith)
-          .isEqualTo(MaskedFlag.mask(combinedList));
+      assertThat(maskWith).isEqualTo(MaskedFlag.mask(combinedList));
     }
   }
 
-  /**
-   * Test as an enum instance rather than a {@link FlagSet}
-   */
+  /** Test as an enum instance rather than a {@link FlagSet} */
   @Test
   void testAsFlag() {
     final T flag = getFirst();
-    assertThat(flag.size())
-        .isEqualTo(1);
-    assertThat(flag.getFlags())
-        .hasSize(1);
+    assertThat(flag.size()).isEqualTo(1);
+    assertThat(flag.getFlags()).hasSize(1);
     final T flag2 = flag.getFlags().iterator().next();
-    assertThat(flag2 == flag)
-        .isTrue();
-    assertThat(flag.getMask())
-        .isEqualTo(MaskedFlag.mask(flag));
-    assertThat(flag.isEmpty())
-        .isFalse();
-    assertThat(flag.toString())
-        .isNotNull();
-    assertThat(flag.isSet(flag))
-        .isTrue();
-    assertThat(flag.isSet(flag2))
-        .isTrue();
-    assertThat(flag.isSet(null))
-        .isFalse();
+    assertThat(flag2 == flag).isTrue();
+    assertThat(flag.getMask()).isEqualTo(MaskedFlag.mask(flag));
+    assertThat(flag.isEmpty()).isFalse();
+    assertThat(flag.toString()).isNotNull();
+    assertThat(flag.isSet(flag)).isTrue();
+    assertThat(flag.isSet(flag2)).isTrue();
+    assertThat(flag.isSet(null)).isFalse();
     final List<T> allFlags = getAllFlags();
     if (allFlags.size() > 1) {
       T secondFlag = allFlags.get(1);
-      assertThat(flag.isSet(secondFlag))
-          .isFalse();
+      assertThat(flag.isSet(secondFlag)).isFalse();
     }
   }
 
diff --git a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
index d9312cce..6ee8f874 100644
--- a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
+++ b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
@@ -51,9 +51,7 @@
 import org.lmdbjava.ByteBufferProxy.BufferMustBeDirectException;
 import org.lmdbjava.Env.ReadersFullException;
 
-/**
- * Test {@link ByteBufferProxy}.
- */
+/** Test {@link ByteBufferProxy}. */
 public final class ByteBufferProxyTest {
 
   static final MemoryManager MEM_MGR = RUNTIME.getMemoryManager();
@@ -61,25 +59,24 @@ public final class ByteBufferProxyTest {
   @Test
   void buffersMustBeDirect() {
     assertThatThrownBy(
-        () -> {
-          FileUtil.useTempDir(
-              dir -> {
-                try (Env<ByteBuffer> env = create()
-                    .setMaxReaders(1)
-                    .open(dir)) {
-                  final Dbi<ByteBuffer> db = env.createDbi()
-                      .setDbName(DB_1)
-                      .withDefaultComparator()
-                      .setDbiFlags(MDB_CREATE)
-                      .open();
-                  final ByteBuffer key = allocate(100);
-                  key.putInt(1).flip();
-                  final ByteBuffer val = allocate(100);
-                  val.putInt(1).flip();
-                  db.put(key, val); // error
-                }
-              });
-        })
+            () -> {
+              FileUtil.useTempDir(
+                  dir -> {
+                    try (Env<ByteBuffer> env = create().setMaxReaders(1).open(dir)) {
+                      final Dbi<ByteBuffer> db =
+                          env.createDbi()
+                              .setDbName(DB_1)
+                              .withDefaultComparator()
+                              .setDbiFlags(MDB_CREATE)
+                              .open();
+                      final ByteBuffer key = allocate(100);
+                      key.putInt(1).flip();
+                      final ByteBuffer val = allocate(100);
+                      val.putInt(1).flip();
+                      db.put(key, val); // error
+                    }
+                  });
+            })
         .isInstanceOf(BufferMustBeDirectException.class);
   }
 
@@ -104,9 +101,9 @@ void coverPrivateConstructor() {
   @Test
   void fieldNeverFound() {
     assertThatThrownBy(
-        () -> {
-          findField(Exception.class, "notARealField");
-        })
+            () -> {
+              findField(Exception.class, "notARealField");
+            })
         .isInstanceOf(LmdbException.class);
   }
 
@@ -164,29 +161,29 @@ public void comparatorPerformance() {
       int x = 0;
       for (int round = 0; round < rounds; round++) {
         for (int i = 1; i < values.length; i++) {
-          buffer1.order(ByteOrder.nativeOrder())
-              .putLong(0, values[i - 1]);
-          buffer2.order(ByteOrder.nativeOrder())
-              .putLong(0, values[i]);
-          final int result = ByteBufferProxy.AbstractByteBufferProxy.compareAsIntegerKeys(buffer1, buffer2);
+          buffer1.order(ByteOrder.nativeOrder()).putLong(0, values[i - 1]);
+          buffer2.order(ByteOrder.nativeOrder()).putLong(0, values[i]);
+          final int result =
+              ByteBufferProxy.AbstractByteBufferProxy.compareAsIntegerKeys(buffer1, buffer2);
           x += result;
         }
       }
-      System.out.println("compareAsIntegerKeys: " + Duration.between(time, Instant.now()) + ", x: " + x);
+      System.out.println(
+          "compareAsIntegerKeys: " + Duration.between(time, Instant.now()) + ", x: " + x);
 
       time = Instant.now();
       int y = 0;
       for (int round = 0; round < rounds; round++) {
         for (int i = 1; i < values.length; i++) {
-          buffer1.order(BIG_ENDIAN)
-              .putLong(0, values[i - 1]);
-          buffer2.order(BIG_ENDIAN)
-              .putLong(0, values[i]);
-          final int result = ByteBufferProxy.AbstractByteBufferProxy.compareLexicographically(buffer1, buffer2);
+          buffer1.order(BIG_ENDIAN).putLong(0, values[i - 1]);
+          buffer2.order(BIG_ENDIAN).putLong(0, values[i]);
+          final int result =
+              ByteBufferProxy.AbstractByteBufferProxy.compareLexicographically(buffer1, buffer2);
           y += result;
         }
       }
-      System.out.println("compareLexicographically: " + Duration.between(time, Instant.now()) + ", y: " + y);
+      System.out.println(
+          "compareLexicographically: " + Duration.between(time, Instant.now()) + ", y: " + y);
 
       assertThat(y).isEqualTo(x);
     }
@@ -195,25 +192,27 @@ public void comparatorPerformance() {
   @Test
   public void verifyComparators() {
     final Random random = new Random(203948);
-    final ByteBuffer buffer1native = ByteBuffer.allocateDirect(Long.BYTES).order(ByteOrder.nativeOrder());
-    final ByteBuffer buffer2native = ByteBuffer.allocateDirect(Long.BYTES).order(ByteOrder.nativeOrder());
+    final ByteBuffer buffer1native =
+        ByteBuffer.allocateDirect(Long.BYTES).order(ByteOrder.nativeOrder());
+    final ByteBuffer buffer2native =
+        ByteBuffer.allocateDirect(Long.BYTES).order(ByteOrder.nativeOrder());
     final ByteBuffer buffer1be = ByteBuffer.allocateDirect(Long.BYTES).order(BIG_ENDIAN);
     final ByteBuffer buffer2be = ByteBuffer.allocateDirect(Long.BYTES).order(BIG_ENDIAN);
     buffer1native.limit(Long.BYTES);
     buffer2native.limit(Long.BYTES);
     buffer1be.limit(Long.BYTES);
     buffer2be.limit(Long.BYTES);
-    final long[] values = random.longs()
-        .filter(i -> i >= 0)
-        .limit(5_000_000)
-        .toArray();
-//    System.out.println("stats: " + Arrays.stream(values)
-//        .summaryStatistics()
-//        .toString());
+    final long[] values = random.longs().filter(i -> i >= 0).limit(5_000_000).toArray();
+    //    System.out.println("stats: " + Arrays.stream(values)
+    //        .summaryStatistics()
+    //        .toString());
 
     final LinkedHashMap<String, Comparator<ByteBuffer>> comparators = new LinkedHashMap<>();
-    comparators.put("compareAsIntegerKeys", ByteBufferProxy.AbstractByteBufferProxy::compareAsIntegerKeys);
-    comparators.put("compareLexicographically", ByteBufferProxy.AbstractByteBufferProxy::compareLexicographically);
+    comparators.put(
+        "compareAsIntegerKeys", ByteBufferProxy.AbstractByteBufferProxy::compareAsIntegerKeys);
+    comparators.put(
+        "compareLexicographically",
+        ByteBufferProxy.AbstractByteBufferProxy::compareLexicographically);
 
     final LinkedHashMap<String, Integer> results = new LinkedHashMap<>(comparators.size());
     final Set<Integer> uniqueResults = new HashSet<>(comparators.size());
@@ -228,22 +227,23 @@ public void verifyComparators() {
       uniqueResults.clear();
 
       // Make sure all comparators give the same result for the same inputs
-      comparators.forEach((name, comparator) -> {
-        final int result;
-        // IntegerKey comparator expects keys to have been written in native order so need different buffers.
-        if (name.equals("compareAsIntegerKeys")) {
-          result = comparator.compare(buffer1native, buffer2native);
-        } else {
-          result = comparator.compare(buffer1be, buffer2be);
-        }
-        results.put(name, result);
-        uniqueResults.add(result);
-      });
+      comparators.forEach(
+          (name, comparator) -> {
+            final int result;
+            // IntegerKey comparator expects keys to have been written in native order so need
+            // different buffers.
+            if (name.equals("compareAsIntegerKeys")) {
+              result = comparator.compare(buffer1native, buffer2native);
+            } else {
+              result = comparator.compare(buffer1be, buffer2be);
+            }
+            results.put(name, result);
+            uniqueResults.add(result);
+          });
 
       if (uniqueResults.size() != 1) {
-        Assertions.fail("Comparator mismatch for values: "
-            + val1 + " and "
-            + val2 + ". Results: " + results);
+        Assertions.fail(
+            "Comparator mismatch for values: " + val1 + " and " + val2 + ". Results: " + results);
       }
     }
   }
diff --git a/src/test/java/org/lmdbjava/ByteUnitTest.java b/src/test/java/org/lmdbjava/ByteUnitTest.java
index a899cbc3..5724429d 100644
--- a/src/test/java/org/lmdbjava/ByteUnitTest.java
+++ b/src/test/java/org/lmdbjava/ByteUnitTest.java
@@ -59,6 +59,5 @@ void test() {
 
     Assertions.assertThat(ByteUnit.PETABYTES.toBytes(1)).isEqualTo(1000000000000000L);
     Assertions.assertThat(ByteUnit.PETABYTES.toBytes(2)).isEqualTo(2000000000000000L);
-
   }
 }
diff --git a/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java b/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java
index 32e0c8c5..00c0ce28 100644
--- a/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java
+++ b/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java
@@ -38,9 +38,7 @@
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
 
-/**
- * Tests comparator functions are consistent across buffers.
- */
+/** Tests comparator functions are consistent across buffers. */
 public final class ComparatorIntegerKeyTest {
 
   static Stream<Arguments> comparatorProvider() {
@@ -101,10 +99,7 @@ void testRandomLong(final ComparatorRunner runner) {
     final Random random = new Random(3239480);
 
     // 5mil random longs to compare
-    final long[] values = random.longs()
-        .filter(i -> i >= 0)
-        .limit(5_000_000)
-        .toArray();
+    final long[] values = random.longs().filter(i -> i >= 0).limit(5_000_000).toArray();
 
     for (int i = 1; i < values.length; i++) {
       final long long1 = values[i - 1];
@@ -114,20 +109,32 @@ void testRandomLong(final ComparatorRunner runner) {
       final ComparatorTest.ComparatorResult expectedResult = get(Long.compare(long1, long2));
 
       assertThat(result)
-          .withFailMessage(() -> "Compare mismatch - long1: " + long1
-              + ", long2: " + long2
-              + ", expected: " + expectedResult
-              + ", actual: " + result)
+          .withFailMessage(
+              () ->
+                  "Compare mismatch - long1: "
+                      + long1
+                      + ", long2: "
+                      + long2
+                      + ", expected: "
+                      + expectedResult
+                      + ", actual: "
+                      + result)
           .isEqualTo(expectedResult);
 
       final ComparatorTest.ComparatorResult result2 = get(runner.compare(long2, long1));
       final ComparatorTest.ComparatorResult expectedResult2 = expectedResult.opposite();
 
       assertThat(result)
-          .withFailMessage(() -> "Compare mismatch for - long2: " + long2
-              + ", long1: " + long1
-              + ", expected2: " + expectedResult2
-              + ", actual2: " + result2)
+          .withFailMessage(
+              () ->
+                  "Compare mismatch for - long2: "
+                      + long2
+                      + ", long1: "
+                      + long1
+                      + ", expected2: "
+                      + expectedResult2
+                      + ", actual2: "
+                      + result2)
           .isEqualTo(expectedResult);
     }
   }
@@ -138,10 +145,7 @@ void testRandomInt(final ComparatorRunner runner) {
     final Random random = new Random(3239480);
 
     // 5mil random ints to compare
-    final int[] values = random.ints()
-        .filter(i -> i >= 0)
-        .limit(5_000_000)
-        .toArray();
+    final int[] values = random.ints().filter(i -> i >= 0).limit(5_000_000).toArray();
 
     for (int i = 1; i < values.length; i++) {
       final int int1 = values[i - 1];
@@ -151,34 +155,43 @@ void testRandomInt(final ComparatorRunner runner) {
       final ComparatorTest.ComparatorResult expectedResult = get(Integer.compare(int1, int2));
 
       assertThat(result)
-          .withFailMessage(() -> "Compare mismatch for - int1: " + int1
-              + ", int2: " + int2
-              + ", expected: " + expectedResult
-              + ", actual: " + result)
+          .withFailMessage(
+              () ->
+                  "Compare mismatch for - int1: "
+                      + int1
+                      + ", int2: "
+                      + int2
+                      + ", expected: "
+                      + expectedResult
+                      + ", actual: "
+                      + result)
           .isEqualTo(expectedResult);
 
       final ComparatorTest.ComparatorResult result2 = get(runner.compare(int2, int1));
       final ComparatorTest.ComparatorResult expectedResult2 = expectedResult.opposite();
 
       assertThat(result)
-          .withFailMessage(() -> "Compare mismatch for - int2: " + int2
-              + ", int1: " + int1
-              + ", expected2: " + expectedResult2
-              + ", actual2: " + result2)
+          .withFailMessage(
+              () ->
+                  "Compare mismatch for - int2: "
+                      + int2
+                      + ", int1: "
+                      + int1
+                      + ", expected2: "
+                      + expectedResult2
+                      + ", actual2: "
+                      + result2)
           .isEqualTo(expectedResult);
     }
   }
 
-
   // --------------------------------------------------------------------------------
 
-
-  /**
-   * Tests {@link ByteBufferProxy}.
-   */
+  /** Tests {@link ByteBufferProxy}. */
   private static final class ByteBufferRunner implements ComparatorRunner {
 
-    private static final Comparator<ByteBuffer> COMPARATOR = PROXY_OPTIMAL.getComparator(DbiFlags.MDB_INTEGERKEY);
+    private static final Comparator<ByteBuffer> COMPARATOR =
+        PROXY_OPTIMAL.getComparator(DbiFlags.MDB_INTEGERKEY);
 
     @Override
     public int compare(long long1, long long2) {
@@ -247,15 +260,12 @@ private ByteBuffer intToBuffer(final int val, final int bufferCapacity) {
     }
   }
 
-
   // --------------------------------------------------------------------------------
 
-
-  /**
-   * Tests {@link DirectBufferProxy}.
-   */
+  /** Tests {@link DirectBufferProxy}. */
   private static final class DirectBufferRunner implements ComparatorRunner {
-    private static final Comparator<DirectBuffer> COMPARATOR = PROXY_DB.getComparator(DbiFlags.MDB_INTEGERKEY);
+    private static final Comparator<DirectBuffer> COMPARATOR =
+        PROXY_DB.getComparator(DbiFlags.MDB_INTEGERKEY);
 
     @Override
     public int compare(long long1, long long2) {
@@ -276,12 +286,11 @@ public int compare(int int1, int int2) {
     }
   }
 
-  /**
-   * Tests {@link ByteBufProxy}.
-   */
+  /** Tests {@link ByteBufProxy}. */
   private static final class NettyRunner implements ComparatorRunner {
 
-    private static final Comparator<ByteBuf> COMPARATOR = PROXY_NETTY.getComparator(DbiFlags.MDB_INTEGERKEY);
+    private static final Comparator<ByteBuf> COMPARATOR =
+        PROXY_NETTY.getComparator(DbiFlags.MDB_INTEGERKEY);
 
     @Override
     public int compare(long long1, long long2) {
@@ -322,13 +331,9 @@ public int compare(int int1, int int2) {
     }
   }
 
-
   // --------------------------------------------------------------------------------
 
-
-  /**
-   * Interface that can test a {@link BufferProxy} <code>compare</code> method.
-   */
+  /** Interface that can test a {@link BufferProxy} <code>compare</code> method. */
   private interface ComparatorRunner {
 
     /**
diff --git a/src/test/java/org/lmdbjava/CopyFlagSetTest.java b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
index e53c7508..898da499 100644
--- a/src/test/java/org/lmdbjava/CopyFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
@@ -22,39 +22,38 @@
 
 public class CopyFlagSetTest extends AbstractFlagSetTest<CopyFlags, CopyFlagSet> {
 
-    @Override
-    List<CopyFlags> getAllFlags() {
-        return Arrays.stream(CopyFlags.values())
-            .collect(Collectors.toList());
-    }
-
-    @Override
-    CopyFlagSet getEmptyFlagSet() {
-        return CopyFlagSet.empty();
-    }
-
-    @Override
-    AbstractFlagSet.Builder<CopyFlags, CopyFlagSet> getBuilder() {
-        return CopyFlagSet.builder();
-    }
-
-    @Override
-    CopyFlagSet getFlagSet(Collection<CopyFlags> flags) {
-        return CopyFlagSet.of(flags);
-    }
-
-    @Override
-    CopyFlagSet getFlagSet(CopyFlags[] flags) {
-        return CopyFlagSet.of(flags);
-    }
-
-    @Override
-    CopyFlagSet getFlagSet(CopyFlags flag) {
-        return CopyFlagSet.of(flag);
-    }
-
-    @Override
-    Class<CopyFlags> getFlagType() {
-        return CopyFlags.class;
-    }
+  @Override
+  List<CopyFlags> getAllFlags() {
+    return Arrays.stream(CopyFlags.values()).collect(Collectors.toList());
+  }
+
+  @Override
+  CopyFlagSet getEmptyFlagSet() {
+    return CopyFlagSet.empty();
+  }
+
+  @Override
+  AbstractFlagSet.Builder<CopyFlags, CopyFlagSet> getBuilder() {
+    return CopyFlagSet.builder();
+  }
+
+  @Override
+  CopyFlagSet getFlagSet(Collection<CopyFlags> flags) {
+    return CopyFlagSet.of(flags);
+  }
+
+  @Override
+  CopyFlagSet getFlagSet(CopyFlags[] flags) {
+    return CopyFlagSet.of(flags);
+  }
+
+  @Override
+  CopyFlagSet getFlagSet(CopyFlags flag) {
+    return CopyFlagSet.of(flag);
+  }
+
+  @Override
+  Class<CopyFlags> getFlagType() {
+    return CopyFlags.class;
+  }
 }
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
index 0e3d4e3e..7a2515b2 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
@@ -79,18 +79,16 @@
 import org.lmdbjava.CursorIterable.KeyVal;
 
 /**
- * Test {@link CursorIterable} using {@link DbiFlags#MDB_INTEGERKEY} to ensure that
- * comparators work with native order integer keys.
+ * Test {@link CursorIterable} using {@link DbiFlags#MDB_INTEGERKEY} to ensure that comparators work
+ * with native order integer keys.
  */
 @Disabled // Waiting for the merge of stroomdev66's cursor tests
 @ParameterizedClass(name = "{index}: dbi: {0}")
 @ArgumentsSource(CursorIterableIntegerDupTest.MyArgumentProvider.class)
 public final class CursorIterableIntegerDupTest {
 
-  private static final DbiFlagSet DBI_FLAGS = DbiFlagSet.of(
-      MDB_CREATE,
-      MDB_INTEGERDUP,
-      MDB_DUPSORT);
+  private static final DbiFlagSet DBI_FLAGS =
+      DbiFlagSet.of(MDB_CREATE, MDB_INTEGERDUP, MDB_DUPSORT);
   private static final BufferProxy<ByteBuffer> BUFFER_PROXY = ByteBufferProxy.PROXY_OPTIMAL;
   private static final List<Map.Entry<Integer, Integer>> INPUT_DATA;
 
@@ -113,8 +111,7 @@ public final class CursorIterableIntegerDupTest {
   private Env<ByteBuffer> env;
   private Deque<Map.Entry<Integer, Integer>> expectedEntriesDeque;
 
-  @Parameter
-  public DbiFactory dbiFactory;
+  @Parameter public DbiFactory dbiFactory;
 
   @BeforeEach
   public void before() throws IOException {
@@ -185,15 +182,15 @@ private void populateDatabase(final Dbi<ByteBuffer> dbi) {
       }
       txn.commit();
     }
-//    try (Txn<ByteBuffer> txn = env.txnRead();
-//         CursorIterable<ByteBuffer> c = dbi.iterate(txn)) {
-//
-//      for (final KeyVal<ByteBuffer> kv : c) {
-//        System.out.print(getNativeInt(kv.key()) + " => " + kv.val().getInt());
-//        System.out.print(", ");
-//      }
-//      System.out.println();
-//    }
+    //    try (Txn<ByteBuffer> txn = env.txnRead();
+    //         CursorIterable<ByteBuffer> c = dbi.iterate(txn)) {
+    //
+    //      for (final KeyVal<ByteBuffer> kv : c) {
+    //        System.out.print(getNativeInt(kv.key()) + " => " + kv.val().getInt());
+    //        System.out.print(", ");
+    //      }
+    //      System.out.println();
+    //    }
   }
 
   private int[] rangeInc(final int fromInc, final int toInc) {
@@ -256,14 +253,16 @@ public void greaterThanTest() {
   }
 
   public void iterableOnlyReturnedOnce() {
-    Assertions.assertThatThrownBy(() -> {
-      final Dbi<ByteBuffer> db = getDb();
-      try (Txn<ByteBuffer> txn = env.txnRead();
-           CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-        c.iterator(); // ok
-        c.iterator(); // fails
-      }
-    }).isInstanceOf(IllegalStateException.class);
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead();
+                  CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+                c.iterator(); // ok
+                c.iterator(); // fails
+              }
+            })
+        .isInstanceOf(IllegalStateException.class);
   }
 
   @Test
@@ -271,12 +270,12 @@ public void iterate() {
     populateExpectedEntriesDeque();
     final Dbi<ByteBuffer> db = getDb();
     try (Txn<ByteBuffer> txn = env.txnRead();
-         CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+        CursorIterable<ByteBuffer> c = db.iterate(txn)) {
 
       for (final KeyVal<ByteBuffer> kv : c) {
         final Map.Entry<Integer, Integer> entry = expectedEntriesDeque.pollFirst();
         assertThat(entry).isNotNull();
-//        System.out.println(entry.getKey() + " => " + entry.getValue());
+        //        System.out.println(entry.getKey() + " => " + entry.getValue());
         assertThat(getNativeInt(kv.key())).isEqualTo(entry.getKey());
         assertThat(kv.val().getInt()).isEqualTo(entry.getValue());
       }
@@ -284,14 +283,16 @@ public void iterate() {
   }
 
   public void iteratorOnlyReturnedOnce() {
-    Assertions.assertThatThrownBy(() -> {
-      final Dbi<ByteBuffer> db = getDb();
-      try (Txn<ByteBuffer> txn = env.txnRead();
-           CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-        c.iterator(); // ok
-        c.iterator(); // fails
-      }
-    }).isInstanceOf(IllegalStateException.class);
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead();
+                  CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+                c.iterator(); // ok
+                c.iterator(); // fails
+              }
+            })
+        .isInstanceOf(IllegalStateException.class);
   }
 
   @Test
@@ -336,10 +337,12 @@ public void openClosedBackwardTestWithGuava() {
           return guava.compare(array1, array2);
         };
 
-    final Dbi<ByteBuffer> guavaDbi = env.createDbi()
-        .setDbName(DB_1).withIteratorComparator(ignored -> comparator)
-        .setDbiFlags(MDB_CREATE)
-        .open();
+    final Dbi<ByteBuffer> guavaDbi =
+        env.createDbi()
+            .setDbName(DB_1)
+            .withIteratorComparator(ignored -> comparator)
+            .setDbiFlags(MDB_CREATE)
+            .open();
 
     populateDatabase(guavaDbi);
     verify(openClosedBackward(bbNative(7), bbNative(2)), guavaDbi, 6, 4, 2);
@@ -380,61 +383,68 @@ public void removeOddElements() {
   }
 
   public void nextWithClosedEnvTest() {
-    Assertions.assertThatThrownBy(() -> {
-      final Dbi<ByteBuffer> db = getDb();
-      try (Txn<ByteBuffer> txn = env.txnRead()) {
-        try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
 
-          env.close();
-          c.next();
-        }
-      }
-    }).isInstanceOf(Env.AlreadyClosedException.class);
+                  env.close();
+                  c.next();
+                }
+              }
+            })
+        .isInstanceOf(Env.AlreadyClosedException.class);
   }
 
   public void removeWithClosedEnvTest() {
-    Assertions.assertThatThrownBy(() -> {
-      final Dbi<ByteBuffer> db = getDb();
-      try (Txn<ByteBuffer> txn = env.txnWrite()) {
-        try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
-          final KeyVal<ByteBuffer> keyVal = c.next();
-          assertThat(keyVal).isNotNull();
-          env.close();
-          c.remove();
-        }
-      }
-    }).isInstanceOf(Env.AlreadyClosedException.class);
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnWrite()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+                  final KeyVal<ByteBuffer> keyVal = c.next();
+                  assertThat(keyVal).isNotNull();
+                  env.close();
+                  c.remove();
+                }
+              }
+            })
+        .isInstanceOf(Env.AlreadyClosedException.class);
   }
 
   public void hasNextWithClosedEnvTest() {
-    Assertions.assertThatThrownBy(() -> {
-      final Dbi<ByteBuffer> db = getDb();
-      try (Txn<ByteBuffer> txn = env.txnRead()) {
-        try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
-
-          env.close();
-          c.hasNext();
-        }
-      }
-    }).isInstanceOf(Env.AlreadyClosedException.class);
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+                  env.close();
+                  c.hasNext();
+                }
+              }
+            })
+        .isInstanceOf(Env.AlreadyClosedException.class);
   }
 
   public void forEachRemainingWithClosedEnvTest() {
-    Assertions.assertThatThrownBy(() -> {
-      final Dbi<ByteBuffer> db = getDb();
-      try (Txn<ByteBuffer> txn = env.txnRead()) {
-        try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
-
-          env.close();
-          c.forEachRemaining(keyVal -> {
-          });
-        }
-      }
-    }).isInstanceOf(Env.AlreadyClosedException.class);
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+                  env.close();
+                  c.forEachRemaining(keyVal -> {});
+                }
+              }
+            })
+        .isInstanceOf(Env.AlreadyClosedException.class);
   }
 
   private void verify(final KeyRange<ByteBuffer> range, final int... expectedKeys) {
@@ -443,40 +453,39 @@ private void verify(final KeyRange<ByteBuffer> range, final int... expectedKeys)
     verify(range, db, expectedKeys);
   }
 
-  private void verify(final Dbi<ByteBuffer> dbi,
-                      final KeyRange<ByteBuffer> range,
-                      final int... expectedKeys) {
+  private void verify(
+      final Dbi<ByteBuffer> dbi, final KeyRange<ByteBuffer> range, final int... expectedKeys) {
     verify(range, dbi, expectedKeys);
   }
 
-  private void verify(final KeyRange<ByteBuffer> range,
-                      final Dbi<ByteBuffer> dbi,
-                      final int... expectedKeys) {
+  private void verify(
+      final KeyRange<ByteBuffer> range, final Dbi<ByteBuffer> dbi, final int... expectedKeys) {
     final boolean isForward = range.getType().isDirectionForward();
 
-    final List<Integer> expectedValues = Arrays.stream(expectedKeys)
-        .boxed()
-        .flatMap(key -> {
-          final int base = key * 10;
-          return isForward
-              ? Stream.of(base + 1, base + 2)
-              : Stream.of(base + 2, base + 1);
-        })
-        .collect(Collectors.toList());
+    final List<Integer> expectedValues =
+        Arrays.stream(expectedKeys)
+            .boxed()
+            .flatMap(
+                key -> {
+                  final int base = key * 10;
+                  return isForward ? Stream.of(base + 1, base + 2) : Stream.of(base + 2, base + 1);
+                })
+            .collect(Collectors.toList());
 
     final List<Integer> results = new ArrayList<>();
-//    System.out.println(rangeToString(range) + ", expected: " + expectedValues);
+    //    System.out.println(rangeToString(range) + ", expected: " + expectedValues);
 
     try (Txn<ByteBuffer> txn = env.txnRead();
-         CursorIterable<ByteBuffer> c = dbi.iterate(txn, range)) {
+        CursorIterable<ByteBuffer> c = dbi.iterate(txn, range)) {
       for (final KeyVal<ByteBuffer> kv : c) {
         final int key = getNativeInt(kv.key());
         final int val = kv.val().getInt();
-//        System.out.println(key + " => " + val);
+        //        System.out.println(key + " => " + val);
         results.add(val);
-        assertThat(val).satisfiesAnyOf(
-            v -> assertThat(v).isEqualTo((key * 10) + 1),
-              v -> assertThat(v).isEqualTo((key * 10) + 2));
+        assertThat(val)
+            .satisfiesAnyOf(
+                v -> assertThat(v).isEqualTo((key * 10) + 1),
+                v -> assertThat(v).isEqualTo((key * 10) + 2));
       }
     }
 
@@ -489,8 +498,11 @@ private void verify(final KeyRange<ByteBuffer> range,
   private String rangeToString(final KeyRange<ByteBuffer> range) {
     final ByteBuffer start = range.getStart();
     final ByteBuffer stop = range.getStop();
-    return range.getType() + " start: " + (start != null ? getNativeInt(start) : "")
-        + " stop: " + (stop != null ? getNativeInt(stop) : "");
+    return range.getType()
+        + " start: "
+        + (start != null ? getNativeInt(start) : "")
+        + " stop: "
+        + (stop != null ? getNativeInt(stop) : "");
   }
 
   private Dbi<ByteBuffer> getDb() {
@@ -499,10 +511,8 @@ private Dbi<ByteBuffer> getDb() {
     return dbi;
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   private static class DbiFactory {
     private final String name;
     private final Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory;
@@ -518,44 +528,51 @@ public String toString() {
     }
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   static class MyArgumentProvider implements ArgumentsProvider {
 
     @Override
-    public Stream<? extends Arguments> provideArguments(ParameterDeclarations parameters,
-                                                        ExtensionContext context) throws Exception {
-      final DbiFactory defaultComparatorDb = new DbiFactory("defaultComparator", env ->
-          env.createDbi()
-              .setDbName(DB_1)
-              .withDefaultComparator()
-              .setDbiFlags(DBI_FLAGS)
-              .open());
-      final DbiFactory nativeComparatorDb = new DbiFactory("nativeComparator", env ->
-          env.createDbi()
-              .setDbName(DB_2)
-              .withNativeComparator()
-              .setDbiFlags(DBI_FLAGS)
-              .open());
-      final DbiFactory callbackComparatorDb = new DbiFactory("callbackComparator", env ->
-          env.createDbi()
-              .setDbName(DB_3)
-              .withCallbackComparator(MyArgumentProvider::buildComparator)
-              .setDbiFlags(DBI_FLAGS)
-              .open());
-      final DbiFactory iteratorComparatorDb = new DbiFactory("iteratorComparator", env ->
-          env.createDbi()
-              .setDbName(DB_4)
-              .withIteratorComparator(MyArgumentProvider::buildComparator)
-              .setDbiFlags(DBI_FLAGS)
-              .open());
+    public Stream<? extends Arguments> provideArguments(
+        ParameterDeclarations parameters, ExtensionContext context) throws Exception {
+      final DbiFactory defaultComparatorDb =
+          new DbiFactory(
+              "defaultComparator",
+              env ->
+                  env.createDbi()
+                      .setDbName(DB_1)
+                      .withDefaultComparator()
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      final DbiFactory nativeComparatorDb =
+          new DbiFactory(
+              "nativeComparator",
+              env ->
+                  env.createDbi()
+                      .setDbName(DB_2)
+                      .withNativeComparator()
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      final DbiFactory callbackComparatorDb =
+          new DbiFactory(
+              "callbackComparator",
+              env ->
+                  env.createDbi()
+                      .setDbName(DB_3)
+                      .withCallbackComparator(MyArgumentProvider::buildComparator)
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      final DbiFactory iteratorComparatorDb =
+          new DbiFactory(
+              "iteratorComparator",
+              env ->
+                  env.createDbi()
+                      .setDbName(DB_4)
+                      .withIteratorComparator(MyArgumentProvider::buildComparator)
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
       return Stream.of(
-              defaultComparatorDb,
-              nativeComparatorDb,
-              callbackComparatorDb,
-              iteratorComparatorDb)
+              defaultComparatorDb, nativeComparatorDb, callbackComparatorDb, iteratorComparatorDb)
           .map(Arguments::of);
     }
 
@@ -564,8 +581,15 @@ private static Comparator<ByteBuffer> buildComparator(final DbiFlagSet dbiFlagSe
       return (o1, o2) -> {
         if (o1.remaining() != o2.remaining()) {
           // Make sure LMDB is always giving us consistent key lengths.
-          Assertions.fail("o1: " + o1 + " " + getNativeIntOrLong(o1)
-              + ", o2: " + o2 + " " + getNativeIntOrLong(o2));
+          Assertions.fail(
+              "o1: "
+                  + o1
+                  + " "
+                  + getNativeIntOrLong(o1)
+                  + ", o2: "
+                  + o2
+                  + " "
+                  + getNativeIntOrLong(o2));
         }
         return baseComparator.compare(o1, o2);
       };
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
index 3ff4364f..c35767c0 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
@@ -81,8 +81,8 @@
 import org.lmdbjava.CursorIterable.KeyVal;
 
 /**
- * Test {@link CursorIterable} using {@link DbiFlags#MDB_INTEGERKEY} to ensure that
- * comparators work with native order integer keys.
+ * Test {@link CursorIterable} using {@link DbiFlags#MDB_INTEGERKEY} to ensure that comparators work
+ * with native order integer keys.
  */
 @ParameterizedClass(name = "{index}: dbi: {0}")
 @ArgumentsSource(CursorIterableIntegerKeyTest.MyArgumentProvider.class)
@@ -95,19 +95,19 @@ public final class CursorIterableIntegerKeyTest {
   private Env<ByteBuffer> env;
   private Deque<Integer> list;
 
-  @Parameter
-  public DbiFactory dbiFactory;
+  @Parameter public DbiFactory dbiFactory;
 
   @BeforeEach
   public void before() throws IOException {
     file = FileUtil.createTempFile();
     final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
-    env = Env.create(bufferProxy)
-        .setMapSize(256, ByteUnit.KIBIBYTES)
-        .setMaxReaders(1)
-        .setMaxDbs(3)
-        .setEnvFlags(MDB_NOSUBDIR)
-        .open(file);
+    env =
+        Env.create(bufferProxy)
+            .setMapSize(256, ByteUnit.KIBIBYTES)
+            .setMaxReaders(1)
+            .setMaxDbs(3)
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(file);
 
     populateTestDataList();
   }
@@ -126,7 +126,7 @@ public void testNumericOrderLong() {
       final Cursor<ByteBuffer> c = dbi.openCursor(txn);
       long i = 1;
       while (true) {
-//        System.out.println("putting " + i);
+        //        System.out.println("putting " + i);
         c.put(bbNative(i), bb(i + "-long"));
         final long i2 = i * 10;
         if (i2 < i) {
@@ -146,18 +146,14 @@ public void testNumericOrderLong() {
           final String val = getString(keyVal.val());
           final long key = getNativeLong(keyVal.key());
           entries.add(new AbstractMap.SimpleEntry<>(key, val));
-//          System.out.println(val);
+          //          System.out.println(val);
         }
       }
     }
 
-    final List<Long> dbKeys = entries.stream()
-        .map(Map.Entry::getKey)
-        .collect(Collectors.toList());
-    final List<Long> dbKeysSorted = entries.stream()
-        .map(Map.Entry::getKey)
-        .sorted()
-        .collect(Collectors.toList());
+    final List<Long> dbKeys = entries.stream().map(Map.Entry::getKey).collect(Collectors.toList());
+    final List<Long> dbKeysSorted =
+        entries.stream().map(Map.Entry::getKey).sorted().collect(Collectors.toList());
     for (int i = 0; i < dbKeys.size(); i++) {
       final long dbKey1 = dbKeys.get(i);
       final long dbKey2 = dbKeysSorted.get(i);
@@ -173,7 +169,7 @@ public void testNumericOrderInt() {
       final Cursor<ByteBuffer> c = dbi.openCursor(txn);
       int i = 1;
       while (true) {
-//        System.out.println("putting " + i);
+        //        System.out.println("putting " + i);
         c.put(bbNative(i), bb(i + "-int"));
         final int i2 = i * 10;
         if (i2 < i) {
@@ -193,18 +189,15 @@ public void testNumericOrderInt() {
           final String val = getString(keyVal.val());
           final int key = TestUtils.getNativeInt(keyVal.key());
           entries.add(new AbstractMap.SimpleEntry<>(key, val));
-//          System.out.println(val);
+          //          System.out.println(val);
         }
       }
     }
 
-    final List<Integer> dbKeys = entries.stream()
-        .map(Map.Entry::getKey)
-        .collect(Collectors.toList());
-    final List<Integer> dbKeysSorted = entries.stream()
-        .map(Map.Entry::getKey)
-        .sorted()
-        .collect(Collectors.toList());
+    final List<Integer> dbKeys =
+        entries.stream().map(Map.Entry::getKey).collect(Collectors.toList());
+    final List<Integer> dbKeysSorted =
+        entries.stream().map(Map.Entry::getKey).sorted().collect(Collectors.toList());
     for (int i = 0; i < dbKeys.size(); i++) {
       final long dbKey1 = dbKeys.get(i);
       final long dbKey2 = dbKeysSorted.get(i);
@@ -218,7 +211,7 @@ public void testIntegerKeyKeySize() {
     long maxIntAsLong = Integer.MAX_VALUE;
 
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
-//      System.out.println("Flags: " + db.listFlags(txn));
+      //      System.out.println("Flags: " + db.listFlags(txn));
       int val = 0;
       db.put(txn, bbNative(0L), bb("val_" + ++val));
       db.put(txn, bbNative(10L), bb("val_" + ++val));
@@ -233,16 +226,16 @@ public void testIntegerKeyKeySize() {
       db.put(txn, bbNative(Long.MAX_VALUE), bb("val_" + ++val));
       txn.commit();
     }
-//    try (Txn<ByteBuffer> txn = env.txnRead()) {
-//      try (CursorIterable<ByteBuffer> iterable = db.iterate(txn)) {
-//        for (KeyVal<ByteBuffer> keyVal : iterable) {
-//          final String val = getString(keyVal.val());
-//          final long key = getNativeLong(keyVal.key());
-//          final int remaining = keyVal.key().remaining();
-//          System.out.println("key: " + key + ", val: " + val + ", remaining: " + remaining);
-//        }
-//      }
-//    }
+    //    try (Txn<ByteBuffer> txn = env.txnRead()) {
+    //      try (CursorIterable<ByteBuffer> iterable = db.iterate(txn)) {
+    //        for (KeyVal<ByteBuffer> keyVal : iterable) {
+    //          final String val = getString(keyVal.val());
+    //          final long key = getNativeLong(keyVal.key());
+    //          final int remaining = keyVal.key().remaining();
+    //          System.out.println("key: " + key + ", val: " + val + ", remaining: " + remaining);
+    //        }
+    //      }
+    //    }
   }
 
   @Test
@@ -337,14 +330,16 @@ public void greaterThanTest() {
   }
 
   public void iterableOnlyReturnedOnce() {
-    Assertions.assertThatThrownBy(() -> {
-      final Dbi<ByteBuffer> db = getDb();
-      try (Txn<ByteBuffer> txn = env.txnRead();
-           CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-        c.iterator(); // ok
-        c.iterator(); // fails
-      }
-    }).isInstanceOf(IllegalStateException.class);
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead();
+                  CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+                c.iterator(); // ok
+                c.iterator(); // fails
+              }
+            })
+        .isInstanceOf(IllegalStateException.class);
   }
 
   @Test
@@ -352,7 +347,7 @@ public void iterate() {
     populateTestDataList();
     final Dbi<ByteBuffer> db = getDb();
     try (Txn<ByteBuffer> txn = env.txnRead();
-         CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+        CursorIterable<ByteBuffer> c = db.iterate(txn)) {
 
       for (final KeyVal<ByteBuffer> kv : c) {
         assertThat(getNativeInt(kv.key())).isEqualTo(list.pollFirst());
@@ -362,14 +357,16 @@ public void iterate() {
   }
 
   public void iteratorOnlyReturnedOnce() {
-    Assertions.assertThatThrownBy(() -> {
-      final Dbi<ByteBuffer> db = getDb();
-      try (Txn<ByteBuffer> txn = env.txnRead();
-           CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-        c.iterator(); // ok
-        c.iterator(); // fails
-      }
-    }).isInstanceOf(IllegalStateException.class);
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead();
+                  CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+                c.iterator(); // ok
+                c.iterator(); // fails
+              }
+            })
+        .isInstanceOf(IllegalStateException.class);
   }
 
   @Test
@@ -385,21 +382,23 @@ public void lessThanTest() {
   }
 
   public void nextThrowsNoSuchElementExceptionIfNoMoreElements() {
-    Assertions.assertThatThrownBy(() -> {
-      populateTestDataList();
-      final Dbi<ByteBuffer> db = getDb();
-      try (Txn<ByteBuffer> txn = env.txnRead();
-           CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-        final Iterator<KeyVal<ByteBuffer>> i = c.iterator();
-        while (i.hasNext()) {
-          final KeyVal<ByteBuffer> kv = i.next();
-          assertThat(getNativeInt(kv.key())).isEqualTo(list.pollFirst());
-          assertThat(kv.val().getInt()).isEqualTo(list.pollFirst());
-        }
-        assertThat(i.hasNext()).isEqualTo(false);
-        i.next();
-      }
-    }).isInstanceOf(NoSuchElementException.class);
+    Assertions.assertThatThrownBy(
+            () -> {
+              populateTestDataList();
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead();
+                  CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+                final Iterator<KeyVal<ByteBuffer>> i = c.iterator();
+                while (i.hasNext()) {
+                  final KeyVal<ByteBuffer> kv = i.next();
+                  assertThat(getNativeInt(kv.key())).isEqualTo(list.pollFirst());
+                  assertThat(kv.val().getInt()).isEqualTo(list.pollFirst());
+                }
+                assertThat(i.hasNext()).isEqualTo(false);
+                i.next();
+              }
+            })
+        .isInstanceOf(NoSuchElementException.class);
   }
 
   @Test
@@ -431,11 +430,12 @@ public void openClosedBackwardTestWithGuava() {
           bb2.reset();
           return guava.compare(array1, array2);
         };
-    final Dbi<ByteBuffer> guavaDbi = env.createDbi()
-        .setDbName(DB_1)
-        .withIteratorComparator(ignored -> comparator)
-        .setDbiFlags(MDB_CREATE)
-        .open();
+    final Dbi<ByteBuffer> guavaDbi =
+        env.createDbi()
+            .setDbName(DB_1)
+            .withIteratorComparator(ignored -> comparator)
+            .setDbiFlags(MDB_CREATE)
+            .open();
     populateDatabase(guavaDbi);
     verify(openClosedBackward(bbNative(7), bbNative(2)), guavaDbi, 6, 4, 2);
     verify(openClosedBackward(bbNative(8), bbNative(4)), guavaDbi, 6, 4);
@@ -475,63 +475,70 @@ public void removeOddElements() {
   }
 
   public void nextWithClosedEnvTest() {
-    Assertions.assertThatThrownBy(() -> {
-      final Dbi<ByteBuffer> db = getDb();
-      try (Txn<ByteBuffer> txn = env.txnRead()) {
-        try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
 
-          env.close();
-          c.next();
-        }
-      }
-    }).isInstanceOf(Env.AlreadyClosedException.class);
+                  env.close();
+                  c.next();
+                }
+              }
+            })
+        .isInstanceOf(Env.AlreadyClosedException.class);
   }
 
   public void removeWithClosedEnvTest() {
-    Assertions.assertThatThrownBy(() -> {
-      final Dbi<ByteBuffer> db = getDb();
-      try (Txn<ByteBuffer> txn = env.txnWrite()) {
-        try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnWrite()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
 
-          final KeyVal<ByteBuffer> keyVal = c.next();
-          assertThat(keyVal).isNotNull();
+                  final KeyVal<ByteBuffer> keyVal = c.next();
+                  assertThat(keyVal).isNotNull();
 
-          env.close();
-          c.remove();
-        }
-      }
-    }).isInstanceOf(Env.AlreadyClosedException.class);
+                  env.close();
+                  c.remove();
+                }
+              }
+            })
+        .isInstanceOf(Env.AlreadyClosedException.class);
   }
 
   public void hasNextWithClosedEnvTest() {
-    Assertions.assertThatThrownBy(() -> {
-      final Dbi<ByteBuffer> db = getDb();
-      try (Txn<ByteBuffer> txn = env.txnRead()) {
-        try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
-
-          env.close();
-          c.hasNext();
-        }
-      }
-    }).isInstanceOf(Env.AlreadyClosedException.class);
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+                  env.close();
+                  c.hasNext();
+                }
+              }
+            })
+        .isInstanceOf(Env.AlreadyClosedException.class);
   }
 
   public void forEachRemainingWithClosedEnvTest() {
-    Assertions.assertThatThrownBy(() -> {
-      final Dbi<ByteBuffer> db = getDb();
-      try (Txn<ByteBuffer> txn = env.txnRead()) {
-        try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-          final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
-
-          env.close();
-          c.forEachRemaining(keyVal -> {
-          });
-        }
-      }
-    }).isInstanceOf(Env.AlreadyClosedException.class);
+    Assertions.assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+                  env.close();
+                  c.forEachRemaining(keyVal -> {});
+                }
+              }
+            })
+        .isInstanceOf(Env.AlreadyClosedException.class);
   }
 
   private void verify(final KeyRange<ByteBuffer> range, final int... expected) {
@@ -551,7 +558,7 @@ private void verify(
     final List<Integer> results = new ArrayList<>();
 
     try (Txn<ByteBuffer> txn = env.txnRead();
-         CursorIterable<ByteBuffer> c = dbi.iterate(txn, range)) {
+        CursorIterable<ByteBuffer> c = dbi.iterate(txn, range)) {
       for (final KeyVal<ByteBuffer> kv : c) {
         final int key = kv.key().order(ByteOrder.nativeOrder()).getInt();
         final int val = kv.val().getInt();
@@ -572,10 +579,8 @@ private Dbi<ByteBuffer> getDb() {
     return dbi;
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   private static class DbiFactory {
     private final String name;
     private final Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory;
@@ -591,44 +596,51 @@ public String toString() {
     }
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   static class MyArgumentProvider implements ArgumentsProvider {
 
     @Override
-    public Stream<? extends Arguments> provideArguments(ParameterDeclarations parameters,
-                                                        ExtensionContext context) throws Exception {
-      final DbiFactory defaultComparatorDb = new DbiFactory("defaultComparator", env ->
-          env.createDbi()
-              .setDbName(DB_1)
-              .withDefaultComparator()
-              .setDbiFlags(DBI_FLAGS)
-              .open());
-      final DbiFactory nativeComparatorDb = new DbiFactory("nativeComparator", env ->
-          env.createDbi()
-              .setDbName(DB_2)
-              .withNativeComparator()
-              .setDbiFlags(DBI_FLAGS)
-              .open());
-      final DbiFactory callbackComparatorDb = new DbiFactory("callbackComparator", env ->
-          env.createDbi()
-              .setDbName(DB_3)
-              .withCallbackComparator(MyArgumentProvider::buildComparator)
-              .setDbiFlags(DBI_FLAGS)
-              .open());
-      final DbiFactory iteratorComparatorDb = new DbiFactory("iteratorComparator", env ->
-          env.createDbi()
-              .setDbName(DB_4)
-              .withIteratorComparator(MyArgumentProvider::buildComparator)
-              .setDbiFlags(DBI_FLAGS)
-              .open());
+    public Stream<? extends Arguments> provideArguments(
+        ParameterDeclarations parameters, ExtensionContext context) throws Exception {
+      final DbiFactory defaultComparatorDb =
+          new DbiFactory(
+              "defaultComparator",
+              env ->
+                  env.createDbi()
+                      .setDbName(DB_1)
+                      .withDefaultComparator()
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      final DbiFactory nativeComparatorDb =
+          new DbiFactory(
+              "nativeComparator",
+              env ->
+                  env.createDbi()
+                      .setDbName(DB_2)
+                      .withNativeComparator()
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      final DbiFactory callbackComparatorDb =
+          new DbiFactory(
+              "callbackComparator",
+              env ->
+                  env.createDbi()
+                      .setDbName(DB_3)
+                      .withCallbackComparator(MyArgumentProvider::buildComparator)
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      final DbiFactory iteratorComparatorDb =
+          new DbiFactory(
+              "iteratorComparator",
+              env ->
+                  env.createDbi()
+                      .setDbName(DB_4)
+                      .withIteratorComparator(MyArgumentProvider::buildComparator)
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
       return Stream.of(
-              defaultComparatorDb,
-              nativeComparatorDb,
-              callbackComparatorDb,
-              iteratorComparatorDb)
+              defaultComparatorDb, nativeComparatorDb, callbackComparatorDb, iteratorComparatorDb)
           .map(Arguments::of);
     }
 
@@ -637,8 +649,15 @@ private static Comparator<ByteBuffer> buildComparator(final DbiFlagSet dbiFlagSe
       return (o1, o2) -> {
         if (o1.remaining() != o2.remaining()) {
           // Make sure LMDB is always giving us consistent key lengths.
-          Assertions.fail("o1: " + o1 + " " + getNativeIntOrLong(o1)
-              + ", o2: " + o2 + " " + getNativeIntOrLong(o2));
+          Assertions.fail(
+              "o1: "
+                  + o1
+                  + " "
+                  + getNativeIntOrLong(o1)
+                  + ", o2: "
+                  + o2
+                  + " "
+                  + getNativeIntOrLong(o2));
         }
         return baseComparator.compare(o1, o2);
       };
diff --git a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
index 82bf337d..9470abb2 100644
--- a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
@@ -58,24 +58,27 @@ public void before() throws IOException {
 
     final DbiFlagSet dbiFlagSet = MDB_CREATE;
     // Use a java comparator for start/stop keys only
-    Dbi<ByteBuffer> dbJavaComparator = env.createDbi()
-        .setDbName("JavaComparator")
-        .withDefaultComparator()
-        .setDbiFlags(dbiFlagSet)
-        .open();
+    Dbi<ByteBuffer> dbJavaComparator =
+        env.createDbi()
+            .setDbName("JavaComparator")
+            .withDefaultComparator()
+            .setDbiFlags(dbiFlagSet)
+            .open();
     // Use LMDB comparator for start/stop keys
-    Dbi<ByteBuffer> dbLmdbComparator = env.createDbi()
-        .setDbName("LmdbComparator")
-        .withNativeComparator()
-        .setDbiFlags(dbiFlagSet)
-        .open();
+    Dbi<ByteBuffer> dbLmdbComparator =
+        env.createDbi()
+            .setDbName("LmdbComparator")
+            .withNativeComparator()
+            .setDbiFlags(dbiFlagSet)
+            .open();
 
     // Use a java comparator for start/stop keys and as a callback comparator
-    Dbi<ByteBuffer> dbCallbackComparator = env.createDbi()
-        .setDbName("CallBackComparator")
-        .withCallbackComparator(bufferProxy::getComparator)
-        .setDbiFlags(dbiFlagSet)
-        .open();
+    Dbi<ByteBuffer> dbCallbackComparator =
+        env.createDbi()
+            .setDbName("CallBackComparator")
+            .withCallbackComparator(bufferProxy::getComparator)
+            .setDbiFlags(dbiFlagSet)
+            .open();
 
     dbs.add(dbJavaComparator);
     dbs.add(dbLmdbComparator);
diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index e57e8ca4..7c1aa227 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -71,9 +71,7 @@
 import org.junit.jupiter.params.support.ParameterDeclarations;
 import org.lmdbjava.CursorIterable.KeyVal;
 
-/**
- * Test {@link CursorIterable}.
- */
+/** Test {@link CursorIterable}. */
 @ParameterizedClass(name = "{index}: dbi: {0}")
 @ArgumentsSource(CursorIterableTest.MyArgumentProvider.class)
 public final class CursorIterableTest {
@@ -85,23 +83,23 @@ public final class CursorIterableTest {
   private Env<ByteBuffer> env;
   private Deque<Integer> list;
 
-//  /**
-//   * Injected by {@link #data()} with appropriate runner.
-//   */
-//  @SuppressWarnings("ClassEscapesDefinedScope")
-  @Parameter
-  public DbiFactory dbiFactory;
+  //  /**
+  //   * Injected by {@link #data()} with appropriate runner.
+  //   */
+  //  @SuppressWarnings("ClassEscapesDefinedScope")
+  @Parameter public DbiFactory dbiFactory;
 
   @BeforeEach
   void beforeEach() {
     file = FileUtil.createTempFile();
     final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
-    env = create(bufferProxy)
-        .setMapSize(256, ByteUnit.KIBIBYTES)
-        .setMaxReaders(1)
-        .setMaxDbs(3)
-        .setEnvFlags(MDB_NOSUBDIR)
-        .open(file);
+    env =
+        create(bufferProxy)
+            .setMapSize(256, ByteUnit.KIBIBYTES)
+            .setMaxReaders(1)
+            .setMaxDbs(3)
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(file);
 
     populateTestDataList();
   }
@@ -112,7 +110,6 @@ void afterEach() {
     FileUtil.delete(file);
   }
 
-
   private void populateTestDataList() {
     list = new LinkedList<>();
     list.addAll(asList(2, 3, 4, 5, 6, 7, 8, 9));
@@ -207,14 +204,14 @@ void greaterThanTest() {
   @Test
   void iterableOnlyReturnedOnce() {
     assertThatThrownBy(
-        () -> {
-          final Dbi<ByteBuffer> db = getDb();
-          try (Txn<ByteBuffer> txn = env.txnRead();
-               CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-            c.iterator(); // ok
-            c.iterator(); // fails
-          }
-        })
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead();
+                  CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+                c.iterator(); // ok
+                c.iterator(); // fails
+              }
+            })
         .isInstanceOf(IllegalStateException.class);
   }
 
@@ -222,7 +219,7 @@ void iterableOnlyReturnedOnce() {
   void iterate() {
     final Dbi<ByteBuffer> db = getDb();
     try (Txn<ByteBuffer> txn = env.txnRead();
-         CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+        CursorIterable<ByteBuffer> c = db.iterate(txn)) {
 
       for (final KeyVal<ByteBuffer> kv : c) {
         assertThat(kv.key().getInt()).isEqualTo(list.pollFirst());
@@ -234,14 +231,14 @@ void iterate() {
   @Test
   void iteratorOnlyReturnedOnce() {
     assertThatThrownBy(
-        () -> {
-          final Dbi<ByteBuffer> db = getDb();
-          try (Txn<ByteBuffer> txn = env.txnRead();
-               CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-            c.iterator(); // ok
-            c.iterator(); // fails
-          }
-        })
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead();
+                  CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+                c.iterator(); // ok
+                c.iterator(); // fails
+              }
+            })
         .isInstanceOf(IllegalStateException.class);
   }
 
@@ -260,21 +257,21 @@ void lessThanTest() {
   @Test
   void nextThrowsNoSuchElementExceptionIfNoMoreElements() {
     assertThatThrownBy(
-        () -> {
-          final Dbi<ByteBuffer> db = getDb();
-          populateTestDataList();
-          try (Txn<ByteBuffer> txn = env.txnRead();
-               CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-            final Iterator<KeyVal<ByteBuffer>> i = c.iterator();
-            while (i.hasNext()) {
-              final KeyVal<ByteBuffer> kv = i.next();
-              assertThat(kv.key().getInt()).isEqualTo(list.pollFirst());
-              assertThat(kv.val().getInt()).isEqualTo(list.pollFirst());
-            }
-            assertThat(i.hasNext()).isFalse();
-            i.next();
-          }
-        })
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              populateTestDataList();
+              try (Txn<ByteBuffer> txn = env.txnRead();
+                  CursorIterable<ByteBuffer> c = db.iterate(txn)) {
+                final Iterator<KeyVal<ByteBuffer>> i = c.iterator();
+                while (i.hasNext()) {
+                  final KeyVal<ByteBuffer> kv = i.next();
+                  assertThat(kv.key().getInt()).isEqualTo(list.pollFirst());
+                  assertThat(kv.val().getInt()).isEqualTo(list.pollFirst());
+                }
+                assertThat(i.hasNext()).isFalse();
+                i.next();
+              }
+            })
         .isInstanceOf(NoSuchElementException.class);
   }
 
@@ -307,11 +304,8 @@ void openClosedBackwardTestWithGuava() {
           bb2.reset();
           return guava.compare(array1, array2);
         };
-    final Dbi<ByteBuffer> guavaDbi = env.createDbi()
-        .setDbName(DB_1)
-        .withDefaultComparator()
-        .setDbiFlags(MDB_CREATE)
-        .open();
+    final Dbi<ByteBuffer> guavaDbi =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
     populateDatabase(guavaDbi);
     verify(openClosedBackward(bb(7), bb(2)), guavaDbi, 6, 4, 2);
     verify(openClosedBackward(bb(8), bb(4)), guavaDbi, 6, 4);
@@ -353,121 +347,121 @@ void removeOddElements() {
   @Test
   void nextWithClosedEnvTest() {
     assertThatThrownBy(
-        () -> {
-          final Dbi<ByteBuffer> db = getDb();
-          try (Txn<ByteBuffer> txn = env.txnRead()) {
-            try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-              final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
-
-              env.close();
-              c.next();
-            }
-          }
-        })
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+                  env.close();
+                  c.next();
+                }
+              }
+            })
         .isInstanceOf(Env.AlreadyClosedException.class);
   }
 
   @Test
   void removeWithClosedEnvTest() {
     assertThatThrownBy(
-        () -> {
-          final Dbi<ByteBuffer> db = getDb();
-          try (Txn<ByteBuffer> txn = env.txnWrite()) {
-            try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-              final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
-
-              final KeyVal<ByteBuffer> keyVal = c.next();
-              assertThat(keyVal).isNotNull();
-
-              env.close();
-              c.remove();
-            }
-          }
-        })
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnWrite()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+                  final KeyVal<ByteBuffer> keyVal = c.next();
+                  assertThat(keyVal).isNotNull();
+
+                  env.close();
+                  c.remove();
+                }
+              }
+            })
         .isInstanceOf(Env.AlreadyClosedException.class);
   }
 
   @Test
   void hasNextWithClosedEnvTest() {
     assertThatThrownBy(
-        () -> {
-          final Dbi<ByteBuffer> db = getDb();
-          try (Txn<ByteBuffer> txn = env.txnRead()) {
-            try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-              final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
-
-              env.close();
-              c.hasNext();
-            }
-          }
-        })
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+                  env.close();
+                  c.hasNext();
+                }
+              }
+            })
         .isInstanceOf(Env.AlreadyClosedException.class);
   }
 
   @Test
   void forEachRemainingWithClosedEnvTest() {
     assertThatThrownBy(
-        () -> {
-          final Dbi<ByteBuffer> db = getDb();
-          try (Txn<ByteBuffer> txn = env.txnRead()) {
-            try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-              final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
-
-              env.close();
-              c.forEachRemaining(keyVal -> {
-              });
-            }
-          }
-        })
+            () -> {
+              final Dbi<ByteBuffer> db = getDb();
+              try (Txn<ByteBuffer> txn = env.txnRead()) {
+                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
+
+                  env.close();
+                  c.forEachRemaining(keyVal -> {});
+                }
+              }
+            })
         .isInstanceOf(Env.AlreadyClosedException.class);
   }
 
-//  @Test
-//  public void testSignedVsUnsigned() {
-//    final ByteBuffer val1 = bb(1);
-//    final ByteBuffer val2 = bb(2);
-//    final ByteBuffer val110 = bb(110);
-//    final ByteBuffer val111 = bb(111);
-//    final ByteBuffer val150 = bb(150);
-//
-//    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
-//    final Comparator<ByteBuffer> unsignedComparator = bufferProxy.getUnsignedComparator();
-//    final Comparator<ByteBuffer> signedComparator = bufferProxy.getSignedComparator();
-//
-//    // Compare the same
-//    assertThat(
-//        unsignedComparator.compare(val1, val2), Matchers.is(signedComparator.compare(val1, val2)));
-//
-//    // Compare differently
-//    assertThat(
-//        unsignedComparator.compare(val110, val150),
-//        Matchers.not(signedComparator.compare(val110, val150)));
-//
-//    // Compare differently
-//    assertThat(
-//        unsignedComparator.compare(val111, val150),
-//        Matchers.not(signedComparator.compare(val111, val150)));
-//
-//    // This will fail if the db is using a signed comparator for the start/stop keys
-//    for (final Dbi<ByteBuffer> db : dbs) {
-//      db.put(val110, val110);
-//      db.put(val150, val150);
-//
-//      final ByteBuffer startKeyBuf = val111;
-//      KeyRange<ByteBuffer> keyRange = KeyRange.atLeastBackward(startKeyBuf);
-//
-//      try (Txn<ByteBuffer> txn = env.txnRead();
-//          CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
-//        for (final CursorIterable.KeyVal<ByteBuffer> kv : c) {
-//          final int key = kv.key().getInt();
-//          final int val = kv.val().getInt();
-//          //          System.out.println("key: " + key + " val: " + val);
-//          assertThat(key, is(110));
-//          break;
-//        }
-//      }
-//    }
-//  }
+  //  @Test
+  //  public void testSignedVsUnsigned() {
+  //    final ByteBuffer val1 = bb(1);
+  //    final ByteBuffer val2 = bb(2);
+  //    final ByteBuffer val110 = bb(110);
+  //    final ByteBuffer val111 = bb(111);
+  //    final ByteBuffer val150 = bb(150);
+  //
+  //    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
+  //    final Comparator<ByteBuffer> unsignedComparator = bufferProxy.getUnsignedComparator();
+  //    final Comparator<ByteBuffer> signedComparator = bufferProxy.getSignedComparator();
+  //
+  //    // Compare the same
+  //    assertThat(
+  //        unsignedComparator.compare(val1, val2), Matchers.is(signedComparator.compare(val1,
+  // val2)));
+  //
+  //    // Compare differently
+  //    assertThat(
+  //        unsignedComparator.compare(val110, val150),
+  //        Matchers.not(signedComparator.compare(val110, val150)));
+  //
+  //    // Compare differently
+  //    assertThat(
+  //        unsignedComparator.compare(val111, val150),
+  //        Matchers.not(signedComparator.compare(val111, val150)));
+  //
+  //    // This will fail if the db is using a signed comparator for the start/stop keys
+  //    for (final Dbi<ByteBuffer> db : dbs) {
+  //      db.put(val110, val110);
+  //      db.put(val150, val150);
+  //
+  //      final ByteBuffer startKeyBuf = val111;
+  //      KeyRange<ByteBuffer> keyRange = KeyRange.atLeastBackward(startKeyBuf);
+  //
+  //      try (Txn<ByteBuffer> txn = env.txnRead();
+  //          CursorIterable<ByteBuffer> c = db.iterate(txn, keyRange)) {
+  //        for (final CursorIterable.KeyVal<ByteBuffer> kv : c) {
+  //          final int key = kv.key().getInt();
+  //          final int val = kv.val().getInt();
+  //          //          System.out.println("key: " + key + " val: " + val);
+  //          assertThat(key, is(110));
+  //          break;
+  //        }
+  //      }
+  //    }
+  //  }
 
   private void verify(final KeyRange<ByteBuffer> range, final int... expected) {
     final Dbi<ByteBuffer> db = getDb();
@@ -479,14 +473,13 @@ private void verify(
     verify(range, dbi, expected);
   }
 
-  private void verify(final KeyRange<ByteBuffer> range,
-                      final Dbi<ByteBuffer> dbi,
-                      final int... expected) {
+  private void verify(
+      final KeyRange<ByteBuffer> range, final Dbi<ByteBuffer> dbi, final int... expected) {
 
     final List<Integer> results = new ArrayList<>();
 
     try (Txn<ByteBuffer> txn = env.txnRead();
-         CursorIterable<ByteBuffer> c = dbi.iterate(txn, range)) {
+        CursorIterable<ByteBuffer> c = dbi.iterate(txn, range)) {
       for (final KeyVal<ByteBuffer> kv : c) {
         final int key = kv.key().getInt();
         final int val = kv.val().getInt();
@@ -507,10 +500,8 @@ private Dbi<ByteBuffer> getDb() {
     return dbi;
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   private static class DbiFactory {
     private final String name;
     private final Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory;
@@ -526,44 +517,51 @@ public String toString() {
     }
   }
 
-
   // --------------------------------------------------------------------------------
 
-
   static class MyArgumentProvider implements ArgumentsProvider {
 
     @Override
-    public Stream<? extends Arguments> provideArguments(ParameterDeclarations parameters,
-                                                        ExtensionContext context) throws Exception {
-      final DbiFactory defaultComparatorDb = new DbiFactory("defaultComparator", env ->
-          env.createDbi()
-              .setDbName(DB_1)
-              .withDefaultComparator()
-              .setDbiFlags(DBI_FLAGS)
-              .open());
-      final DbiFactory nativeComparatorDb = new DbiFactory("nativeComparator", env ->
-          env.createDbi()
-              .setDbName(DB_2)
-              .withNativeComparator()
-              .setDbiFlags(DBI_FLAGS)
-              .open());
-      final DbiFactory callbackComparatorDb = new DbiFactory("callbackComparator", env ->
-          env.createDbi()
-              .setDbName(DB_3)
-              .withCallbackComparator(BUFFER_PROXY::getComparator)
-              .setDbiFlags(DBI_FLAGS)
-              .open());
-      final DbiFactory iteratorComparatorDb = new DbiFactory("iteratorComparator", env ->
-          env.createDbi()
-              .setDbName(DB_4)
-              .withIteratorComparator(BUFFER_PROXY::getComparator)
-              .setDbiFlags(DBI_FLAGS)
-              .open());
+    public Stream<? extends Arguments> provideArguments(
+        ParameterDeclarations parameters, ExtensionContext context) throws Exception {
+      final DbiFactory defaultComparatorDb =
+          new DbiFactory(
+              "defaultComparator",
+              env ->
+                  env.createDbi()
+                      .setDbName(DB_1)
+                      .withDefaultComparator()
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      final DbiFactory nativeComparatorDb =
+          new DbiFactory(
+              "nativeComparator",
+              env ->
+                  env.createDbi()
+                      .setDbName(DB_2)
+                      .withNativeComparator()
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      final DbiFactory callbackComparatorDb =
+          new DbiFactory(
+              "callbackComparator",
+              env ->
+                  env.createDbi()
+                      .setDbName(DB_3)
+                      .withCallbackComparator(BUFFER_PROXY::getComparator)
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
+      final DbiFactory iteratorComparatorDb =
+          new DbiFactory(
+              "iteratorComparator",
+              env ->
+                  env.createDbi()
+                      .setDbName(DB_4)
+                      .withIteratorComparator(BUFFER_PROXY::getComparator)
+                      .setDbiFlags(DBI_FLAGS)
+                      .open());
       return Stream.of(
-              defaultComparatorDb,
-              nativeComparatorDb,
-              callbackComparatorDb,
-              iteratorComparatorDb)
+              defaultComparatorDb, nativeComparatorDb, callbackComparatorDb, iteratorComparatorDb)
           .map(Arguments::of);
     }
   }
diff --git a/src/test/java/org/lmdbjava/CursorParamTest.java b/src/test/java/org/lmdbjava/CursorParamTest.java
index f2fc5fbb..3dac152e 100644
--- a/src/test/java/org/lmdbjava/CursorParamTest.java
+++ b/src/test/java/org/lmdbjava/CursorParamTest.java
@@ -56,7 +56,8 @@ public final class CursorParamTest {
 
   static Stream<Arguments> data() {
     return Stream.of(
-        Arguments.argumentSet("ByteBufferRunner(PROXY_OPTIMAL)", new ByteBufferRunner(PROXY_OPTIMAL)),
+        Arguments.argumentSet(
+            "ByteBufferRunner(PROXY_OPTIMAL)", new ByteBufferRunner(PROXY_OPTIMAL)),
         Arguments.argumentSet("ByteBufferRunner(PROXY_SAFE)", new ByteBufferRunner(PROXY_SAFE)),
         Arguments.argumentSet("ByteArrayRunner(PROXY_BA)", new ByteArrayRunner(PROXY_BA)),
         Arguments.argumentSet("DirectBufferRunner", new DirectBufferRunner()),
diff --git a/src/test/java/org/lmdbjava/CursorTest.java b/src/test/java/org/lmdbjava/CursorTest.java
index 7177000a..3d6b5b86 100644
--- a/src/test/java/org/lmdbjava/CursorTest.java
+++ b/src/test/java/org/lmdbjava/CursorTest.java
@@ -277,7 +277,8 @@ void getKeyVal() {
 
   @Test
   void putMultiple() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT, MDB_DUPFIXED));
+    final Dbi<ByteBuffer> db =
+        env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT, MDB_DUPFIXED));
     final int elemCount = 20;
 
     final ByteBuffer values = allocateDirect(Integer.BYTES * elemCount);
diff --git a/src/test/java/org/lmdbjava/DbiBuilderTest.java b/src/test/java/org/lmdbjava/DbiBuilderTest.java
index ede387c9..f7484f00 100644
--- a/src/test/java/org/lmdbjava/DbiBuilderTest.java
+++ b/src/test/java/org/lmdbjava/DbiBuilderTest.java
@@ -40,12 +40,13 @@ public class DbiBuilderTest {
   @BeforeEach
   public void before() {
     file = FileUtil.createTempFile();
-    env = create()
-        .setMapSize(64, ByteUnit.MEBIBYTES)
-        .setMaxReaders(2)
-        .setMaxDbs(2)
-        .setEnvFlags(MDB_NOSUBDIR)
-        .open(file);
+    env =
+        create()
+            .setMapSize(64, ByteUnit.MEBIBYTES)
+            .setMaxReaders(2)
+            .setMaxDbs(2)
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(file);
   }
 
   @AfterEach
@@ -56,11 +57,12 @@ public void after() {
 
   @Test
   public void unnamed() {
-    final Dbi<ByteBuffer> dbi = env.createDbi()
-        .withoutDbName()
-        .withDefaultComparator()
-        .setDbiFlags(DbiFlags.MDB_CREATE)
-        .open();
+    final Dbi<ByteBuffer> dbi =
+        env.createDbi()
+            .withoutDbName()
+            .withDefaultComparator()
+            .setDbiFlags(DbiFlags.MDB_CREATE)
+            .open();
     assertThat(dbi.getName()).isNull();
     assertThat(dbi.getNameAsString()).isEmpty();
     assertThat(env.getDbiNames()).isEmpty();
@@ -69,49 +71,46 @@ public void unnamed() {
 
   @Test
   public void named() {
-    final Dbi<ByteBuffer> dbi = env.createDbi()
-        .setDbName("foo")
-        .withDefaultComparator()
-        .setDbiFlags(DbiFlags.MDB_CREATE)
-        .open();
+    final Dbi<ByteBuffer> dbi =
+        env.createDbi()
+            .setDbName("foo")
+            .withDefaultComparator()
+            .setDbiFlags(DbiFlags.MDB_CREATE)
+            .open();
 
     assertPutAndGet(dbi);
 
     assertThat(env.getDbiNames()).hasSize(1);
-    assertThat(new String(env.getDbiNames().get(0), StandardCharsets.UTF_8))
-        .isEqualTo("foo");
-    assertThat(dbi.getNameAsString())
-        .isEqualTo("foo");
-    assertThat(dbi.getNameAsString(StandardCharsets.UTF_8))
-        .isEqualTo("foo");
+    assertThat(new String(env.getDbiNames().get(0), StandardCharsets.UTF_8)).isEqualTo("foo");
+    assertThat(dbi.getNameAsString()).isEqualTo("foo");
+    assertThat(dbi.getNameAsString(StandardCharsets.UTF_8)).isEqualTo("foo");
   }
 
   @Test
   public void named2() {
-    final Dbi<ByteBuffer> dbi = env.createDbi()
-        .setDbName("foo".getBytes(StandardCharsets.US_ASCII))
-        .withDefaultComparator()
-        .setDbiFlags(DbiFlags.MDB_CREATE)
-        .open();
+    final Dbi<ByteBuffer> dbi =
+        env.createDbi()
+            .setDbName("foo".getBytes(StandardCharsets.US_ASCII))
+            .withDefaultComparator()
+            .setDbiFlags(DbiFlags.MDB_CREATE)
+            .open();
 
     assertPutAndGet(dbi);
 
     assertThat(env.getDbiNames()).hasSize(1);
-    assertThat(new String(env.getDbiNames().get(0), StandardCharsets.US_ASCII))
-        .isEqualTo("foo");
-    assertThat(dbi.getNameAsString())
-        .isEqualTo("foo");
-    assertThat(dbi.getNameAsString(StandardCharsets.US_ASCII))
-        .isEqualTo("foo");
+    assertThat(new String(env.getDbiNames().get(0), StandardCharsets.US_ASCII)).isEqualTo("foo");
+    assertThat(dbi.getNameAsString()).isEqualTo("foo");
+    assertThat(dbi.getNameAsString(StandardCharsets.US_ASCII)).isEqualTo("foo");
   }
 
   @Test
   public void nativeComparator() {
-    final Dbi<ByteBuffer> dbi = env.createDbi()
-        .setDbName("foo")
-        .withNativeComparator()
-        .addDbiFlags(DbiFlags.MDB_CREATE)
-        .open();
+    final Dbi<ByteBuffer> dbi =
+        env.createDbi()
+            .setDbName("foo")
+            .withNativeComparator()
+            .addDbiFlags(DbiFlags.MDB_CREATE)
+            .open();
 
     assertPutAndGet(dbi);
     assertThat(env.getDbiNames()).hasSize(1);
@@ -121,69 +120,72 @@ public void nativeComparator() {
   public void callback() {
     final Comparator<ByteBuffer> proxyOptimal = ByteBufferProxy.PROXY_OPTIMAL.getComparator();
     // Compare on key length, falling back to default
-    final Comparator<ByteBuffer> comparator = (o1, o2) -> {
-      final int res = Integer.compare(o1.remaining(), o2.remaining());
-      if (res == 0) {
-        return proxyOptimal.compare(o1, o2);
-      } else {
-        return res;
-      }
-    };
-
-    final Dbi<ByteBuffer> dbi = env.createDbi()
-        .setDbName("foo")
-        .withCallbackComparator(ignored -> comparator)
-        .addDbiFlags(DbiFlags.MDB_CREATE)
-        .open();
-
-    TestUtils.doWithWriteTxn(env, txn -> {
-      dbi.put(txn, bb("fox"), bb("val_1"));
-      dbi.put(txn, bb("rabbit"), bb("val_2"));
-      dbi.put(txn, bb("deer"), bb("val_3"));
-      dbi.put(txn, bb("badger"), bb("val_4"));
-      txn.commit();
-    });
+    final Comparator<ByteBuffer> comparator =
+        (o1, o2) -> {
+          final int res = Integer.compare(o1.remaining(), o2.remaining());
+          if (res == 0) {
+            return proxyOptimal.compare(o1, o2);
+          } else {
+            return res;
+          }
+        };
+
+    final Dbi<ByteBuffer> dbi =
+        env.createDbi()
+            .setDbName("foo")
+            .withCallbackComparator(ignored -> comparator)
+            .addDbiFlags(DbiFlags.MDB_CREATE)
+            .open();
+
+    TestUtils.doWithWriteTxn(
+        env,
+        txn -> {
+          dbi.put(txn, bb("fox"), bb("val_1"));
+          dbi.put(txn, bb("rabbit"), bb("val_2"));
+          dbi.put(txn, bb("deer"), bb("val_3"));
+          dbi.put(txn, bb("badger"), bb("val_4"));
+          txn.commit();
+        });
 
     final List<String> keys = new ArrayList<>();
-    TestUtils.doWithReadTxn(env, txn -> {
-      try (CursorIterable<ByteBuffer> cursorIterable = dbi.iterate(txn)) {
-        final Iterator<CursorIterable.KeyVal<ByteBuffer>> iterator = cursorIterable.iterator();
-        iterator.forEachRemaining(keyVal -> {
-          keys.add(getString(keyVal.key()));
+    TestUtils.doWithReadTxn(
+        env,
+        txn -> {
+          try (CursorIterable<ByteBuffer> cursorIterable = dbi.iterate(txn)) {
+            final Iterator<CursorIterable.KeyVal<ByteBuffer>> iterator = cursorIterable.iterator();
+            iterator.forEachRemaining(
+                keyVal -> {
+                  keys.add(getString(keyVal.key()));
+                });
+          }
         });
-      }
-    });
-    assertThat(keys).containsExactly(
-        "fox",
-        "deer",
-        "badger",
-        "rabbit");
+    assertThat(keys).containsExactly("fox", "deer", "badger", "rabbit");
   }
 
   @Test
   public void flags() {
-    final Dbi<ByteBuffer> dbi = env.createDbi()
-        .setDbName("foo")
-        .withDefaultComparator()
-        .setDbiFlags(DbiFlags.MDB_DUPSORT, DbiFlags.MDB_DUPFIXED) // Will get overwritten
-        .setDbiFlags() // clear them
-        .addDbiFlags(DbiFlags.MDB_CREATE) // Not a dbi flag as far as lmdb is concerned.
-        .addDbiFlags(DbiFlags.MDB_INTEGERKEY)
-        .addDbiFlags(DbiFlags.MDB_REVERSEKEY)
-        .open();
+    final Dbi<ByteBuffer> dbi =
+        env.createDbi()
+            .setDbName("foo")
+            .withDefaultComparator()
+            .setDbiFlags(DbiFlags.MDB_DUPSORT, DbiFlags.MDB_DUPFIXED) // Will get overwritten
+            .setDbiFlags() // clear them
+            .addDbiFlags(DbiFlags.MDB_CREATE) // Not a dbi flag as far as lmdb is concerned.
+            .addDbiFlags(DbiFlags.MDB_INTEGERKEY)
+            .addDbiFlags(DbiFlags.MDB_REVERSEKEY)
+            .open();
 
     assertPutAndGet(dbi);
 
     assertThat(env.getDbiNames()).hasSize(1);
-    assertThat(new String(env.getDbiNames().get(0), StandardCharsets.UTF_8))
-        .isEqualTo("foo");
-
-    TestUtils.doWithReadTxn(env, readTxn -> {
-      assertThat(dbi.listFlags(readTxn))
-          .containsExactlyInAnyOrder(
-              DbiFlags.MDB_INTEGERKEY,
-              DbiFlags.MDB_REVERSEKEY);
-    });
+    assertThat(new String(env.getDbiNames().get(0), StandardCharsets.UTF_8)).isEqualTo("foo");
+
+    TestUtils.doWithReadTxn(
+        env,
+        readTxn -> {
+          assertThat(dbi.listFlags(readTxn))
+              .containsExactlyInAnyOrder(DbiFlags.MDB_INTEGERKEY, DbiFlags.MDB_REVERSEKEY);
+        });
   }
 
   private void assertPutAndGet(Dbi<ByteBuffer> dbi) {
diff --git a/src/test/java/org/lmdbjava/DbiFlagSetTest.java b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
index 06236497..1c44f0c0 100644
--- a/src/test/java/org/lmdbjava/DbiFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
@@ -22,39 +22,38 @@
 
 public class DbiFlagSetTest extends AbstractFlagSetTest<DbiFlags, DbiFlagSet> {
 
-    @Override
-    List<DbiFlags> getAllFlags() {
-        return Arrays.stream(DbiFlags.values())
-            .collect(Collectors.toList());
-    }
-
-    @Override
-    DbiFlagSet getEmptyFlagSet() {
-        return DbiFlagSet.empty();
-    }
-
-    @Override
-    AbstractFlagSet.Builder<DbiFlags, DbiFlagSet> getBuilder() {
-        return DbiFlagSet.builder();
-    }
-
-    @Override
-    Class<DbiFlags> getFlagType() {
-        return DbiFlags.class;
-    }
-
-    @Override
-    DbiFlagSet getFlagSet(Collection<DbiFlags> flags) {
-        return DbiFlagSet.of(flags);
-    }
-
-    @Override
-    DbiFlagSet getFlagSet(DbiFlags[] flags) {
-        return DbiFlagSet.of(flags);
-    }
-
-    @Override
-    DbiFlagSet getFlagSet(DbiFlags flag) {
-        return DbiFlagSet.of(flag);
-    }
+  @Override
+  List<DbiFlags> getAllFlags() {
+    return Arrays.stream(DbiFlags.values()).collect(Collectors.toList());
+  }
+
+  @Override
+  DbiFlagSet getEmptyFlagSet() {
+    return DbiFlagSet.empty();
+  }
+
+  @Override
+  AbstractFlagSet.Builder<DbiFlags, DbiFlagSet> getBuilder() {
+    return DbiFlagSet.builder();
+  }
+
+  @Override
+  Class<DbiFlags> getFlagType() {
+    return DbiFlags.class;
+  }
+
+  @Override
+  DbiFlagSet getFlagSet(Collection<DbiFlags> flags) {
+    return DbiFlagSet.of(flags);
+  }
+
+  @Override
+  DbiFlagSet getFlagSet(DbiFlags[] flags) {
+    return DbiFlagSet.of(flags);
+  }
+
+  @Override
+  DbiFlagSet getFlagSet(DbiFlags flag) {
+    return DbiFlagSet.of(flag);
+  }
 }
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 8b8a461b..f9e7a033 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -68,9 +68,7 @@
 import org.lmdbjava.Env.MapFullException;
 import org.lmdbjava.LmdbNativeException.ConstantDerivedException;
 
-/**
- * Test {@link Dbi}.
- */
+/** Test {@link Dbi}. */
 public final class DbiTest {
 
   private Path file;
@@ -81,19 +79,21 @@ public final class DbiTest {
   @BeforeEach
   void beforeEach() {
     file = FileUtil.createTempFile();
-    env = create()
-        .setMapSize(64, ByteUnit.MEBIBYTES)
-        .setMaxReaders(2)
-        .setMaxDbs(2)
-        .setEnvFlags(MDB_NOSUBDIR)
-        .open(file);
+    env =
+        create()
+            .setMapSize(64, ByteUnit.MEBIBYTES)
+            .setMaxReaders(2)
+            .setMaxDbs(2)
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(file);
     fileBa = FileUtil.createTempFile();
-    envBa = create(PROXY_BA)
-        .setMapSize(64, ByteUnit.MEBIBYTES)
-        .setMaxReaders(2)
-        .setMaxDbs(2)
-        .setEnvFlags(MDB_NOSUBDIR)
-        .open(fileBa);
+    envBa =
+        create(PROXY_BA)
+            .setMapSize(64, ByteUnit.MEBIBYTES)
+            .setMaxReaders(2)
+            .setMaxDbs(2)
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(fileBa);
   }
 
   @AfterEach
@@ -107,16 +107,17 @@ void afterEach() {
   @Test
   void close() {
     assertThatThrownBy(
-        () -> {
-          final Dbi<ByteBuffer> db = env.createDbi()
-              .setDbName(DB_1)
-              .withDefaultComparator()
-              .addDbiFlag(MDB_CREATE)
-              .open();
-          db.put(bb(1), bb(42));
-          db.close();
-          db.put(bb(2), bb(42)); // error
-        })
+            () -> {
+              final Dbi<ByteBuffer> db =
+                  env.createDbi()
+                      .setDbName(DB_1)
+                      .withDefaultComparator()
+                      .addDbiFlag(MDB_CREATE)
+                      .open();
+              db.put(bb(1), bb(42));
+              db.close();
+              db.put(bb(2), bb(42)); // error
+            })
         .isInstanceOf(ConstantDerivedException.class);
   }
 
@@ -151,11 +152,12 @@ private <T> void doCustomComparator(
       Comparator<T> comparator,
       IntFunction<T> serializer,
       ToIntFunction<T> deserializer) {
-    final Dbi<T> db = env.createDbi()
-        .setDbName(DB_1)
-        .withCallbackComparator(ignored -> comparator)
-        .setDbiFlags(MDB_CREATE)
-        .open();
+    final Dbi<T> db =
+        env.createDbi()
+            .setDbName(DB_1)
+            .withCallbackComparator(ignored -> comparator)
+            .setDbiFlags(MDB_CREATE)
+            .open();
     try (Txn<T> txn = env.txnWrite()) {
       assertThat(db.put(txn, serializer.apply(2), serializer.apply(3))).isTrue();
       assertThat(db.put(txn, serializer.apply(4), serializer.apply(6))).isTrue();
@@ -164,7 +166,7 @@ private <T> void doCustomComparator(
       txn.commit();
     }
     try (Txn<T> txn = env.txnRead();
-         CursorIterable<T> ci = db.iterate(txn, atMost(serializer.apply(4)))) {
+        CursorIterable<T> ci = db.iterate(txn, atMost(serializer.apply(4)))) {
       final Iterator<KeyVal<T>> iter = ci.iterator();
       assertThat(deserializer.applyAsInt(iter.next().key())).isEqualTo(8);
       assertThat(deserializer.applyAsInt(iter.next().key())).isEqualTo(6);
@@ -175,11 +177,11 @@ private <T> void doCustomComparator(
   @Test
   void dbOpenMaxDatabases() {
     assertThatThrownBy(
-        () -> {
-          env.openDbi("db1 is OK", MDB_CREATE);
-          env.openDbi("db2 is OK", MDB_CREATE);
-          env.openDbi("db3 fails", MDB_CREATE);
-        })
+            () -> {
+              env.openDbi("db1 is OK", MDB_CREATE);
+              env.openDbi("db2 is OK", MDB_CREATE);
+              env.openDbi("db3 fails", MDB_CREATE);
+            })
         .isInstanceOf(DbFullException.class);
   }
 
@@ -202,15 +204,14 @@ private <T> void doDbiWithComparatorThreadSafety(
       ToIntFunction<T> deserializer) {
     final DbiFlagSet flags = DbiFlagSet.of(MDB_CREATE, MDB_INTEGERKEY);
     final Comparator<T> comparator = comparatorSupplier.get();
-    final Dbi<T> db = env.createDbi()
-        .setDbName(DB_1)
-        .withCallbackComparator(ignored -> comparator)
-        .setDbiFlags(flags)
-        .open();
+    final Dbi<T> db =
+        env.createDbi()
+            .setDbName(DB_1)
+            .withCallbackComparator(ignored -> comparator)
+            .setDbiFlags(flags)
+            .open();
 
-    final List<Integer> keys = range(0, 1_000)
-        .boxed()
-        .collect(toList());
+    final List<Integer> keys = range(0, 1_000).boxed().collect(toList());
 
     // TODO surround with try-with-resources in J19+
     //noinspection resource // Not in J8
@@ -234,7 +235,7 @@ private <T> void doDbiWithComparatorThreadSafety(
     }
 
     try (Txn<T> txn = env.txnRead();
-         CursorIterable<T> ci = db.iterate(txn)) {
+        CursorIterable<T> ci = db.iterate(txn)) {
       final Iterator<KeyVal<T>> iter = ci.iterator();
       final List<Integer> result = new ArrayList<>();
       while (iter.hasNext()) {
@@ -314,8 +315,8 @@ void getName() {
 
   @Test
   void getNamesWhenDbisPresent() {
-    final byte[] dbHello = new byte[]{'h', 'e', 'l', 'l', 'o'};
-    final byte[] dbWorld = new byte[]{'w', 'o', 'r', 'l', 'd'};
+    final byte[] dbHello = new byte[] {'h', 'e', 'l', 'l', 'o'};
+    final byte[] dbWorld = new byte[] {'w', 'o', 'r', 'l', 'd'};
     env.openDbi(dbHello, MDB_CREATE);
     env.openDbi(dbWorld, MDB_CREATE);
     final List<byte[]> dbiNames = env.getDbiNames();
@@ -332,7 +333,8 @@ void getNamesWhenEmpty() {
 
   @Test
   void listsFlags() {
-    final Dbi<ByteBuffer> dbi = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT, MDB_REVERSEKEY));
+    final Dbi<ByteBuffer> dbi =
+        env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT, MDB_REVERSEKEY));
 
     try (Txn<ByteBuffer> txn = env.txnRead()) {
       final List<DbiFlags> flags = dbi.listFlags(txn);
@@ -391,12 +393,13 @@ void putCommitGet() {
   void putCommitGetByteArray() {
     FileUtil.useTempFile(
         file -> {
-          try (Env<byte[]> envBa = create(PROXY_BA)
-              .setMapSize(64, ByteUnit.MEBIBYTES)
-              .setMaxReaders(1)
-              .setMaxDbs(2)
-              .setEnvFlags(MDB_NOSUBDIR)
-              .open(file)) {
+          try (Env<byte[]> envBa =
+              create(PROXY_BA)
+                  .setMapSize(64, ByteUnit.MEBIBYTES)
+                  .setMaxReaders(1)
+                  .setMaxDbs(2)
+                  .setEnvFlags(MDB_NOSUBDIR)
+                  .open(file)) {
             final Dbi<byte[]> db = envBa.openDbi(DB_1, MDB_CREATE);
             try (Txn<byte[]> txn = envBa.txnWrite()) {
               db.put(txn, ba(5), ba(5));
@@ -528,19 +531,19 @@ void stats() {
   @Test
   void testMapFullException() {
     assertThatThrownBy(
-        () -> {
-          final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
-          try (Txn<ByteBuffer> txn = env.txnWrite()) {
-            final ByteBuffer v;
-            try {
-              v = allocateDirect(1_024 * 1_024 * 1_024);
-            } catch (final OutOfMemoryError e) {
-              // Travis CI OS X build cannot allocate this much memory, so assume OK
-              throw new MapFullException();
-            }
-            db.put(txn, bb(1), v);
-          }
-        })
+            () -> {
+              final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+              try (Txn<ByteBuffer> txn = env.txnWrite()) {
+                final ByteBuffer v;
+                try {
+                  v = allocateDirect(1_024 * 1_024 * 1_024);
+                } catch (final OutOfMemoryError e) {
+                  // Travis CI OS X build cannot allocate this much memory, so assume OK
+                  throw new MapFullException();
+                }
+                db.put(txn, bb(1), v);
+              }
+            })
         .isInstanceOf(MapFullException.class);
   }
 
@@ -565,110 +568,110 @@ void testParallelWritesStress() {
   @Test
   void closedEnvRejectsOpenCall() {
     assertThatThrownBy(
-        () -> {
-          env.close();
-          env.openDbi(DB_1, MDB_CREATE);
-        })
+            () -> {
+              env.close();
+              env.openDbi(DB_1, MDB_CREATE);
+            })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void closedEnvRejectsCloseCall() {
     assertThatThrownBy(
-        () -> {
-          doEnvClosedTest(null, (db, txn) -> db.close());
-        })
+            () -> {
+              doEnvClosedTest(null, (db, txn) -> db.close());
+            })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void closedEnvRejectsGetCall() {
     assertThatThrownBy(
-        () -> {
-          doEnvClosedTest(
-              (db, txn) -> {
-                final ByteBuffer valBuf = db.get(txn, bb(1));
-                assertThat(valBuf).isNotNull();
-                assertThat(valBuf.getInt()).isEqualTo(10);
-              },
-              (db, txn) -> db.get(txn, bb(2)));
-        })
+            () -> {
+              doEnvClosedTest(
+                  (db, txn) -> {
+                    final ByteBuffer valBuf = db.get(txn, bb(1));
+                    assertThat(valBuf).isNotNull();
+                    assertThat(valBuf.getInt()).isEqualTo(10);
+                  },
+                  (db, txn) -> db.get(txn, bb(2)));
+            })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void closedEnvRejectsPutCall() {
     assertThatThrownBy(
-        () -> {
-          doEnvClosedTest(null, (db, txn) -> db.put(bb(5), bb(50)));
-        })
+            () -> {
+              doEnvClosedTest(null, (db, txn) -> db.put(bb(5), bb(50)));
+            })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void closedEnvRejectsPutWithTxnCall() {
     assertThatThrownBy(
-        () -> {
-          doEnvClosedTest(
-              null,
-              (db, txn) -> {
-                db.put(txn, bb(5), bb(50));
-              });
-        })
+            () -> {
+              doEnvClosedTest(
+                  null,
+                  (db, txn) -> {
+                    db.put(txn, bb(5), bb(50));
+                  });
+            })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void closedEnvRejectsIterateCall() {
     assertThatThrownBy(
-        () -> {
-          doEnvClosedTest(null, Dbi::iterate);
-        })
+            () -> {
+              doEnvClosedTest(null, Dbi::iterate);
+            })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void closedEnvRejectsDropCall() {
     assertThatThrownBy(
-        () -> {
-          doEnvClosedTest(null, Dbi::drop);
-        })
+            () -> {
+              doEnvClosedTest(null, Dbi::drop);
+            })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void closedEnvRejectsDropAndDeleteCall() {
     assertThatThrownBy(
-        () -> {
-          doEnvClosedTest(null, (db, txn) -> db.drop(txn, true));
-        })
+            () -> {
+              doEnvClosedTest(null, (db, txn) -> db.drop(txn, true));
+            })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void closedEnvRejectsOpenCursorCall() {
     assertThatThrownBy(
-        () -> {
-          doEnvClosedTest(null, Dbi::openCursor);
-        })
+            () -> {
+              doEnvClosedTest(null, Dbi::openCursor);
+            })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void closedEnvRejectsReserveCall() {
     assertThatThrownBy(
-        () -> {
-          doEnvClosedTest(null, (db, txn) -> db.reserve(txn, bb(1), 32, MDB_NOOVERWRITE));
-        })
+            () -> {
+              doEnvClosedTest(null, (db, txn) -> db.reserve(txn, bb(1), 32, MDB_NOOVERWRITE));
+            })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void closedEnvRejectsStatCall() {
     assertThatThrownBy(
-        () -> {
-          doEnvClosedTest(null, Dbi::stat);
-        })
+            () -> {
+              doEnvClosedTest(null, Dbi::stat);
+            })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
diff --git a/src/test/java/org/lmdbjava/EnvFlagSetTest.java b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
index 98a033f5..bd181ce8 100644
--- a/src/test/java/org/lmdbjava/EnvFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
@@ -22,39 +22,38 @@
 
 public class EnvFlagSetTest extends AbstractFlagSetTest<EnvFlags, EnvFlagSet> {
 
-    @Override
-    List<EnvFlags> getAllFlags() {
-        return Arrays.stream(EnvFlags.values())
-            .collect(Collectors.toList());
-    }
-
-    @Override
-    EnvFlagSet getEmptyFlagSet() {
-        return EnvFlagSet.empty();
-    }
-
-    @Override
-    AbstractFlagSet.Builder<EnvFlags, EnvFlagSet> getBuilder() {
-        return EnvFlagSet.builder();
-    }
-
-    @Override
-    EnvFlagSet getFlagSet(Collection<EnvFlags> flags) {
-        return EnvFlagSet.of(flags);
-    }
-
-    @Override
-    EnvFlagSet getFlagSet(EnvFlags[] flags) {
-        return EnvFlagSet.of(flags);
-    }
-
-    @Override
-    EnvFlagSet getFlagSet(EnvFlags flag) {
-        return EnvFlagSet.of(flag);
-    }
-
-    @Override
-    Class<EnvFlags> getFlagType() {
-        return EnvFlags.class;
-    }
+  @Override
+  List<EnvFlags> getAllFlags() {
+    return Arrays.stream(EnvFlags.values()).collect(Collectors.toList());
+  }
+
+  @Override
+  EnvFlagSet getEmptyFlagSet() {
+    return EnvFlagSet.empty();
+  }
+
+  @Override
+  AbstractFlagSet.Builder<EnvFlags, EnvFlagSet> getBuilder() {
+    return EnvFlagSet.builder();
+  }
+
+  @Override
+  EnvFlagSet getFlagSet(Collection<EnvFlags> flags) {
+    return EnvFlagSet.of(flags);
+  }
+
+  @Override
+  EnvFlagSet getFlagSet(EnvFlags[] flags) {
+    return EnvFlagSet.of(flags);
+  }
+
+  @Override
+  EnvFlagSet getFlagSet(EnvFlags flag) {
+    return EnvFlagSet.of(flag);
+  }
+
+  @Override
+  Class<EnvFlags> getFlagType() {
+    return EnvFlags.class;
+  }
 }
diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index e1e72401..ab7c02ca 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -42,20 +42,19 @@
 import org.lmdbjava.Env.MapFullException;
 import org.lmdbjava.Txn.BadReaderLockException;
 
-/**
- * Test {@link Env}.
- */
+/** Test {@link Env}. */
 public final class EnvTest {
 
   @Test
   void byteUnit() {
     FileUtil.useTempFile(
         file -> {
-          try (Env<ByteBuffer> env = Env.create()
-              .setMaxReaders(1)
-              .setMapSize(1, ByteUnit.MEBIBYTES)
-              .setEnvFlags(MDB_NOSUBDIR)
-              .open(file)) {
+          try (Env<ByteBuffer> env =
+              Env.create()
+                  .setMaxReaders(1)
+                  .setMapSize(1, ByteUnit.MEBIBYTES)
+                  .setEnvFlags(MDB_NOSUBDIR)
+                  .open(file)) {
             final EnvInfo info = env.info();
             assertThat(info.mapSize).isEqualTo(ByteUnit.MEBIBYTES.toBytes(1));
           }
@@ -65,142 +64,132 @@ void byteUnit() {
   @Test
   void cannotChangeMapSizeAfterOpen() {
     assertThatThrownBy(
-        () -> {
-          FileUtil.useTempFile(
-              file -> {
-                final Builder<ByteBuffer> builder = Env.create()
-                    .setMaxReaders(1)
-                    .setEnvFlags(MDB_NOSUBDIR);
-                try (Env<ByteBuffer> ignored = builder.open(file)) {
-                  builder.setMapSize(1);
-                }
-              });
-        })
+            () -> {
+              FileUtil.useTempFile(
+                  file -> {
+                    final Builder<ByteBuffer> builder =
+                        Env.create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR);
+                    try (Env<ByteBuffer> ignored = builder.open(file)) {
+                      builder.setMapSize(1);
+                    }
+                  });
+            })
         .isInstanceOf(AlreadyOpenException.class);
   }
 
   @Test
   void cannotChangeMaxDbsAfterOpen() {
     assertThatThrownBy(
-        () -> {
-          FileUtil.useTempFile(
-              file -> {
-                final Builder<ByteBuffer> builder = Env.create()
-                    .setMaxReaders(1)
-                    .setEnvFlags(MDB_NOSUBDIR);
-                try (Env<ByteBuffer> ignored = builder.open(file)) {
-                  builder.setMaxDbs(1);
-                }
-              });
-        })
+            () -> {
+              FileUtil.useTempFile(
+                  file -> {
+                    final Builder<ByteBuffer> builder =
+                        Env.create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR);
+                    try (Env<ByteBuffer> ignored = builder.open(file)) {
+                      builder.setMaxDbs(1);
+                    }
+                  });
+            })
         .isInstanceOf(AlreadyOpenException.class);
   }
 
   @Test
   void cannotChangeMaxReadersAfterOpen() {
     assertThatThrownBy(
-        () -> {
-          FileUtil.useTempFile(
-              file -> {
-                final Builder<ByteBuffer> builder = Env.create()
-                    .setMaxReaders(1)
-                    .setEnvFlags(MDB_NOSUBDIR);
-                try (Env<ByteBuffer> ignored = builder.open(file)) {
-                  builder.setMaxReaders(1);
-                }
-              });
-        })
+            () -> {
+              FileUtil.useTempFile(
+                  file -> {
+                    final Builder<ByteBuffer> builder =
+                        Env.create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR);
+                    try (Env<ByteBuffer> ignored = builder.open(file)) {
+                      builder.setMaxReaders(1);
+                    }
+                  });
+            })
         .isInstanceOf(AlreadyOpenException.class);
   }
 
   @Test
   void cannotInfoOnceClosed() {
     assertThatThrownBy(
-        () -> {
-          FileUtil.useTempFile(
-              file -> {
-                final Env<ByteBuffer> env = Env.create()
-                    .setMaxReaders(1)
-                    .setEnvFlags(MDB_NOSUBDIR)
-                    .open(file);
-                env.close();
-                env.info();
-              });
-        })
+            () -> {
+              FileUtil.useTempFile(
+                  file -> {
+                    final Env<ByteBuffer> env =
+                        Env.create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR).open(file);
+                    env.close();
+                    env.info();
+                  });
+            })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void cannotOpenTwice() {
     assertThatThrownBy(
-        () -> {
-          FileUtil.useTempFile(
-              file -> {
-                final Builder<ByteBuffer> builder = Env.create()
-                    .setMaxReaders(1)
-                    .setEnvFlags(MDB_NOSUBDIR);
-                builder.open(file).close();
-                //noinspection resource // This will fail to open
-                builder.open(file);
-              });
-        })
+            () -> {
+              FileUtil.useTempFile(
+                  file -> {
+                    final Builder<ByteBuffer> builder =
+                        Env.create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR);
+                    builder.open(file).close();
+                    //noinspection resource // This will fail to open
+                    builder.open(file);
+                  });
+            })
         .isInstanceOf(AlreadyOpenException.class);
   }
 
   @Test
   void cannotOverflowMapSize() {
     assertThatThrownBy(
-        () -> {
-          final Builder<ByteBuffer> builder = Env.create().setMaxReaders(1);
-          final int mb = 1_024 * 1_024;
-          //noinspection NumericOverflow // Intentional overflow
-          final int size = mb * 2_048; // as per issue 18
-          builder.setMapSize(size);
-        })
+            () -> {
+              final Builder<ByteBuffer> builder = Env.create().setMaxReaders(1);
+              final int mb = 1_024 * 1_024;
+              //noinspection NumericOverflow // Intentional overflow
+              final int size = mb * 2_048; // as per issue 18
+              builder.setMapSize(size);
+            })
         .isInstanceOf(IllegalArgumentException.class);
   }
 
   @Test
   void negativeMapSize() {
     assertThatThrownBy(
-        () -> {
-          final Builder<ByteBuffer> builder = Env.create().setMaxReaders(1);
-          builder.setMapSize(-1);
-        })
+            () -> {
+              final Builder<ByteBuffer> builder = Env.create().setMaxReaders(1);
+              builder.setMapSize(-1);
+            })
         .isInstanceOf(IllegalArgumentException.class);
   }
 
   @Test
   void cannotStatOnceClosed() {
     assertThatThrownBy(
-        () -> {
-          FileUtil.useTempFile(
-              file -> {
-                final Env<ByteBuffer> env = Env.create()
-                    .setMaxReaders(1)
-                    .setEnvFlags(MDB_NOSUBDIR)
-                    .open(file);
-                env.close();
-                env.stat();
-              });
-        })
+            () -> {
+              FileUtil.useTempFile(
+                  file -> {
+                    final Env<ByteBuffer> env =
+                        Env.create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR).open(file);
+                    env.close();
+                    env.stat();
+                  });
+            })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
   @Test
   void cannotSyncOnceClosed() {
     assertThatThrownBy(
-        () -> {
-          FileUtil.useTempFile(
-              file -> {
-                final Env<ByteBuffer> env = Env.create()
-                    .setMaxReaders(1)
-                    .setEnvFlags(MDB_NOSUBDIR)
-                    .open(file);
-                env.close();
-                env.sync(false);
-              });
-        })
+            () -> {
+              FileUtil.useTempFile(
+                  file -> {
+                    final Env<ByteBuffer> env =
+                        Env.create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR).open(file);
+                    env.close();
+                    env.sync(false);
+                  });
+            })
         .isInstanceOf(AlreadyClosedException.class);
   }
 
@@ -224,66 +213,64 @@ void copyDirectoryBased() {
   @Test
   void copyDirectoryRejectsFileDestination() {
     assertThatThrownBy(
-        () -> {
-          FileUtil.useTempDir(
-              dest -> {
-                FileUtil.deleteDir(dest);
-                FileUtil.useTempDir(
-                    src -> {
-                      try (Env<ByteBuffer> env = Env.create().setMaxReaders(1).open(src)) {
-                        env.copy(dest.toFile(), MDB_CP_COMPACT);
-                      }
-                    });
-              });
-        })
+            () -> {
+              FileUtil.useTempDir(
+                  dest -> {
+                    FileUtil.deleteDir(dest);
+                    FileUtil.useTempDir(
+                        src -> {
+                          try (Env<ByteBuffer> env = Env.create().setMaxReaders(1).open(src)) {
+                            env.copy(dest.toFile(), MDB_CP_COMPACT);
+                          }
+                        });
+                  });
+            })
         .isInstanceOf(InvalidCopyDestination.class);
   }
 
   @Test
   void copyDirectoryRejectsMissingDestination() {
     assertThatThrownBy(
-        () -> {
-          FileUtil.useTempDir(
-              dest -> {
-                try {
-                  Files.delete(dest);
-                  FileUtil.useTempDir(
-                      src -> {
-                        try (Env<ByteBuffer> env =
-                                 Env.create().setMaxReaders(1).open(src)) {
-                          env.copy(dest.toFile(), MDB_CP_COMPACT);
-                        }
-                      });
-                } catch (final IOException e) {
-                  throw new UncheckedIOException(e);
-                }
-              });
-        })
+            () -> {
+              FileUtil.useTempDir(
+                  dest -> {
+                    try {
+                      Files.delete(dest);
+                      FileUtil.useTempDir(
+                          src -> {
+                            try (Env<ByteBuffer> env = Env.create().setMaxReaders(1).open(src)) {
+                              env.copy(dest.toFile(), MDB_CP_COMPACT);
+                            }
+                          });
+                    } catch (final IOException e) {
+                      throw new UncheckedIOException(e);
+                    }
+                  });
+            })
         .isInstanceOf(InvalidCopyDestination.class);
   }
 
   @Test
   void copyDirectoryRejectsNonEmptyDestination() {
     assertThatThrownBy(
-        () -> {
-          FileUtil.useTempDir(
-              dest -> {
-                try {
-                  final Path subDir = dest.resolve("hello");
-                  Files.createDirectory(subDir);
-                  assertThat(Files.isDirectory(subDir)).isTrue();
-                  FileUtil.useTempDir(
-                      src -> {
-                        try (Env<ByteBuffer> env =
-                                 Env.create().setMaxReaders(1).open(src)) {
-                          env.copy(dest.toFile(), MDB_CP_COMPACT);
-                        }
-                      });
-                } catch (final IOException e) {
-                  throw new UncheckedIOException(e);
-                }
-              });
-        })
+            () -> {
+              FileUtil.useTempDir(
+                  dest -> {
+                    try {
+                      final Path subDir = dest.resolve("hello");
+                      Files.createDirectory(subDir);
+                      assertThat(Files.isDirectory(subDir)).isTrue();
+                      FileUtil.useTempDir(
+                          src -> {
+                            try (Env<ByteBuffer> env = Env.create().setMaxReaders(1).open(src)) {
+                              env.copy(dest.toFile(), MDB_CP_COMPACT);
+                            }
+                          });
+                    } catch (final IOException e) {
+                      throw new UncheckedIOException(e);
+                    }
+                  });
+            })
         .isInstanceOf(InvalidCopyDestination.class);
   }
 
@@ -296,7 +283,7 @@ void copyFileBased() {
           FileUtil.useTempFile(
               src -> {
                 try (Env<ByteBuffer> env =
-                         Env.create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR).open(src)) {
+                    Env.create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR).open(src)) {
                   env.copy(dest.toFile(), MDB_CP_COMPACT);
                 }
                 assertThat(FileUtil.size(dest)).isGreaterThan(0L);
@@ -307,19 +294,19 @@ void copyFileBased() {
   @Test
   void copyFileRejectsExistingDestination() {
     assertThatThrownBy(
-        () -> {
-          FileUtil.useTempFile(
-              dest -> {
-                assertThat(Files.exists(dest)).isTrue();
-                FileUtil.useTempFile(
-                    src -> {
-                      try (Env<ByteBuffer> env =
-                               Env.create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR).open(src)) {
-                        env.copy(dest.toFile(), MDB_CP_COMPACT);
-                      }
-                    });
-              });
-        })
+            () -> {
+              FileUtil.useTempFile(
+                  dest -> {
+                    assertThat(Files.exists(dest)).isTrue();
+                    FileUtil.useTempFile(
+                        src -> {
+                          try (Env<ByteBuffer> env =
+                              Env.create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR).open(src)) {
+                            env.copy(dest.toFile(), MDB_CP_COMPACT);
+                          }
+                        });
+                  });
+            })
         .isInstanceOf(InvalidCopyDestination.class);
   }
 
@@ -340,12 +327,13 @@ void createAsDirectory() {
   void createAsFile() {
     FileUtil.useTempFile(
         file -> {
-          try (Env<ByteBuffer> env = Env.create()
-              .setMapSize(1, ByteUnit.MEBIBYTES)
-              .setMaxDbs(1)
-              .setMaxReaders(1)
-              .setEnvFlags(MDB_NOSUBDIR)
-              .open(file)) {
+          try (Env<ByteBuffer> env =
+              Env.create()
+                  .setMapSize(1, ByteUnit.MEBIBYTES)
+                  .setMaxDbs(1)
+                  .setMaxReaders(1)
+                  .setEnvFlags(MDB_NOSUBDIR)
+                  .open(file)) {
             env.sync(true);
             assertThat(Files.isRegularFile(file)).isTrue();
           }
@@ -355,16 +343,16 @@ void createAsFile() {
   @Test
   void detectTransactionThreadViolation() {
     assertThatThrownBy(
-        () -> {
-          FileUtil.useTempFile(
-              file -> {
-                try (Env<ByteBuffer> env =
-                         Env.create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR).open(file)) {
-                  env.txnRead();
-                  env.txnRead();
-                }
-              });
-        })
+            () -> {
+              FileUtil.useTempFile(
+                  file -> {
+                    try (Env<ByteBuffer> env =
+                        Env.create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR).open(file)) {
+                      env.txnRead();
+                      env.txnRead();
+                    }
+                  });
+            })
         .isInstanceOf(BadReaderLockException.class);
   }
 
@@ -372,11 +360,12 @@ void detectTransactionThreadViolation() {
   void info() {
     FileUtil.useTempFile(
         file -> {
-          try (Env<ByteBuffer> env = Env.create()
-              .setMaxReaders(4)
-              .setMapSize(123_456)
-              .setEnvFlags(MDB_NOSUBDIR)
-              .open(file)) {
+          try (Env<ByteBuffer> env =
+              Env.create()
+                  .setMaxReaders(4)
+                  .setMapSize(123_456)
+                  .setEnvFlags(MDB_NOSUBDIR)
+                  .open(file)) {
             final EnvInfo info = env.info();
             assertThat(info).isNotNull();
             assertThat(info.lastPageNumber).isEqualTo(1L);
@@ -394,31 +383,31 @@ void info() {
   @Test
   void mapFull() {
     assertThatThrownBy(
-        () -> {
-          FileUtil.useTempDir(
-              dir -> {
-                final byte[] k = new byte[500];
-                final ByteBuffer key = allocateDirect(500);
-                final ByteBuffer val = allocateDirect(1_024);
-                final Random rnd = new Random();
-                try (Env<ByteBuffer> env =
-                         Env.create()
-                             .setMaxReaders(1)
-                             .setMapSize(8, ByteUnit.MEBIBYTES)
-                             .setMaxDbs(1)
-                             .open(dir)) {
-                  final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
-                  //noinspection InfiniteLoopStatement // Needs infinite loop to fill the env
-                  for (; ; ) {
-                    rnd.nextBytes(k);
-                    key.clear();
-                    key.put(k).flip();
-                    val.clear();
-                    db.put(key, val);
-                  }
-                }
-              });
-        })
+            () -> {
+              FileUtil.useTempDir(
+                  dir -> {
+                    final byte[] k = new byte[500];
+                    final ByteBuffer key = allocateDirect(500);
+                    final ByteBuffer val = allocateDirect(1_024);
+                    final Random rnd = new Random();
+                    try (Env<ByteBuffer> env =
+                        Env.create()
+                            .setMaxReaders(1)
+                            .setMapSize(8, ByteUnit.MEBIBYTES)
+                            .setMaxDbs(1)
+                            .open(dir)) {
+                      final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+                      //noinspection InfiniteLoopStatement // Needs infinite loop to fill the env
+                      for (; ; ) {
+                        rnd.nextBytes(k);
+                        key.clear();
+                        key.put(k).flip();
+                        val.clear();
+                        db.put(key, val);
+                      }
+                    }
+                  });
+            })
         .isInstanceOf(MapFullException.class);
   }
 
@@ -426,16 +415,12 @@ void mapFull() {
   void readOnlySupported() {
     FileUtil.useTempDir(
         dir -> {
-          try (Env<ByteBuffer> rwEnv = Env.create()
-              .setMaxReaders(1)
-              .open(dir)) {
+          try (Env<ByteBuffer> rwEnv = Env.create().setMaxReaders(1).open(dir)) {
             final Dbi<ByteBuffer> rwDb = rwEnv.openDbi(DB_1, MDB_CREATE);
             rwDb.put(bb(1), bb(42));
           }
-          try (Env<ByteBuffer> roEnv = Env.create()
-              .setMaxReaders(1)
-              .setEnvFlags(MDB_RDONLY_ENV)
-              .open(dir)) {
+          try (Env<ByteBuffer> roEnv =
+              Env.create().setMaxReaders(1).setEnvFlags(MDB_RDONLY_ENV).open(dir)) {
             final Dbi<ByteBuffer> roDb = roEnv.openDbi(DB_1, DbiFlagSet.EMPTY);
             try (Txn<ByteBuffer> roTxn = roEnv.txnRead()) {
               assertThat(roDb.get(roTxn, bb(1))).isNotNull();
@@ -452,11 +437,12 @@ void setMapSize() {
           final ByteBuffer key = allocateDirect(500);
           final ByteBuffer val = allocateDirect(1_024);
           final Random rnd = new Random();
-          try (Env<ByteBuffer> env = Env.create()
-              .setMaxReaders(1)
-              .setMapSize(256, ByteUnit.KIBIBYTES)
-              .setMaxDbs(1)
-              .open(dir)) {
+          try (Env<ByteBuffer> env =
+              Env.create()
+                  .setMaxReaders(1)
+                  .setMapSize(256, ByteUnit.KIBIBYTES)
+                  .setMaxDbs(1)
+                  .open(dir)) {
             final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
 
             db.put(bb(1), bb(42));
@@ -474,9 +460,11 @@ void setMapSize() {
             }
             assertThat(mapFullExThrown).isTrue();
 
-            assertThatThrownBy(() -> {
-              env.setMapSize(-1, ByteUnit.KIBIBYTES);
-            }).isInstanceOf(IllegalArgumentException.class);
+            assertThatThrownBy(
+                    () -> {
+                      env.setMapSize(-1, ByteUnit.KIBIBYTES);
+                    })
+                .isInstanceOf(IllegalArgumentException.class);
 
             env.setMapSize(1024, ByteUnit.KIBIBYTES);
 
@@ -507,10 +495,8 @@ void setMapSize() {
   void stats() {
     FileUtil.useTempFile(
         file -> {
-          try (Env<ByteBuffer> env = Env.create()
-              .setMaxReaders(1)
-              .setEnvFlags(MDB_NOSUBDIR)
-              .open(file)) {
+          try (Env<ByteBuffer> env =
+              Env.create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR).open(file)) {
             final Stat stat = env.stat();
             assertThat(stat).isNotNull();
             assertThat(stat.branchPages).isEqualTo(0L);
@@ -550,10 +536,8 @@ void testDefaultOpenNoName1() {
 
             // As this is the unnamed database it returns all keys in the unnamed db
             final List<byte[]> dbiNames = env.getDbiNames();
-            assertThat(dbiNames)
-                .hasSize(2);
-            assertThat(dbiNames.get(0))
-                .isEqualTo("abc".getBytes(Env.DEFAULT_NAME_CHARSET));
+            assertThat(dbiNames).hasSize(2);
+            assertThat(dbiNames.get(0)).isEqualTo("abc".getBytes(Env.DEFAULT_NAME_CHARSET));
           }
         });
   }
@@ -569,10 +553,8 @@ void testDefaultOpenNoName2() {
 
             // As this is the unnamed database it returns all keys in the unnamed db
             final List<byte[]> dbiNames = env.getDbiNames();
-            assertThat(dbiNames)
-                .hasSize(1);
-            assertThat(dbiNames.get(0))
-                .isEqualTo(new byte[0]);
+            assertThat(dbiNames).hasSize(1);
+            assertThat(dbiNames.get(0)).isEqualTo(new byte[0]);
           }
         });
   }
diff --git a/src/test/java/org/lmdbjava/GarbageCollectionTest.java b/src/test/java/org/lmdbjava/GarbageCollectionTest.java
index 21ef5182..71523c66 100644
--- a/src/test/java/org/lmdbjava/GarbageCollectionTest.java
+++ b/src/test/java/org/lmdbjava/GarbageCollectionTest.java
@@ -37,10 +37,7 @@ public class GarbageCollectionTest {
   void buffersNotGarbageCollectedTest() {
     FileUtil.useTempDir(
         dir -> {
-          try (Env<ByteBuffer> env = create()
-              .setMapSize(2_085_760_999)
-              .setMaxDbs(1)
-              .open(dir)) {
+          try (Env<ByteBuffer> env = create().setMapSize(2_085_760_999).setMaxDbs(1).open(dir)) {
             final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
 
             try (Txn<ByteBuffer> txn = env.txnWrite()) {
diff --git a/src/test/java/org/lmdbjava/PutFlagSetTest.java b/src/test/java/org/lmdbjava/PutFlagSetTest.java
index 9991b870..bc1a24e0 100644
--- a/src/test/java/org/lmdbjava/PutFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/PutFlagSetTest.java
@@ -28,8 +28,7 @@ public class PutFlagSetTest extends AbstractFlagSetTest<PutFlags, PutFlagSet> {
 
   @Override
   List<PutFlags> getAllFlags() {
-    return Arrays.stream(PutFlags.values())
-        .collect(Collectors.toList());
+    return Arrays.stream(PutFlags.values()).collect(Collectors.toList());
   }
 
   @Override
@@ -67,10 +66,14 @@ public void testAddFlagVsCheckPresence() {
 
     final int cnt = 10_000_000;
     final int[] arr = new int[cnt];
-    final List<PutFlagSet> flagSets = IntStream.range(0, cnt)
-        .boxed()
-        .map(i -> PutFlagSet.of(PutFlags.MDB_APPEND, PutFlags.MDB_NOOVERWRITE, PutFlags.MDB_RESERVE))
-        .collect(Collectors.toList());
+    final List<PutFlagSet> flagSets =
+        IntStream.range(0, cnt)
+            .boxed()
+            .map(
+                i ->
+                    PutFlagSet.of(
+                        PutFlags.MDB_APPEND, PutFlags.MDB_NOOVERWRITE, PutFlags.MDB_RESERVE))
+            .collect(Collectors.toList());
 
     Instant time;
     for (int i = 0; i < 5; i++) {
diff --git a/src/test/java/org/lmdbjava/TestUtils.java b/src/test/java/org/lmdbjava/TestUtils.java
index 68d988d1..2545fecf 100644
--- a/src/test/java/org/lmdbjava/TestUtils.java
+++ b/src/test/java/org/lmdbjava/TestUtils.java
@@ -69,29 +69,25 @@ static ByteBuffer bb(final String value) {
   }
 
   static ByteBuffer bbNative(final int value) {
-    final ByteBuffer bb = allocateDirect(Integer.BYTES)
-        .order(ByteOrder.nativeOrder());
+    final ByteBuffer bb = allocateDirect(Integer.BYTES).order(ByteOrder.nativeOrder());
     bb.putInt(value).flip();
     return bb;
   }
 
   static ByteBuffer bbNative(final long value) {
-    final ByteBuffer bb = allocateDirect(Long.BYTES)
-        .order(ByteOrder.nativeOrder());
+    final ByteBuffer bb = allocateDirect(Long.BYTES).order(ByteOrder.nativeOrder());
     bb.putLong(value).flip();
     return bb;
   }
 
   static int getNativeInt(final ByteBuffer bb) {
-    final int val = bb.order(ByteOrder.nativeOrder())
-        .getInt();
+    final int val = bb.order(ByteOrder.nativeOrder()).getInt();
     bb.rewind();
     return val;
   }
 
   static long getNativeLong(final ByteBuffer bb) {
-    final long val = bb.order(ByteOrder.nativeOrder())
-        .getLong();
+    final long val = bb.order(ByteOrder.nativeOrder()).getLong();
     bb.rewind();
     return val;
   }
@@ -105,8 +101,7 @@ static long getNativeIntOrLong(final ByteBuffer bb) {
   }
 
   static String getString(final ByteBuffer bb) {
-    final String str = StandardCharsets.UTF_8.decode(bb)
-        .toString();
+    final String str = StandardCharsets.UTF_8.decode(bb).toString();
     bb.rewind();
     return str;
   }
diff --git a/src/test/java/org/lmdbjava/TutorialTest.java b/src/test/java/org/lmdbjava/TutorialTest.java
index 93c4a031..5b875edf 100644
--- a/src/test/java/org/lmdbjava/TutorialTest.java
+++ b/src/test/java/org/lmdbjava/TutorialTest.java
@@ -55,9 +55,7 @@ public final class TutorialTest {
 
   private static final String DB_NAME = "my DB";
 
-  /**
-   * In this first tutorial we will use LmdbJava with some basic defaults.
-   */
+  /** In this first tutorial we will use LmdbJava with some basic defaults. */
   @Test
   void tutorial1() {
     // We need a storage directory first.
@@ -67,15 +65,16 @@ void tutorial1() {
 
           // We always need an Env. An Env owns a physical on-disk storage file. One
           // Env can store many different databases (ie sorted maps).
-          final Env<ByteBuffer> env = Env.create()
-              // LMDB also needs to know how large our DB might be. Over-estimating is OK.
-              .setMapSize(10_485_760)
-              // LMDB also needs to know how many DBs (Dbi) we want to store in this Env.
-              .setMaxDbs(1)
-              // Now let's open the Env. The same path can be concurrently opened and
-              // used in different processes, but do not open the same path twice in
-              // the same process at the same time.
-              .open(dir);
+          final Env<ByteBuffer> env =
+              Env.create()
+                  // LMDB also needs to know how large our DB might be. Over-estimating is OK.
+                  .setMapSize(10_485_760)
+                  // LMDB also needs to know how many DBs (Dbi) we want to store in this Env.
+                  .setMaxDbs(1)
+                  // Now let's open the Env. The same path can be concurrently opened and
+                  // used in different processes, but do not open the same path twice in
+                  // the same process at the same time.
+                  .open(dir);
 
           // We need a Dbi for each DB. A Dbi roughly equates to a sorted map. The
           // MDB_CREATE flag causes the DB to be created if it doesn't already exist.
@@ -124,9 +123,7 @@ void tutorial1() {
         });
   }
 
-  /**
-   * In this second tutorial we'll learn more about LMDB's ACID Txns.
-   */
+  /** In this second tutorial we'll learn more about LMDB's ACID Txns. */
   @Test
   void tutorial2() {
     FileUtil.useTempDir(
@@ -337,9 +334,7 @@ void tutorial4() {
         });
   }
 
-  /**
-   * In this fifth tutorial we'll explore multiple values sharing a single key.
-   */
+  /** In this fifth tutorial we'll explore multiple values sharing a single key. */
   @Test
   void tutorial5() {
     FileUtil.useTempDir(
@@ -399,7 +394,8 @@ void tutorial6() {
     FileUtil.useTempDir(
         dir -> {
           // Note we need to specify the Verifier's DBI_COUNT for the Env.
-          final Env<ByteBuffer> env = Env.create(PROXY_OPTIMAL)
+          final Env<ByteBuffer> env =
+              Env.create(PROXY_OPTIMAL)
                   .setMapSize(10_485_760)
                   .setMaxDbs(Verifier.DBI_COUNT)
                   .open(dir);
@@ -415,9 +411,7 @@ void tutorial6() {
         });
   }
 
-  /**
-   * In this final tutorial we'll look at using Agrona's DirectBuffer.
-   */
+  /** In this final tutorial we'll look at using Agrona's DirectBuffer. */
   @Test
   void tutorial7() {
     FileUtil.useTempDir(
@@ -425,10 +419,8 @@ void tutorial7() {
           // The critical difference is we pass the PROXY_DB field to Env.create().
           // There's also a PROXY_SAFE if you want to stop ByteBuffer's Unsafe use.
           // Aside from that and a different type argument, it's the same as usual...
-          final Env<DirectBuffer> env = Env.create(PROXY_DB)
-              .setMapSize(10_485_760)
-              .setMaxDbs(1)
-              .open(dir);
+          final Env<DirectBuffer> env =
+              Env.create(PROXY_DB).setMapSize(10_485_760).setMaxDbs(1).open(dir);
 
           final Dbi<DirectBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
 
@@ -485,10 +477,6 @@ void tutorial7() {
   // or reverse ordered keys, using Env.DISABLE_CHECKS_PROP etc), but you now
   // know enough to tackle the JavaDocs with confidence. Have fun!
   private Env<ByteBuffer> createSimpleEnv(final Path path) {
-    return Env.create()
-        .setMapSize(10_485_760)
-        .setMaxDbs(1)
-        .setMaxReaders(1)
-        .open(path);
+    return Env.create().setMapSize(10_485_760).setMaxDbs(1).setMaxReaders(1).open(path);
   }
 }
diff --git a/src/test/java/org/lmdbjava/TxnFlagSetTest.java b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
index 87455cb7..4cf1e879 100644
--- a/src/test/java/org/lmdbjava/TxnFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
@@ -24,8 +24,7 @@ public class TxnFlagSetTest extends AbstractFlagSetTest<TxnFlags, TxnFlagSet> {
 
   @Override
   List<TxnFlags> getAllFlags() {
-    return Arrays.stream(TxnFlags.values())
-        .collect(Collectors.toList());
+    return Arrays.stream(TxnFlags.values()).collect(Collectors.toList());
   }
 
   @Override
diff --git a/src/test/java/org/lmdbjava/TxnTest.java b/src/test/java/org/lmdbjava/TxnTest.java
index ba8e55d3..157ba94d 100644
--- a/src/test/java/org/lmdbjava/TxnTest.java
+++ b/src/test/java/org/lmdbjava/TxnTest.java
@@ -125,10 +125,8 @@ void rangeSearch() {
   @Test
   void readOnlyTxnAllowedInReadOnlyEnv() {
     env.openDbi(DB_1, MDB_CREATE);
-    try (Env<ByteBuffer> roEnv = create()
-        .setMaxReaders(1)
-        .setEnvFlags(MDB_NOSUBDIR, MDB_RDONLY_ENV)
-        .open(file)) {
+    try (Env<ByteBuffer> roEnv =
+        create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR, MDB_RDONLY_ENV).open(file)) {
       assertThat(roEnv.txnRead()).isNotNull();
     }
   }
diff --git a/src/test/java/org/lmdbjava/VerifierTest.java b/src/test/java/org/lmdbjava/VerifierTest.java
index 75812e18..7f6b3dff 100644
--- a/src/test/java/org/lmdbjava/VerifierTest.java
+++ b/src/test/java/org/lmdbjava/VerifierTest.java
@@ -24,21 +24,20 @@
 import java.util.concurrent.TimeUnit;
 import org.junit.jupiter.api.Test;
 
-/**
- * Test {@link Verifier}.
- */
+/** Test {@link Verifier}. */
 public final class VerifierTest {
 
   @Test
   void verification() {
     FileUtil.useTempFile(
         file -> {
-          try (Env<ByteBuffer> env = create()
-              .setMaxReaders(1)
-              .setMaxDbs(Verifier.DBI_COUNT)
-              .setMapSize(10, ByteUnit.MEBIBYTES)
-              .setEnvFlags(MDB_NOSUBDIR)
-              .open(file)) {
+          try (Env<ByteBuffer> env =
+              create()
+                  .setMaxReaders(1)
+                  .setMaxDbs(Verifier.DBI_COUNT)
+                  .setMapSize(10, ByteUnit.MEBIBYTES)
+                  .setEnvFlags(MDB_NOSUBDIR)
+                  .open(file)) {
             final Verifier v = new Verifier(env);
             final int seconds = Integer.getInteger("verificationSeconds", 2);
             assertThat(v.runFor(seconds, TimeUnit.SECONDS)).isGreaterThan(1L);

From cf3a11e0a3a201f3b49f3163ff8ca53fb61d40b8 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 7 Nov 2025 10:13:08 +0000
Subject: [PATCH 272/322] Remove class separators

---
 src/main/java/org/lmdbjava/AbstractFlagSet.java       |  9 +++------
 src/main/java/org/lmdbjava/ByteBufferProxy.java       |  9 +++------
 src/main/java/org/lmdbjava/CopyFlagSet.java           |  6 ++----
 src/main/java/org/lmdbjava/CursorIterable.java        |  6 ++----
 src/main/java/org/lmdbjava/DbiBuilder.java            | 11 +++--------
 src/main/java/org/lmdbjava/DbiFlagSet.java            |  6 ++----
 src/main/java/org/lmdbjava/Env.java                   |  3 +--
 src/main/java/org/lmdbjava/EnvFlagSet.java            |  6 ++----
 src/main/java/org/lmdbjava/PutFlagSet.java            |  6 ++----
 src/main/java/org/lmdbjava/TxnFlagSet.java            |  9 +++------
 .../java/org/lmdbjava/ComparatorIntegerKeyTest.java   |  9 +++------
 .../org/lmdbjava/CursorIterableIntegerDupTest.java    |  6 ++----
 .../org/lmdbjava/CursorIterableIntegerKeyTest.java    |  6 ++----
 src/test/java/org/lmdbjava/CursorIterableTest.java    |  6 ++----
 14 files changed, 32 insertions(+), 66 deletions(-)

diff --git a/src/main/java/org/lmdbjava/AbstractFlagSet.java b/src/main/java/org/lmdbjava/AbstractFlagSet.java
index fbaa4c6f..673dac08 100644
--- a/src/main/java/org/lmdbjava/AbstractFlagSet.java
+++ b/src/main/java/org/lmdbjava/AbstractFlagSet.java
@@ -100,8 +100,7 @@ public String toString() {
     return FlagSet.asString(this);
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   abstract static class AbstractSingleFlagSet<T extends Enum<T> & MaskedFlag>
       implements FlagSet<T> {
 
@@ -182,8 +181,7 @@ private Set<T> initSet() {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   static class AbstractEmptyFlagSet<T extends MaskedFlag> implements FlagSet<T> {
 
     @Override
@@ -237,8 +235,7 @@ public int hashCode() {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   /**
    * A builder for creating a {@link AbstractFlagSet}.
    *
diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
index 52bfc924..7272206a 100644
--- a/src/main/java/org/lmdbjava/ByteBufferProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -86,8 +86,7 @@ public BufferMustBeDirectException() {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   /**
    * Provides {@link ByteBuffer} pooling and address resolution for concrete {@link BufferProxy}
    * implementations.
@@ -246,8 +245,7 @@ protected byte[] getBytes(final ByteBuffer buffer) {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   /**
    * A proxy that uses Java reflection to modify byte buffer fields, and official JNR-FFF methods to
    * manipulate native pointers.
@@ -292,8 +290,7 @@ protected ByteBuffer out(final ByteBuffer buffer, final Pointer ptr) {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   /**
    * A proxy that uses Java's "unsafe" class to directly manipulate byte buffer fields and JNR-FFF
    * allocated memory pointers.
diff --git a/src/main/java/org/lmdbjava/CopyFlagSet.java b/src/main/java/org/lmdbjava/CopyFlagSet.java
index 1aed9878..663a367d 100644
--- a/src/main/java/org/lmdbjava/CopyFlagSet.java
+++ b/src/main/java/org/lmdbjava/CopyFlagSet.java
@@ -45,8 +45,7 @@ static AbstractFlagSet.Builder<CopyFlags, CopyFlagSet> builder() {
         CopyFlags.class, CopyFlagSetImpl::new, copyFlag -> copyFlag, () -> CopyFlagSetImpl.EMPTY);
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   class CopyFlagSetImpl extends AbstractFlagSet<CopyFlags> implements CopyFlagSet {
 
     static final CopyFlagSet EMPTY = new EmptyCopyFlagSet();
@@ -56,8 +55,7 @@ private CopyFlagSetImpl(final EnumSet<CopyFlags> flags) {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   class EmptyCopyFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<CopyFlags>
       implements CopyFlagSet {}
 }
diff --git a/src/main/java/org/lmdbjava/CursorIterable.java b/src/main/java/org/lmdbjava/CursorIterable.java
index 2289f130..f5ec4fc0 100644
--- a/src/main/java/org/lmdbjava/CursorIterable.java
+++ b/src/main/java/org/lmdbjava/CursorIterable.java
@@ -239,8 +239,7 @@ enum State {
     TERMINATED
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   static class JavaRangeComparator<T> implements RangeComparator {
 
     private final Comparator<T> comparator;
@@ -274,8 +273,7 @@ public void close() throws Exception {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   /**
    * Calls down to mdb_cmp to make use of the comparator that LMDB uses for insertion order. Has a
    * very slight overhead as compared to {@link JavaRangeComparator}.
diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
index d5d1af8c..c8dacd08 100644
--- a/src/main/java/org/lmdbjava/DbiBuilder.java
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -82,8 +82,6 @@ public DbiBuilderStage2<T> withoutDbName() {
     return setDbName((byte[]) null);
   }
 
-  // --------------------------------------------------------------------------------
-
   /**
    * Intermediate builder stage for constructing a {@link Dbi}.
    *
@@ -209,8 +207,7 @@ public DbiBuilderStage3<T> withIteratorComparator(
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   /**
    * Final stage builder for constructing a {@link Dbi}.
    *
@@ -394,8 +391,7 @@ private Dbi<T> openDbi(final Txn<T> txn, final DbiBuilder<T> dbiBuilder) {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   private enum ComparatorType {
     /**
      * Default Java comparator for {@link CursorIterable} KeyRange testing, LMDB comparator for
@@ -414,8 +410,7 @@ private enum ComparatorType {
     ;
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   @FunctionalInterface
   public interface ComparatorFactory<T> {
 
diff --git a/src/main/java/org/lmdbjava/DbiFlagSet.java b/src/main/java/org/lmdbjava/DbiFlagSet.java
index 6f2d3c81..0452f068 100644
--- a/src/main/java/org/lmdbjava/DbiFlagSet.java
+++ b/src/main/java/org/lmdbjava/DbiFlagSet.java
@@ -49,8 +49,7 @@ static AbstractFlagSet.Builder<DbiFlags, DbiFlagSet> builder() {
         DbiFlags.class, DbiFlagSetImpl::new, dbiFlag -> dbiFlag, () -> DbiFlagSetImpl.EMPTY);
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   class DbiFlagSetImpl extends AbstractFlagSet<DbiFlags> implements DbiFlagSet {
 
     static final DbiFlagSet EMPTY = new EmptyDbiFlagSet();
@@ -60,8 +59,7 @@ private DbiFlagSetImpl(final EnumSet<DbiFlags> flags) {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   class EmptyDbiFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<DbiFlags>
       implements DbiFlagSet {}
 }
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 54115b33..370fbc8c 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -633,8 +633,7 @@ public AlreadyOpenException() {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   /**
    * Builder for configuring and opening Env.
    *
diff --git a/src/main/java/org/lmdbjava/EnvFlagSet.java b/src/main/java/org/lmdbjava/EnvFlagSet.java
index 771f5e2c..e0c4d21c 100644
--- a/src/main/java/org/lmdbjava/EnvFlagSet.java
+++ b/src/main/java/org/lmdbjava/EnvFlagSet.java
@@ -45,8 +45,7 @@ static AbstractFlagSet.Builder<EnvFlags, EnvFlagSet> builder() {
         EnvFlags.class, EnvFlagSetImpl::new, envFlag -> envFlag, () -> EnvFlagSetImpl.EMPTY);
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   class EnvFlagSetImpl extends AbstractFlagSet<EnvFlags> implements EnvFlagSet {
 
     static final EnvFlagSet EMPTY = new EmptyEnvFlagSet();
@@ -56,8 +55,7 @@ private EnvFlagSetImpl(final EnumSet<EnvFlags> flags) {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   class EmptyEnvFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<EnvFlags>
       implements EnvFlagSet {}
 }
diff --git a/src/main/java/org/lmdbjava/PutFlagSet.java b/src/main/java/org/lmdbjava/PutFlagSet.java
index ee2a9826..ee2855a6 100644
--- a/src/main/java/org/lmdbjava/PutFlagSet.java
+++ b/src/main/java/org/lmdbjava/PutFlagSet.java
@@ -45,8 +45,7 @@ static AbstractFlagSet.Builder<PutFlags, PutFlagSet> builder() {
         PutFlags.class, PutFlagSetImpl::new, putFlag -> putFlag, EmptyPutFlagSet::new);
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   class PutFlagSetImpl extends AbstractFlagSet<PutFlags> implements PutFlagSet {
 
     public static final PutFlagSet EMPTY = new EmptyPutFlagSet();
@@ -56,8 +55,7 @@ private PutFlagSetImpl(final EnumSet<PutFlags> flags) {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   class EmptyPutFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<PutFlags>
       implements PutFlagSet {}
 }
diff --git a/src/main/java/org/lmdbjava/TxnFlagSet.java b/src/main/java/org/lmdbjava/TxnFlagSet.java
index 1fa34d32..c15ebec1 100644
--- a/src/main/java/org/lmdbjava/TxnFlagSet.java
+++ b/src/main/java/org/lmdbjava/TxnFlagSet.java
@@ -45,8 +45,7 @@ static AbstractFlagSet.Builder<TxnFlags, TxnFlagSet> builder() {
         TxnFlags.class, TxnFlagSetImpl::new, SingleTxnFlagSet::new, () -> TxnFlagSetImpl.EMPTY);
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   class TxnFlagSetImpl extends AbstractFlagSet<TxnFlags> implements TxnFlagSet {
 
     static final TxnFlagSet EMPTY = new EmptyTxnFlagSet();
@@ -56,8 +55,7 @@ private TxnFlagSetImpl(final EnumSet<TxnFlags> flags) {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   class SingleTxnFlagSet extends AbstractFlagSet.AbstractSingleFlagSet<TxnFlags>
       implements TxnFlagSet {
 
@@ -66,8 +64,7 @@ class SingleTxnFlagSet extends AbstractFlagSet.AbstractSingleFlagSet<TxnFlags>
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   class EmptyTxnFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<TxnFlags>
       implements TxnFlagSet {}
 }
diff --git a/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java b/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java
index 00c0ce28..e35d7d27 100644
--- a/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java
+++ b/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java
@@ -185,8 +185,7 @@ void testRandomInt(final ComparatorRunner runner) {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   /** Tests {@link ByteBufferProxy}. */
   private static final class ByteBufferRunner implements ComparatorRunner {
 
@@ -260,8 +259,7 @@ private ByteBuffer intToBuffer(final int val, final int bufferCapacity) {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   /** Tests {@link DirectBufferProxy}. */
   private static final class DirectBufferRunner implements ComparatorRunner {
     private static final Comparator<DirectBuffer> COMPARATOR =
@@ -331,8 +329,7 @@ public int compare(int int1, int int2) {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   /** Interface that can test a {@link BufferProxy} <code>compare</code> method. */
   private interface ComparatorRunner {
 
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
index 7a2515b2..da0b86f2 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
@@ -511,8 +511,7 @@ private Dbi<ByteBuffer> getDb() {
     return dbi;
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   private static class DbiFactory {
     private final String name;
     private final Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory;
@@ -528,8 +527,7 @@ public String toString() {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   static class MyArgumentProvider implements ArgumentsProvider {
 
     @Override
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
index c35767c0..509b5bbb 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
@@ -579,8 +579,7 @@ private Dbi<ByteBuffer> getDb() {
     return dbi;
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   private static class DbiFactory {
     private final String name;
     private final Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory;
@@ -596,8 +595,7 @@ public String toString() {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   static class MyArgumentProvider implements ArgumentsProvider {
 
     @Override
diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index 7c1aa227..75358b56 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -500,8 +500,7 @@ private Dbi<ByteBuffer> getDb() {
     return dbi;
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   private static class DbiFactory {
     private final String name;
     private final Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory;
@@ -517,8 +516,7 @@ public String toString() {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
+  
   static class MyArgumentProvider implements ArgumentsProvider {
 
     @Override

From 0c97cf469952ee263b3b1d7b85fcd6f3320ccabc Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 7 Nov 2025 10:14:02 +0000
Subject: [PATCH 273/322] Run format plugin

---
 src/main/java/org/lmdbjava/AbstractFlagSet.java              | 3 ---
 src/main/java/org/lmdbjava/ByteBufferProxy.java              | 3 ---
 src/main/java/org/lmdbjava/CopyFlagSet.java                  | 2 --
 src/main/java/org/lmdbjava/CursorIterable.java               | 2 --
 src/main/java/org/lmdbjava/DbiBuilder.java                   | 3 ---
 src/main/java/org/lmdbjava/DbiFlagSet.java                   | 2 --
 src/main/java/org/lmdbjava/Env.java                          | 1 -
 src/main/java/org/lmdbjava/EnvFlagSet.java                   | 2 --
 src/main/java/org/lmdbjava/PutFlagSet.java                   | 2 --
 src/main/java/org/lmdbjava/TxnFlagSet.java                   | 3 ---
 src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java     | 3 ---
 src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java | 2 --
 src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java | 2 --
 src/test/java/org/lmdbjava/CursorIterableTest.java           | 2 --
 14 files changed, 32 deletions(-)

diff --git a/src/main/java/org/lmdbjava/AbstractFlagSet.java b/src/main/java/org/lmdbjava/AbstractFlagSet.java
index 673dac08..655369e1 100644
--- a/src/main/java/org/lmdbjava/AbstractFlagSet.java
+++ b/src/main/java/org/lmdbjava/AbstractFlagSet.java
@@ -100,7 +100,6 @@ public String toString() {
     return FlagSet.asString(this);
   }
 
-  
   abstract static class AbstractSingleFlagSet<T extends Enum<T> & MaskedFlag>
       implements FlagSet<T> {
 
@@ -181,7 +180,6 @@ private Set<T> initSet() {
     }
   }
 
-  
   static class AbstractEmptyFlagSet<T extends MaskedFlag> implements FlagSet<T> {
 
     @Override
@@ -235,7 +233,6 @@ public int hashCode() {
     }
   }
 
-  
   /**
    * A builder for creating a {@link AbstractFlagSet}.
    *
diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
index 7272206a..25218fe4 100644
--- a/src/main/java/org/lmdbjava/ByteBufferProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -86,7 +86,6 @@ public BufferMustBeDirectException() {
     }
   }
 
-  
   /**
    * Provides {@link ByteBuffer} pooling and address resolution for concrete {@link BufferProxy}
    * implementations.
@@ -245,7 +244,6 @@ protected byte[] getBytes(final ByteBuffer buffer) {
     }
   }
 
-  
   /**
    * A proxy that uses Java reflection to modify byte buffer fields, and official JNR-FFF methods to
    * manipulate native pointers.
@@ -290,7 +288,6 @@ protected ByteBuffer out(final ByteBuffer buffer, final Pointer ptr) {
     }
   }
 
-  
   /**
    * A proxy that uses Java's "unsafe" class to directly manipulate byte buffer fields and JNR-FFF
    * allocated memory pointers.
diff --git a/src/main/java/org/lmdbjava/CopyFlagSet.java b/src/main/java/org/lmdbjava/CopyFlagSet.java
index 663a367d..cea2fce9 100644
--- a/src/main/java/org/lmdbjava/CopyFlagSet.java
+++ b/src/main/java/org/lmdbjava/CopyFlagSet.java
@@ -45,7 +45,6 @@ static AbstractFlagSet.Builder<CopyFlags, CopyFlagSet> builder() {
         CopyFlags.class, CopyFlagSetImpl::new, copyFlag -> copyFlag, () -> CopyFlagSetImpl.EMPTY);
   }
 
-  
   class CopyFlagSetImpl extends AbstractFlagSet<CopyFlags> implements CopyFlagSet {
 
     static final CopyFlagSet EMPTY = new EmptyCopyFlagSet();
@@ -55,7 +54,6 @@ private CopyFlagSetImpl(final EnumSet<CopyFlags> flags) {
     }
   }
 
-  
   class EmptyCopyFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<CopyFlags>
       implements CopyFlagSet {}
 }
diff --git a/src/main/java/org/lmdbjava/CursorIterable.java b/src/main/java/org/lmdbjava/CursorIterable.java
index f5ec4fc0..fe379151 100644
--- a/src/main/java/org/lmdbjava/CursorIterable.java
+++ b/src/main/java/org/lmdbjava/CursorIterable.java
@@ -239,7 +239,6 @@ enum State {
     TERMINATED
   }
 
-  
   static class JavaRangeComparator<T> implements RangeComparator {
 
     private final Comparator<T> comparator;
@@ -273,7 +272,6 @@ public void close() throws Exception {
     }
   }
 
-  
   /**
    * Calls down to mdb_cmp to make use of the comparator that LMDB uses for insertion order. Has a
    * very slight overhead as compared to {@link JavaRangeComparator}.
diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
index c8dacd08..450fb3c7 100644
--- a/src/main/java/org/lmdbjava/DbiBuilder.java
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -207,7 +207,6 @@ public DbiBuilderStage3<T> withIteratorComparator(
     }
   }
 
-  
   /**
    * Final stage builder for constructing a {@link Dbi}.
    *
@@ -391,7 +390,6 @@ private Dbi<T> openDbi(final Txn<T> txn, final DbiBuilder<T> dbiBuilder) {
     }
   }
 
-  
   private enum ComparatorType {
     /**
      * Default Java comparator for {@link CursorIterable} KeyRange testing, LMDB comparator for
@@ -410,7 +408,6 @@ private enum ComparatorType {
     ;
   }
 
-  
   @FunctionalInterface
   public interface ComparatorFactory<T> {
 
diff --git a/src/main/java/org/lmdbjava/DbiFlagSet.java b/src/main/java/org/lmdbjava/DbiFlagSet.java
index 0452f068..d0b13793 100644
--- a/src/main/java/org/lmdbjava/DbiFlagSet.java
+++ b/src/main/java/org/lmdbjava/DbiFlagSet.java
@@ -49,7 +49,6 @@ static AbstractFlagSet.Builder<DbiFlags, DbiFlagSet> builder() {
         DbiFlags.class, DbiFlagSetImpl::new, dbiFlag -> dbiFlag, () -> DbiFlagSetImpl.EMPTY);
   }
 
-  
   class DbiFlagSetImpl extends AbstractFlagSet<DbiFlags> implements DbiFlagSet {
 
     static final DbiFlagSet EMPTY = new EmptyDbiFlagSet();
@@ -59,7 +58,6 @@ private DbiFlagSetImpl(final EnumSet<DbiFlags> flags) {
     }
   }
 
-  
   class EmptyDbiFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<DbiFlags>
       implements DbiFlagSet {}
 }
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 370fbc8c..8fa9e901 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -633,7 +633,6 @@ public AlreadyOpenException() {
     }
   }
 
-  
   /**
    * Builder for configuring and opening Env.
    *
diff --git a/src/main/java/org/lmdbjava/EnvFlagSet.java b/src/main/java/org/lmdbjava/EnvFlagSet.java
index e0c4d21c..4ce5eadc 100644
--- a/src/main/java/org/lmdbjava/EnvFlagSet.java
+++ b/src/main/java/org/lmdbjava/EnvFlagSet.java
@@ -45,7 +45,6 @@ static AbstractFlagSet.Builder<EnvFlags, EnvFlagSet> builder() {
         EnvFlags.class, EnvFlagSetImpl::new, envFlag -> envFlag, () -> EnvFlagSetImpl.EMPTY);
   }
 
-  
   class EnvFlagSetImpl extends AbstractFlagSet<EnvFlags> implements EnvFlagSet {
 
     static final EnvFlagSet EMPTY = new EmptyEnvFlagSet();
@@ -55,7 +54,6 @@ private EnvFlagSetImpl(final EnumSet<EnvFlags> flags) {
     }
   }
 
-  
   class EmptyEnvFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<EnvFlags>
       implements EnvFlagSet {}
 }
diff --git a/src/main/java/org/lmdbjava/PutFlagSet.java b/src/main/java/org/lmdbjava/PutFlagSet.java
index ee2855a6..8c587138 100644
--- a/src/main/java/org/lmdbjava/PutFlagSet.java
+++ b/src/main/java/org/lmdbjava/PutFlagSet.java
@@ -45,7 +45,6 @@ static AbstractFlagSet.Builder<PutFlags, PutFlagSet> builder() {
         PutFlags.class, PutFlagSetImpl::new, putFlag -> putFlag, EmptyPutFlagSet::new);
   }
 
-  
   class PutFlagSetImpl extends AbstractFlagSet<PutFlags> implements PutFlagSet {
 
     public static final PutFlagSet EMPTY = new EmptyPutFlagSet();
@@ -55,7 +54,6 @@ private PutFlagSetImpl(final EnumSet<PutFlags> flags) {
     }
   }
 
-  
   class EmptyPutFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<PutFlags>
       implements PutFlagSet {}
 }
diff --git a/src/main/java/org/lmdbjava/TxnFlagSet.java b/src/main/java/org/lmdbjava/TxnFlagSet.java
index c15ebec1..4bfdf2e3 100644
--- a/src/main/java/org/lmdbjava/TxnFlagSet.java
+++ b/src/main/java/org/lmdbjava/TxnFlagSet.java
@@ -45,7 +45,6 @@ static AbstractFlagSet.Builder<TxnFlags, TxnFlagSet> builder() {
         TxnFlags.class, TxnFlagSetImpl::new, SingleTxnFlagSet::new, () -> TxnFlagSetImpl.EMPTY);
   }
 
-  
   class TxnFlagSetImpl extends AbstractFlagSet<TxnFlags> implements TxnFlagSet {
 
     static final TxnFlagSet EMPTY = new EmptyTxnFlagSet();
@@ -55,7 +54,6 @@ private TxnFlagSetImpl(final EnumSet<TxnFlags> flags) {
     }
   }
 
-  
   class SingleTxnFlagSet extends AbstractFlagSet.AbstractSingleFlagSet<TxnFlags>
       implements TxnFlagSet {
 
@@ -64,7 +62,6 @@ class SingleTxnFlagSet extends AbstractFlagSet.AbstractSingleFlagSet<TxnFlags>
     }
   }
 
-  
   class EmptyTxnFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<TxnFlags>
       implements TxnFlagSet {}
 }
diff --git a/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java b/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java
index e35d7d27..dbe00fa0 100644
--- a/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java
+++ b/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java
@@ -185,7 +185,6 @@ void testRandomInt(final ComparatorRunner runner) {
     }
   }
 
-  
   /** Tests {@link ByteBufferProxy}. */
   private static final class ByteBufferRunner implements ComparatorRunner {
 
@@ -259,7 +258,6 @@ private ByteBuffer intToBuffer(final int val, final int bufferCapacity) {
     }
   }
 
-  
   /** Tests {@link DirectBufferProxy}. */
   private static final class DirectBufferRunner implements ComparatorRunner {
     private static final Comparator<DirectBuffer> COMPARATOR =
@@ -329,7 +327,6 @@ public int compare(int int1, int int2) {
     }
   }
 
-  
   /** Interface that can test a {@link BufferProxy} <code>compare</code> method. */
   private interface ComparatorRunner {
 
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
index da0b86f2..703865d0 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
@@ -511,7 +511,6 @@ private Dbi<ByteBuffer> getDb() {
     return dbi;
   }
 
-  
   private static class DbiFactory {
     private final String name;
     private final Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory;
@@ -527,7 +526,6 @@ public String toString() {
     }
   }
 
-  
   static class MyArgumentProvider implements ArgumentsProvider {
 
     @Override
diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
index 509b5bbb..6baa1907 100644
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableIntegerKeyTest.java
@@ -579,7 +579,6 @@ private Dbi<ByteBuffer> getDb() {
     return dbi;
   }
 
-  
   private static class DbiFactory {
     private final String name;
     private final Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory;
@@ -595,7 +594,6 @@ public String toString() {
     }
   }
 
-  
   static class MyArgumentProvider implements ArgumentsProvider {
 
     @Override
diff --git a/src/test/java/org/lmdbjava/CursorIterableTest.java b/src/test/java/org/lmdbjava/CursorIterableTest.java
index 75358b56..c853a8ab 100644
--- a/src/test/java/org/lmdbjava/CursorIterableTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableTest.java
@@ -500,7 +500,6 @@ private Dbi<ByteBuffer> getDb() {
     return dbi;
   }
 
-  
   private static class DbiFactory {
     private final String name;
     private final Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory;
@@ -516,7 +515,6 @@ public String toString() {
     }
   }
 
-  
   static class MyArgumentProvider implements ArgumentsProvider {
 
     @Override

From 72d4e3f40f9e734986a7f6e97caca341f7fefdae Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 7 Nov 2025 11:24:42 +0000
Subject: [PATCH 274/322] Remove binaries accidentally added, fix test

---
 .../org/lmdbjava/aarch64-linux-gnu.so          | Bin 302728 -> 0 bytes
 .../org/lmdbjava/aarch64-macos-none.so         | Bin 135224 -> 0 bytes
 .../resources/org/lmdbjava/x86_64-linux-gnu.so | Bin 308688 -> 0 bytes
 .../org/lmdbjava/x86_64-macos-none.so          | Bin 100150 -> 0 bytes
 .../org/lmdbjava/x86_64-windows-gnu.dll        | Bin 260096 -> 0 bytes
 src/test/java/org/lmdbjava/EnvTest.java        |   8 ++++++--
 6 files changed, 6 insertions(+), 2 deletions(-)
 delete mode 100755 src/main/resources/org/lmdbjava/aarch64-linux-gnu.so
 delete mode 100755 src/main/resources/org/lmdbjava/aarch64-macos-none.so
 delete mode 100755 src/main/resources/org/lmdbjava/x86_64-linux-gnu.so
 delete mode 100755 src/main/resources/org/lmdbjava/x86_64-macos-none.so
 delete mode 100755 src/main/resources/org/lmdbjava/x86_64-windows-gnu.dll

diff --git a/src/main/resources/org/lmdbjava/aarch64-linux-gnu.so b/src/main/resources/org/lmdbjava/aarch64-linux-gnu.so
deleted file mode 100755
index 7e911756099eb50521ad1767c0974d8313f614f5..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 302728
zcmd443wTu3x%j>IOagl*7eWXmTr|T)of%LOLIO0%1cD}9<YH8`wn-q-$%R`IG{dC?
zux&8d5~VFwTjJ%MlNq7M_Fzj|PYu<cf2fyAwHD8@C7|d3PYAYJQ8Nmi@AvKt443G6
zzUTYC=Nq5R+WXz>@~-#3-nDkzGH>Bc4oy?`&#8W)&Oa#?uwLjtNU*B_o33>Jy;6-)
zgMiALfc5s`veW9!E_JJ(fY0}60pkk2$b7I%Wnm@l61i-+UStknmj~ZA+u3D&JHfSc
ztXaQvtkbAymqivbfmE}--Oj<IwClFobzAN1vdrvG*`+<dW&hn!Azl7Y$FsUoORRQd
zCYpF$TpFG7$}VjhE~TB|`Tx{!6dk2srn7<p;0p$TFC75BVgUGk1Hg9-0RPbd@TUiW
z|8xNOF9v|WG64Lq1HeBX0G<ScFGtVg1Hk(SfX4=aCnBhq>wokB@NomcZyW$VZvgn>
z0pKMAz#{{|e>wpC-~jL!27v!z0C?{J@Ijb?%h7Gz0Ptx8z!whyFBt%S_W<w}1Hh{W
zfNvTAzHI>bp9g?Hgdw>c9rg|Y|H%OGe;)w;hXLTn27o_@k-r>1OEGengI5m#-#!3*
z#{lr}4FKOe0Q_GEfFBwFes}=*p9g@yHvs(90Prgf`;e?Q4M*VlS#DHqG3c4B4kVax
zkMY*@a_K5rE%|_k{3coO6iR{He%0>hI;;QwTh02(R{fb4JfY-5_`e(SmaK9{nBz8C
z^-oy%G`?ciSLSQ=lGV>k7XE9k`fGSE`0V_<S>I#9hgkibcA6dJTky{<`17xs^$RU{
zvenNfYrc&Z{5w|tH!b=swBTzkd=6On@3Y`{Tm1wrd?r}%J=S~|{=*#C?&qH^cyPUi
zk6EbAhWsb1Jyw02o(>D2Q`WrfxMDox82qy0o-x+A5-te5)`HvoI%B~nTqF<W*1Uoi
zzm77V{B~RL*GHN3tT4f<$AUkeWx_XE@SoWH-Dpl|C(rULFys@t8f4aAV!l>4Tk~qP
z=xopT-!1qqab)}s8viPFr`1o}U=u#sf_GEOe4k!qcKm?(TBTWd)>`vTv+7T^`oG&6
z*QVRQS@m<oQSy7ws{e^Kud+-No^RoQqs6cHeq#bktomQI`hURc-yZi(3qHw`b6XyQ
zv=jVy7n}V|u=@FLYuv0c=D0aF+!}YXB@a9rzp+;TldW+lS@3oX-t`}5|IJo|f8tTb
z%^GR;f6#obzQv=!_g$o4KeFJjSnz#jGd0G-r}>cC!2{N~i!J!{7fra$-&GcTp#`_)
z=RYhw-+bAuzuf9)w8i(r-<$A43qFrW!86U0+bj$I2MeBXz^tER$)VrE|Fos=2dw&E
zx9};n@Uitv=q>#xTYPD@>aVu&+-=d>W5N3@c;iKOCdtBIU4;Lu7Js`kOhVpm^>f<7
zC&%KiE&qP2pCU_-Y&^yM3Z7nz4gss5Yps5gE%`iZ!Pi^xNxwDe^SD{4$1MCkmfqR+
z_M2A!uYA?4m}9MrlC6GrSqr*;tAB+7cPQt%|IXhF+<s@@$Cu~Z$ldw6a&KN{jrcz7
zHfC*&wc-Ci{u6(ysgL2A2fBz2kmt0)=ChFM2d&@dty3ieJOAuB_dFEfja<@J)?jHv
zb%$zF$*=EH0rh~=(j0n2RzOD#(w0%DOlet+m5`98FTbnv%5G`y!E37`M^l=v>+W3+
zk5Ug(&;AWk0nZYUayaJFTOdtKa7bs#<5XIDpvkD^gU6b3rm4Uj1D62Md0aPf&F2yu
zwv6j8uCH;GaaD3vbJcOl8g2vEX0EMV{<_)euIS&spa1jQKA)M>Kd%3er4K#+Q(yD&
z8~)I<C@W#;!3Q4<eey`loco4HPu%*$-+%D4%5Qw<^WRq0-7==(*TM4VmS()Q>DTxD
z;Ag+Q{YTl$A3If6ci*>v_RE<^okQ>W;py<v(+5AU_-d28@cH~JPj6T<;h+9%PJ8W7
zzkT#)%aex=j(qm74X>`N_{Z136$(x6&KkGi?T^}CD1GR``$lZId*f%hQ_E{^dA;tD
z%6nRu9e=v{mhV&_9>3~Ozs-E*y@rQE)!oe-KiGb6U4v`f#-AKmGGX6?Kl|k`OQzlO
z#{-4^>CKN+dRH%*FlYSR-+pn`k_qp;Q&m^}_Mg(5Z~XE1j(qx#O8-1IG`Z;;zwUjl
zW`#cW>lKgZWNmo;g`fR$!3`C43!hpt;eS<C{A4?Hk<0$Avu`L@Soc+w>#cjS6VtdF
zxkNVX-<{S?i1KExCD!v4N{QjFvYw?7UR=p_KUX%F@W=k$#*L3_CD(GU0xtRGn}xw!
z;rn8)ITp-Axy`zdFYd7(lC08gl_EPLA0j)eESP4Mc2Q&9Or;#gW&1Pxz4(pQ)<csG
zq`V{UUSw|#SA_-p2IWSsT(0q44P5fOh09^wDJ6;%|69w$SGj@~u!PcO-Dgo2TleEA
zui(0uYl{Vw;?}tPQts2aBu64Y(Up3xGA{YeG>iXN{<X~ZC4Jj|L|%-(<gE#CTJSNH
zm;_~+ER|uwM_FZjF~NGc)+%lPFOOp_Se{i%@fEHaanF;j`|GT-ka8~9a4xYy_HQ~j
zH`osYloAu$zw7NAO7ZdX8_9JSm)N!2x#EB2)`QsMMC;y5d9`&vf-+#;+r=zyuHhQQ
zm1zSh7jb=!%g;50Yc|){x#U-C7REYF?B-JIS*@yAQF>oxU47M>)y92&LtSNE-I_Xe
z?nY{?T(#DCTVdZ+uD-9dKD2tJx~HPNq1?DzW&B%OO7qogN^94wEN_rb?=fG}Nkil6
z(z?pkmG`T)4Z*s~@`}<`>l-Q?rE1MN(7lxn^=m6vR^3yzQmv|7wQ_Cf+^hP^+I!SJ
zD_1wvo&%X3tY3XW7xnR7SmUm!ytit#T3KF8O|{A@c(<ymqPEn0yr-_R(wL+HyYQ(#
zSXZ^W#&|2UVD{(kt18aj)>Sg}xu^0KYwFHFtz5HeRh9W@j=6Si<?4#k+NydJxN?16
z{hGScwd>E-nNnL?Us+zaGHCQ@G@?fQ>#EiDmFEGqrK>9|O=PUjDk^J*hBi`07mceb
z>+Y>oYwxeCYN%AT^_7)1%D6XYBz#>7Z+HhM)-t*JQ2oj^tM4(8Ft}dXP`avoZGF`S
zsI`7Ix9XmTy7jAJHvoBDRbFvlRlP~e^DP=HR@7hANuvk>vUd*5ko0{Ccnzcyd8}B!
zR*G8lDPA;cDnmBf7syt5LqlC@)oKWTDHyV>tq+#hL9@%gtXs2UJ<Pe_-9UX+RD#!<
zkTNj6r@o=Q;huW6es%e(N<p|`&3TCxOyNr<#9CRq1}a_Hzul22oxuyEjyypdgH9H2
z?Z-G_GG3c<V#!VAs#R<5J15i#RJkE_=PR1erFG@2kqJZ5O))g)5%+AWZ5&|bn)RzM
zz{i|STn+RjzQ>9cRmP(slT61JbYqfh)`sq>m~xI3$XkU)={5CLjitzNd2Q9btIt<3
zCDbOJQQxMV4Xj>+!kbbqSe+loK*N5Va>3KN2V|r4p4#$zFBHuSAyQ{O3b?YN@mxC*
z;EQ2Wue|=8rpm}tZEbmjso6H*9#ePaQ3U8*pH-{xSz|mv!ctomR@;X7Tvd5{o(b}F
z9^Hz%HKzR*T(CrIk$R&`c}A<w*%f)N!_1=2=ic*t@f6Wf<k&O;(AHFA)0Wk*#Zoqy
z=E8!n3|7V&c++IVvU*HkB|@}Ts;T;_dn;G1Z3uyZ+?Q8W$eqnhAgjvj&wB}j<M)@N
z*Ss-GyQc95;OcV2_6eEj-!S{7rS~)%<f^S&VO77be$920)y)fw=gcjga@`GiidQQI
zC^4M;?0q|@1Sb4?#JTe8vi9d}_}doz^^4$tx8O%Ff|pwGz<4wI(dfU-=-K?IC=PDN
zx$-7x!5!3(k7?J&!NtGZzs5MY9fQidrZ~7Ae+j%f4sK0Zz-m_<+>TQOz9$YY@reCv
zi-X(ooV;s~gU82)&&I*+_*d#5jDx!cVEsDd;CB2kue##k@iF1+ad3%|?BCHixU6IB
zUw0flKDO<NgG;P#|2~L=OYCL;`s3hsEM~l$U{YQ9D6yaY)8pWqZ6IY@99-5=_Ae_A
zzR(6zdg9<)<KW&n`0a7<$#L-NIQaB9cv&1g5C^|04qg-om$ireTM`G4Uso=VgU7F}
z%HrVhYo=fvT-G}FZ*3f0)^ql+F%E98C*)mI99&|4`_~)?A7KM2cg4ZuW9~h1a9OX}
zzqUBI#Q*lMJq{kfu6Z^N9=}dH7zda2k^Sq8gI{3-DZAp}SH{6#kAusa-2NSngL`Zs
zWp^ChUQfyEo;bLyN$uYUaq#grkg`7xJ|PaSt~xLOSH;2gIQZ3Z@U%F%tbOcXRvcW`
zP4>?d2bX+<{qx4bCI4XmCda`GZ6M|JIQWJ*cpwgLnR4T8Q5@V}+sTV1aqty!{Vb1z
z+c_0^T^0wAUtb2};FIF|SsMqp*TnL=F%E98bp_rO2ajK~Hpjv3HL}#-6$jra0PD9W
z4j#WwZi|DjwJTG$$HAw>!JmzTPmO~gjDy?jX?fil2cH&Kzbg)I`*3;vdK^4HFK{#t
zE^B@J*Bu9s&l~i_!Drf)DL;sVORmBG^~b^O9GCI#>htnH%dQ+({-yJ8zqb9mlrigP
z!|bZ|^NsTc4H~y1d#+^doKC09<yvFp=!92cu0KixD$BmcR<3{H`V*I=`)6@|o9lJ1
z6woT<`Zm`qT;iYRaP8t+R5+(}!Mr=?Eib;cWTt09W$1cY`+L@wSJipSYbA;cc`6%;
z>gtWEw=6EXY4L5h6wdVAvc|KjykTXqYW2My;>NgU_ppqpFlsL;xOrab`6kOM*R5ww
zRarsz_f~pVuW9g{uRC|~vSqg|DVayt3nk59*Sf#F-gAH58b)adt*x}Wy`^~WOwVm=
zLABDe<{r<gN&{v3yr;aXmX>SkJcQg;G+RY9>Is%t@TQ@>)?=nYWYV|KTXt*l;#*1=
z72mq3pk!{*Oiv*-R+QIQUeMG^qj*+T)f>|_5GcOo_JW1QV0sgyd8+D-sg$qwETm)4
zJ;01wiwc&M-gMi-g)=?#;&8E+*`C@eQU@LgOeAemt8mV(m#r_0?8{VNHm{(NIb6Pp
zFpfp|Wtx>Nw40O|`I>7<o<NxThBbA<6j=gz?pa@3>$%p`uts>i8UZ+uf4#?8tq286
zmfvCxUcy?lzI>&mhM;x*`Gyr$bqyhd+x604Ts7%?Mb*6qq2}JU?AFE0tiFm@H&oUU
z=$ovfmAN(s!Sa<gmzj?tV<wp|X=;d>Aheo^tf{N?)UPdHd7e4T=G|I+mk8WB&a=>v
z<x9Qi-nz>BJu50hEL!7d4>`;viOj$Fmbr@;Eh#7|p0jY?OwZ!Am32mP%u`Mq<e+M`
zu_$Y(T2Wg$NhDHaLzbVOl|fmWn@pcmP*}R`)`g2vzT(yQu_CTOCRlBXSes1rNFEHy
zMAGVO*EARulU9&_rYD~AtH^A4j0DvrgA3&hR8?DHjE#&|ncbgjj|j{3(WBM%>({O&
z3x(py@=t~qjRs#yb{Lv%bYiMu;cZK9DqcRX(5QQ^x57EaU=tJ)8;L&p0t6nbD?nV7
z*jUF_TyIU@vwn4DBUKr+Hl%J{zj9?|eLZr=q#M@Pt)A(btVA+v)Kxc3uJBy7q0w`#
zTTQtx_qwS$*D0G)hBkXvuBoUrUro7Ad119k;(e7C`RaXc<>5!#OA3#fr8I9FS65ZI
zjV5uVmImhry=udHw=yVj9SH|@y`W^=8LB?{x*69^y<w)uJAZv`$aBNwNuDW_r%W|M
z6K%BfD`nW%7EJW1F`C-Rea;n{YNK32d4O^cWf$c^%6BL~p!|Tck%Ks6SdcwVIhnF~
zoTfHWCSRqg=PA>!79+3JJ6=uQP1!@amhv>^1C+@=P3@svNZCm_;d)JZS+FHc)>H-M
zvy_dL@7<`WmngdnHI>Z5t*}T_C6trq182dukTQXV*scYdnogOuL{pDbKFtR5E0l6x
zr=Rlq+cj0h!Ype!cv9}VQ&Z1UzRCXY2Lk_^rY5iuTUZKylzN$_4pKIhYpRFx%t}qk
z9<jHI_LLRXn%YOXr-t^FJ*za8&jM`cYUW8<v<~`FzPDXdXDFM$t*Js5AUm5iwVbkt
zvX*kpPUuCM@EuK^rhMRG`eEVG@I6g6QPzGRJSab)l-<v+A5f2S%pOhYEJVDNV<;z6
zPNv*PSxA}oDDCC>F-<kF0Lf`%9Lj@~2`oI)p3qbl<=vE%q<l(KLCQADO_c9Z?xOTQ
zt*NIeYbl#pn4G5Uq4fL{^P<eap-*RFk`sn*l)Lspcgp2IfnO|4UZM<8o~F!TLDKfD
zrj}4nC(77E*-p8S^68f}b(Dq4Y06WSIlqPf$XOZXF8F<v@_EXgocHLVT=>7hAO5eU
zoJ6^cGC=t(WeMfozthxi%6BM_Qs%!3J}l%Xy#{?KKX{$~DVvTkKg!8(Am5amC|`$e
z&6Mv^mc6AZ4-31DqsS#?7G)#l>y-N_k5YEZ`?odqCS`!Khw^U9Gn7HfH0a()Ie~Hy
z<#gc#<wDAY|I}0&Wdr5wl#~7oenamZ%2y~Kc!ze-`2gi~%7uSHt|-%vAwSTyld_HS
zU^n<vK7JhefS#vMP#-!L^}sjEPRf0h3BB-vh2B2ONtF6Y=tjAOGDulQxrwr!@@dMf
zKJcR4L&<S?Rd@<Lplo^{xuQHn*-UxhZ<=bS%=!R637qnEN<`ZDX&aU)ZPS(7=;Ukz
z2CC{nCpcK|rJmd`&q7b*U;*xT0;4PAC-q9Wc3)I42&@a3hf;o0Zxh#>z@`g;pO<SF
zS3j_30aT=>6((Pi_G8D765Ni3$=PXzsp>C(F2r0I?VqPC843NRE<eHRb*>6vr-)Hi
zVQQ0hck&fwk2rQGd~eYA^&hzRB>yn=(X_|XAJ6#lh#zISogZk)+0;o@Z@l@(xBhhW
z?f?9*cgz9uX^zQN3E0yIh=0}c)Fma!S1h@>s~@NTD8m_WBxf%vIp4`&{;UEtxtsPy
z+2}JRxRfpb0#qEYBxjc`Ki`Gmv7Ba@1EqVAHNl}Ub?p~Vr<v)jy<|3y_b!DB{m;;M
zBYpw%YWxJ2#yD#)f=vJx1ST>eKcV+@V70&k0$7sjDN4S=^GL#v2mMH2lAP@+Vj_R}
za|N%;sP_Q%jPrd(UrYnHqYUZOhv^ymaD9ZHsb}dU^-=n0eT;skennA|+u01EFQ!sq
zlE_aN<D9+*8_Yd)x|COG!YRkI7cdGw$($3Al|5ecPulVmIm!Yy*=PC``s;LjA>kcu
z$=Ou7kbQ=n7SdM*eP!igZ}7WcCI@b3K0Lg1j?&LQ`gtWEJ4gBD{nQRftJAdanT;JZ
z<??k6!4AX=_K#D4l;%7L9=x*W1g%6rCnrGb=drQegM-O;)Jr%o>@!&Z=3o9Sb?>Hb
z#=m0^FIV^R^L53p$oas>soQDRoxCvlipd5_`j6c|N*4M~UTC0V@$4Y=C*hkWNPT|7
z$5(*m1M>)gpTN3-6~)0sujQ;;2{7X<p{bV_>a`&&?zI>2!LmDoYYu$u#5Oi@4-GEH
z6)IeaYX$Yo0_X9XOtVH{XXr!p<I+Cd&TgoGt`{UJhidz1<9(5MhI`rsmRyEyj;`eF
zz>@P!ld;~TT{rDsx@fG&4cfY$Ip@YQji2x?i<oaMzI>N87X0uCKMX!YnSjBKzx-M7
zDx~h4)FpJV@iKXb$rbLooehj&V`UO@0#!HBZebUGR>oKuZ$oO&*$~11Y3c=#*Fv-Z
zbM&_GcNE&BvTS!5ZI04r2{bp(oh}@}ZkkTOvFGwu$FeySoEKS7V*(-v`NX{qAhpxf
zN5ShHjoi*o^v~p=G!UBBQvdav;W_u`bjPG<(YXopO6akNx(P+Z8Ya&MuxIX)i|kop
zk{fEo`63xxXxKx4weyMf2jGz*1m{_#q|F!|KTh1<C~cM-@^%4V4O11@Ms#ZlZH_L4
zS6_^`^Ar+s5t_!B5=*{w%Q;?)j9)nBm<vQn-OZRU(dN`*Y_*KJZ~z};@w(y*c<mJT
zd4cKu%b$e~6Npbcml8K|Z|U6yI5~F5OScs#(WYn_F`!9r%T7LSaNAkJIEJA_VCk}m
ztC{)_uqJ9Y>2{%RCyPOLJ9eHQ=1;;`w{vG4F$|C@q^~yx-`j}Y(0lOx!nnijT#|6n
zqzx?+`5r^O{q$X|cP^NNX#<=S>^WfUsT<&0Nd0G7ujQEaFF)>iK3qiU!X%-?F8XLg
zNSBy&_>%a|(L6x-X2_DP7oPq)aWefvhjVsALP5i;JYZ|+AK#Km1gMrqaG6mGug&ql
za1KN|m&`%vUqT-{%US2LKKU~GJ1f#J>cx}^=||Sd-Syya+Ltek{hSpSn<=xOH2Qgu
ze)8|P;!vIiCTs3VD7NU2{KV!YCu7fm8E4nc80wO+!0l*{S6ovJB~&=C%mOp~)!p>B
zeB-$|;}ZH4&(YBGa&SNbCYkqc+Uc9|uL(SSiTpZ?E+f7)3vj(dKY^|I%P-}n^Weq7
zlE{PjHV?UlQ`^Z=aIeZP^0}s7;;d{VXzJhusxGJ9z6V%4NIN3Ka|@Z}_A<ugLlgD%
zZxSC%J$}NQ-N0S}R$@R*SUa%fZ(SIxKMyPc80OFTN!!<f_0x8f1(VqLJz!<jt1$KQ
z5?}JT5$_lt;5-)*pM|vbkUNpw$m7zs;iCDwAGa)1;6kfv#On)_9H-+bLw|zbTKapM
zxCho4Kf&(-V2=YkYVzqq+jnk^Qx|rIumot^Nn82W<G^{Fvm`#0mF1p9{%%M2g?eU+
zn?dgc@;~h_p&tfD#JH4M!1e$;C@^&4Vn5^#BJx(8C0)tf7Sd)6d60O1lmSZvmM{JA
zlX?xnrURQ~KulOOuqD98#K9g1wj7vED{1?zRZs5aC*@1P7E;e60Db~HYPIzUfS<rl
z0jr>%@Kt_BAN=z;u(c-0(7y~|li|4$J2iZn|Bxm01!fRVoAkJwe%7{FIza!Exz+-c
z@hrN=*#tA1lVHrU2!;Wpx_X*__R-IB3rB$+<ev|K*>e#&dIgwwCxReyRB^Ga?y+Q*
z@cf**9yO#u`qRnToqCA4gM0Z2Y>edbzH=dLGO&dg!3u$Gx(K!$SS|CkWkGbg7MSGA
zmYA~IrjZaBKv;W{vw3ZY@o)d9;7P1^5zNB#CHh@X{5_dx`N<rP0&4)a#~kYmeFrfB
zJiIh-ApLppVedhgW~1Xv^+48q=k>tkaS3fC-}jQ)<~)zh)c|fYer03Qx|ueTW3_cc
z_$mHV=zrRrL$@=2oobmL%qeh_P=?^qu88X>ZQuMZI$_$BFNq_ZFF^q6oF}-Q2NGIN
zAWzudim&`4KWrtG-o%kyKuJTw@W1p^OFz%=CSPyPM`DZ1vfsJuB9+1!2`?m{SxBC_
zmV12BdAeHh3?}KkGo^}`tD82PXk*C6MeB8FXD`={_sJR19GQ7m`j5AHCf^*?w^(gX
zN_Z5YO%}ZFH`{byHkTlaQr_6qwSDU*+P+EK_sq5z+I>S?9nZ%pt28rmg$HPNl>GZX
zlaAugE{Ri|o1o!&Z)UU=UVcE^B69S5@QGg*Tc8(-1KGCe<bL-&eWBf42u$+t|D!w)
z%(~QSLQl}zO+RhWWw|By1KJ6vhe>u{XeVS^Tu15S0D@NXKUo7fnl6is$d89ycIT`A
zvwY7&>L$Nt*~`MzHqBTN8%rLRT|6QH!iY5bZKUo?>`5%)UVam}b^=ooE2n77s?i)`
z8It;!Kf^vFzup5*?cCcx>GKuZ%Xg4>TR`cv8(1eWu?g@yE>B4k!|GGo>g<VhQ%~;Y
zCvC?7d*@5q3XKY>cZPavrJ+5Bohyk`GO=xIsT=tHx!lnO`7<N`X=^0$&1CAgQGXZp
z_nCd4*Lh1P&o5z2ofJFsCT;ZB&#l`oiT8eJMnukp3smH7qXU_LMi#c1eV0u#CciOU
zUSPGr4w^E#%Tf5F1m`|2RayKjk~ZwgR2VHx9^VbDMD}ScnDA~bunBLn#;{;^5dhTV
z`tCAa=}Fm()H*MsTNR7F?mIHP)q7|AL64@lbUI7lDg&mxzE-&psQ$dPX)42jy=TJo
zK~2kC-axe5>4<nIv_E#->5L?}0?{Uw{no|r5>f(D9rEf&#<lKMdS4mnN`0y8Qi15~
zvFbyX(z|?1$G1+<njf{_=?Q_Tk4x7A9X_sX%~jL$gT15F*u8fNUM^1{?C1SNmpbCo
zl3M0-^*LRU+W#(XT*TF+rPOR?tl660*XvA*6vbjC(oRnfbhNAHyhD6y*RGm!yPes7
zfwyT*%cMNJ@rCeNr)up|d-9N?j-cac-q9SjyG>Km2!k{Du4kRDC8ulC1JT~hy`yF?
zEvnYX1fn}s)3R}idq;IU^~megXP!BKpp-t&Zama3eaka+oOUJ_%j`zQ^i9l-cEzf#
zZnoyFE&yNLUq+|H#3kl*967tu5k9lV8UF0vgm8apV)&Cg28B;A9vnWqUA1PU1)^E>
z@sU$SemE`=U9L6f&2Xv%9;c)ASAz3sHO-qHh`O}E!#h%4Ez_<FMA;V0_+g?t&^$9R
zqdC=^*Ysqd;{bK}7Cv%&D(1``=-A;m=`Hl@as;B;iR!29dzSoZ@ORTWN1M^(%!s(c
zFNJ*tf#`g$*_ykr_nN(<hTmD$-#!OgRKvGK)mk<s5DliPXjklo^s1{B^;C4n)q#$!
zw*cR!I-2hZM8|#njW@OoQqe6lRY&k2j&L@0wv1EJN2aLg!{Eho^-IUwLf<mZ6VNhv
zT_D=F?Kk;u=aBR#wjIjXG_}8N+kfOgvF*3{Pi}iL|EX;+0dwqkq-guwZv@wIfeyiS
zc8Xe8<sae;x>a<pLzNWK*N)_-W%Hd)%Ub3KqP6t9YGxo>6Y6Q)qN#POXQ=e=RQVeF
zo_cW9GgaQ{(nrk(_<2aRW@|}(EB_HI2~yuhdsm{G;X=NQXH7x(Kt~UH)eNnw+|XBZ
z^__s$nfiCr38gabaD6wu+c_-qHMVc%`BP-H+nMP<z4&JMe-m;r4|ym=F6M^MZk!WF
zP7GbW@9IEw#NT7jJqrJBhIY*-0v(Sb7azmhphHc&eM{hxeCCC*SaSjyKg4~vQ|)gW
z6zDkPRH08kQsG&&>qK_PQ)VK&v2?YriMeE+iB0oTzxjmfC>yU@<$aS2`I;N(=yIr>
zUU2k}ceXA_EIjxO?R|-AsOaog^sd*b`yU(?=s-?t$TyUnbh`ZLWlipAcZ*v!J$%MF
zBC_|p$p?Rzn%w_K=#QO}^iIYO+PIu5=Zte?#6`VND5c(Es~$8T>YZ!i(|o1sc+{yn
zhRVF5Z<p3?$o6siP7_?g=~Jij@1@Ru^sfheNndBkToQQy3uyl@z;!Jt-G|N`b||hu
z)X%-hcRBNr=lhT~Kl)UKygiueZn+Jeia-}lbNi{2*$lm*E&R%eAZM+gU#E7X>(j2}
zoxsZ(Pu_hD-1AAyz-b5XT-YVAHqISX&AI1o(XZgM2EQHf-HF~O7`CZM4N3QDDe2QR
z-B0S}fEOE3h0Q3|+UkaD!~HKfT-9aJFk2f^*9AO`-g>m=QQMer5IZ(3ClLJv8w@=n
z_X6v8Y7u#M4QpEF9o)2RB&E=1<j|&N_B$^&zt=g^KWajtL)v+mbI~>W=#0&QM~*X}
z7p7v{T<XBdo5bFaY)MiXEn=63Z&Dp@Phz-Q8}+h#x{79|sVHX_4!Gz~CA2Lo8Xtbl
zH5EM=Hz@ow=>z(f4Q5*$n<39V^ihUf2S=!A`yg!Qc5IWP4*IADch1tT4;c1B?1_HO
zVqe*yrdh)VtEf*KGbOk|b-1>0CF(7W@N?Yzo8H(=pF#Ar+nE)C7CFd4#Dy)dMpu1R
z!Rfxx73sy6K37psbkhm%qt48TcgTW%kF#@D*|z5VX6T-QUxJtZX8QCvRkRJ;+gx|W
zt>xQ_`t`ADr~}%R^G?P(jy`({JKNAh!s3i3>;Y%QGXx*e^^KGQ6Z_mF_7VFh@Gbv{
z{h$q=1-~I<W&7V?9y&Y@enWMLKaw`=H6m}rBBIYr7(;OC$%QTsy{`?sV!vNujFo{M
zDMX&;B3E;euL5kyZw>!+cH=LxDH<>b@0`?0K;{w+nH$v@=qMem*6}wlN=70-A0acN
zZ)jRJ20kW$2k$=ojCrOcs*>e{)sdWyjr|R=*nwulzNruOHBHObJDVS6izFimZmv*c
z{|@Go5t`orCVG|ekJy23=kUl4;0TQlh)g-?U;I)UFtO`Z@aPBhr;i`=7=K{_9%r>Y
zf*$U;Qbn7Qk2}uB4s?zi)Os9VIc{uP=Ahk2ynhe<5;}=36&jviJde2*GRL{hbq;eD
z8vKVrgV>82K34<g;GL5?3Dix54uisH=c?A>&>;)IE3$pssrg?>RqI-?Y3+lCw+Mbw
z<}d;|%S%*8gwKMvYXLZGBU*fkBU|)>uQlr0&?(;I*^M)x(_6n$M>zA<nw_FPEXMEj
zREMS)#WHhC{&7v7ezVz5ZT(t*8}!NEJS*%PUmVt5BaOb?he{95rk`T$pzBcf!IM+e
z?mp&vKzVZY@glp!Yv#cJ;p6eG$WL=ZbDnpQ%8SA$k!AL)qHhlJ<ZVFCg|{{Eb|buD
zIb-p2Ok~T({Qmv$^lornzj0IlAC-D8${3$O<8Ey0tBm;^xP8jJpSvp%z8#+9tC05*
z2LGPmeK$N4{13q!;mhN|KBSKzdR>GbiEVe`_w}y?X0$7B?p{aHy6xaC@3UR1!|?Cm
zuWM?`mT^OTIl4FR^x~V~%RKl~2%qM{uQ~9rAPoNuUnqU`II{BA)5p&pfsXs|QTL|@
zqBGGEk-?r7&=xz=y+TFr8mxwvI!DxiOG*2(nJp@jcNu|D&p$GAC0-={F?`^|;QcXp
z^LOc@!C35B^`kjwgUD{#jq0q}1J`DwZqyeVo$lI<U)t7{?{PNGDjN}qew(&p$F@=?
zGk)2Vs`XpkSMd&BMYE?8A8k=#*S+*jY^d-ZU+4X4<h5*EAbLOd-Gc+s^^`gN*Aur6
zi+m9c?wz7C0@4q%DzT?=pKRWjN$lBQFr!H6dGf9tn#^Hd-ONExFnMxz<FCUXC8?;y
z!XoPu*9tx|?ng<1=-G|GX)j2??<KU=O{J~$Lvr`P7uk^5_CZIaFU1(xr31InAGqX*
zeKK?f9*@PINT2P)oAVl>Ewry|f-idn=Pe=w*;90E`T=~J;4;I&DZ~FXG_~XAEVnvP
z4qeq#s#V^rv$1KygR8j@B8ydqEgcpa%e-~wC_dt5VlD9t3V%|L&g%FK2YUSB4JKT4
zTi>Yg(SaGRuLPoA;y5Fo<6ch;%<vN9Nqh8o-BaKz@uSoezcLZOGM}qPyE2`1ir;^c
ze|eGk>NGkj@murlFNM3(kR^P}jx?1c@sS(d_#HA_ovLycpz90i`&zCoF12nV<zI=X
zc7E@{Q4&{)-#+O~^(WnVz36T03tDntXR<2!SLX8j>NWizM7O;0H{Pe-xw=2wk=pmy
zM76XT|5gSLuhI8M@Uj6tX(o0T{{eqW-Xw<jCy@{6eH?i_gO3s2w0Wg#)W<Fa|6VX7
zJMqf8&cW!eMT>W_jXFH-#&(Ji90$Jd;&buqQI0GbG&gAGR3*3ZZUiy6%t6{eH%PT&
zA6s7lk0-H>!UJE``su~7!MQ<jtO7@U5wOtugF2VQl;xwSH*Q{7#v|TpolBo$d&hE#
zz3YIVp0lx>mDYSZ5|EEmv1v_r1)@LZo#^G>yHs>9_x60RAH@C1*ffdTWd2K}p7A^^
zq79}!_Zl>k`fKsm;$x8Y)-Uoi!YkpW_@o-jEyT)Q&^r0fn*N=!!Flt6CEw}q7hBuw
zbo<3V2C)OgydoRX!|2)!nH%kqy(8^nlX#C$87l8*Ya{!ff~I;X)L%q@nP&^$5dSK^
zaTEBrqg$V$ciGygzPa$eJ$+P**)Fs1(Aijt*udMV7pC59>hzw8l@!r;+g&~RZ5w`>
z{~0m8#NYONSzrGJTy<w4`b*k~jcg_!>T!<pA4Yb?SLoswwNXj!)xmxZ*}RMX^#rvJ
ze_!&bv4$AscW>VGhO8ZaS6$stxpX4W&s5j+m$IhX&KM_Ib2IL`PaW<B-O$UYxffLZ
zBQ{N9kl?mJ$6?~eJWXHlHe-gM(dW)gzY%i`R!f_R-Nfg%-Sw;d&%r;$+Txw`ku4Ey
zelvI%LpO={o<x7~2}=W7=PY?A^*8ctzaKAnI7daKZUMBCv3Z7;uD(OisXg7@BJG8S
ziOlghbm;*P;gR?N{;0`r!L=NI>DyJuaqMn0H0z-h8B69pYc_uqwlUu3i68iQGI1hx
zhfqiS^vB4W<P4<TO8=*w!~L!oRV!<hXb<_2;;pJR5{o@oHOjC>9Z6pabd=r1JkbS1
zrZjhw{uR}6jDAIa-!{q&{}OO6!^ZybAF<4{8-Ep!Vka+Nhm0T=IyOkHLyk)_&6v<H
zI05_c6YN=R!}NasCR_>UgpNcvH1@x3#SY+zKgo#vnz1^F3qEFDH{;eoxP;i@--yYZ
z9G$aR!$lv&X181!h=wJ8a5T+oCzgv4=RHHb=c1iAMMeJ#o~B%z@!~h>vyJ-L`~zF9
zc%uoJ#DEg_M)6&C>}$upJx+%|dlSBQ-nbV3B<wZ0tx2p293Iu-LuR#PWSQJp_AW<g
zzUFGF;>zBX5OzQ92<u~1w0LM>Mz2cC%hnZfUSLL-L(j!dMCPEMldnK7J%d`Sx(Bs7
zc^{<B4%PXGVB6r<EoVlDgHJodt}Nt$9MYBqExdv;{p8GiL*dt%G2yCHW}nSxhZw#(
z=1e3$O(otLLfn%^{4<m|D4qCp7&#$lD|R&^ey|JKe}c<JU-|U4l6;oPh}etU(unuK
z#XX$-jVlnUR-U|Wcr9xWA2Ccd?dKagDR*@zIyReiWIOS*y^dsyGsCCAQPYpiK0ElQ
zbI}(UeJuc%%!zwHeU@rh)}5T)wCq9c!AG~SelDg?6JwlSd@J}a1Mj8azl3=#CT_ch
z97duMx4q!JqW}2#gz$-M6@Ae$InPJGv&lboV<SFtI{hy=$M9KtbKVK!yr-So5s6FQ
z1-CkEG;0O_yUt<$j}kn&J=d@fXYGDpqMFv7-8t(maw-AUH0!J2?wW_4_<V5gC(y%d
zJ?9SkZn`g&ot}M_?i&xRoAys^S4U)=t6i)^d6xcV{ics3_c`8tuaoyw+U&Qov14qN
zmPoyyGnVU{fsiZF)#7iR6B1kQZ*_#kui1Esp2)r6C3p(nVeXGPTr~k`o;yfQ6FjR_
zR<18JCfzkpb-b%J<{_&Qp~H)6Pi_(P?nU4A&92AVomcj^gYR)?VfX|z;f#-gv-Deb
zIyTM6{5CeG8U2rimhUnzp<MwoDn5B=5`OWc*tA}7>LG6NZ-s|j)w=Q26?t5MT+|SI
zEg-ICyDLN5PNhxLhp}n54^}xRuPF?F$~-2*uUhy&)~GYW{{VU?e$M|*6`GXdZt*9&
zTPAK*q2{Ypv=o|1{bX#_r_am{uSyAoYKN;RXE298gbdcEsL;eK=ntJ@%XvyIF_+!{
zLt2Xag#xv1E3`@(9tiE%Mo&o@u0mdDrc>7oy(T%*au<mm#9n^qSfFD+I=p|Z#6+ov
zJnkXZJGni1N^CT1N5<2KsgO?T9-=zhon!h>GKW}<wJ>s0#3uvx94EnB!NZ%9+>&xt
zAo>%=|BmwJNj<5bOuHcQ+Z@I&CFfnx6D#p0Cbtye4}8c2{2JX3E~-GauBYy`^m85W
z_tDp@yniS$1v~?xA8IKr*E$0ox#Lyqe(<?=NFem8gLm7<^w(f>o^hw;KFS<^*>_{O
zg|QYmRdixfAhaMcEpLlcTi52oKO(CU=iU8J7`l=f@xjYda_%R|@y{nG@6qOeX55p1
zFV=QE>Oq!0@bl+`H-+yYhLW}134Hg@(aY<uSG$YcP0N0<{fd5(6W!5PSM-!R*kkeC
z4GzNlE{B_Su4-L4#FO``Bk=Hi@@03>Za(u7zAn;IBKI@ze%7Te4n6PS_PhH9U;I~z
zo*4*<UT$<=IYlRj!=6#7$QcOf<R^;;Qx2wNj>PSuBIuzHf#>L87V<<4pJB8eoIRzG
zds|laC42Iafe!szH8cYq4>GpS+C});jGYs?-Qv`%56x92LcdyP()^u&8j{DlKJNsw
z^9=MWRY`pXS*qk$vzzjKLkni~&Q8k}{`$b7RJr=fGgXQ3SK^%a$nBkkJ|)OW$y{}y
zXl!DuE7Z`~J4a31F-R?)JxkRUqYq61#zXfe%?do69I9=s4X9~8VxAi0->x&3SVMBF
zXPHj~I-Lfe6HjTaj|>ZRy!(jguq$#qc*uJDfAgni)gNQinr|f5&VxU$Hy+JPZj$`=
z(3nH7nFxJ-vaSWU;%T0|-h0KqfD>!wVl69IAsf>7*c5WWe~3+!KBR8!Ui={K!c*}R
zJio<zp;_k;m9vxh;Eq&y%DQ4c`f~^TI*Dx*`Ifb-*roTe75&6ZMcFDOdL{aik{t-8
zj)s53M0ZmcWRJbJ#`i(2BxC)Rx3)v?OynS?Ag5(N?XMHLM|KPyw)OW~RU*9pbi>H>
zo%pX<z3PbdsgUH2MTb9ijGofNb2ajq#2BU8=sGvK_&)0C+JmFy9c%bqv75=~!UJ{N
zp;;&Yrb2GkDo@T;_!XD2KJ4E9?R;JEEKo~1FL!It0u}ASc1FhE82$ho+jKZK?U&Bd
z{vGgRBXTFW&nK4rEK@~uh(k{<R#B0&QfF3QCvj4*W6YFdXygK?V(67b-wQ@FF7%kM
zWhBjqM!#@+^ISX!#`{|wn(JlF>1tVwObH&MlbWTMf|Db(<>4ahos6T;z=vTM%iy)-
zHv2XN8*AvdZ-ciHIcSyfYG_x(Tx6d@a+^9d3jzyReak!@*eE{JM2-u?qKm)4w@iml
zZy_%t1F{bK9Q!Zt4L^#kPaUhZuAZBnz7To*ZE;$9&4ytADs1B-&71eWWrMNXEjzId
zwjJKN^`S?1rl{7P(Jc?Jx&qur213thNelLlo!IAM4#C0M=~Z93GW`U0$VZ>qL)AJb
zYhthV%~9g(Tw3asV-B^By~9z*kW0ZQpsSqsnNtpWCwx5NbVs&Ahj;1YJ!rBi9lniG
zhOhG?^Zv2ehH2<asJdTdw}?FRMCNlXzNB_TP5*bmS7L0Pc?DU2{SA3uq|$PSV0U7~
z`~hhA0sis^u58E98d=YOkdoArMy#LhNbW1(`9pA-yrHHM`sF-Kne9lgS&8pT8>EI#
z-Y~K8Z}c^UnDs+!%aJpKb6cUq4Rh4e8@{34I(yvY8XxP5v>O8tzaCoKxJyfG8S3W!
zpzQS7?9UW@9xEA|8VIF1hPI@QQ>`CdrJ{et?;gaCd*N9RcGhe0XCip?C6R;IcP*=i
zKfw_4fgaRUPHg?;8r4xm-s6SqZwx14A6u}EY@!a;@kKSxB=;6gTXzR~?IF%FWgs(>
zK1}WIMIN>|N7w0&UCZ2R*E04YM}3kRh<=`}I_@KHBldX&ICVI`)<1(aj)&(bUQ|b(
zM5f+#X8GT|R_zW9G5I0!A8nrNVSfB=+q`)GjDkNK*c-@YE;;m3zu~_A|N3mp8^JlM
zwP&y*_GGUNyCm!HKIaI3G0)xD9myr1VDG|f;d&SPITJpXI$eEj@UCckASCflw&t#p
zwO!G$f*C#k7@S))WJHUOPtMkc^_9cJBIoE9H~zVYHH2QZv9XkV1M3Wl`8tB+nD9$c
zFFZ_whkfv{W|XOGrHKn_R=~f$!Nl};RyS7T9~WSkY7(>4w;<13;okycAKAm6k9~7P
zt3ScN&$9y^LMx%uapo1=qTM>|O~%%Sq&r!^ehaz@?Z2w&xkBTU$bdd}Q0qzhXYIM)
z;p&_<XY027z}BYxf~{NgrH;f|{a-Eg>EVKoByHG&XOKt3PqIeXiGASwT=eI_h_|Or
zME+}tr6v+fef7z`xt=Fu)A~lU2Z}%0LT<T_y}CK%mimaFPF)uW*J#NtedOis_~>_M
zB~P5~7u#2GG*<Fge1+iKMVy<h^qL^0(wgM2&}Rr-cr7_pA91GSPd`3GeS8%0|GHOM
zM~Z)v{V4H$<T3n7_`7cSC_aiDV&wQ-t@ZwIWIp!Et%+fsx(ePEL!)|UTKZSDraXyL
zM2GbcH$RN+Y(3%7Uv6^fEt*qr`E(Ndo%jti$CHJ;WJdlD%nfc~{I1AUFLQexoZ5Ik
zJ}3~CoTc>5K0u_GzMGN5ar8gVsX87J8q&s_$U25LV-rO#^~j&;Q{cY_*2KEydCE@c
z@JmYZ^Ev3N(Brf-$uBvg`NRg;rAFe<oa3xtWsUx<PX6Fq@EW@w{FVxpeNS>z+5Rwn
z2rYcT<=I7y@iee6&dClwqEDC?mb|R&Ys6v+;n?*m+WXYtu+AEI<bO4Fh;QxAQ_<K|
zXDGJC74ErNMSaL`jGXn3gtT1ox3bUeX1_-E@Abr{Wm73#dBEfupX#1P9l6J@P^Uv@
zpV4@yvqogjz(PgbOW91xyAFLi<qWgW*|hDMi+sRW){;@z%%)`mbA5%l9ohBD`<vk{
zYlU{D=XN6t_8NTgNXesTMVeC=^amx!V!eBkaf^5-d6srdCJV4_&G@RWB=y{V<V?Pw
zL@s$|phNZ%BsbUr{}j2Z*!IC+nBUV^(g*pN5i8lZT$a~D9y|ILIm=wu<U#TpF66|A
zz6nhZF`gFk^#?yIn9;0d<w-u{5yt5n5eUhib^F=O+%ERC>0@00dm}OC8r~DPXSUN8
z**K8LTzdby>5Xu8RsU>F>np?Fe2Q<$)-wCZ?Ux**uGIN6WtiNGw1bWZB=*7X^-0cp
zK6)Kq=5LvZtV+&t0eK_wdp_#e^?rlTlDI<FfKo@=8hJU9RoXv8`&!!X)zpWIwZ#g?
zmO3xeu8e$I+g;&&<~>x#KMgME$I^D_v}F|6On5#7{U^`p9^1BzT*M>TkH}|Sy5@Fs
z4kGe7S5GGUSu0eloMq@84Bv+!SET`o;rr$gGZ_4RSMtBvk<H`<+WsD!)-xXcGx_cx
z4edX_Mn&gC!%o((c3a7V+T#h2#8wbD_ie-W@M-CDw%m+EZ-1F}q1<f!Tdc$dT-x=L
zyXYN4IUc;|<5Tn=oAbswyq@Cxglb!+W9ykqGy^=E-j7XNPg|jjjJXnAL=J}Y?!@*v
z;p5!DHc{>V4`}v1>U<Bs8m2r+?o4<jCH5l{oY~Yd10P-L9N9PD%10b?xcji<CG4er
zIG$4GsFO49fd-O?z=oDQ&i>yslwv<_bB=h~=N$fWl(=a&yjvC5*6ZqeRQ#AL<>g0D
zI`x-zjlD=;(qkhuSBu!K+_T{ayZ*lU4WWh1*Pz9CbP;~Yd{0<&7uv|&|Hz!${u};e
zl1p@q>^q5nk=Rll4s7Uh?0wXAw)sJw7&wsPY7rVb=%br9|LGXsg4|^qI!c}y8k5U0
z?YEYg>Hj@-x=+NW39Z_<mG-x%>Ma>5nJ-HnIgio>y!kF)Kk_$J^zuGroqQ?#=oyh_
z<nb5M9-2$+(8awipB=QDfzOHOCEtGTZaNm5_HU^pTTX8mo(k`gpR;q{@WKDn%yl^Q
z?j5Gci;wKvk1lvW+Wdy(J#87NPaXbpe4kEi;79n?`xtLM__TlndzjI{JF#gqoWuLn
zJIIH~GjtW2I-&P#PI5SBVmWW)XT|>i$;jOfyr&;?4m~moo1Zly5d9nWzle2UniIQ~
zl9gA4kCi>9{udO!!PL7mls$9Fd16;Y7kh~B^tq~)ydvjEvi&{a+wV+UAT&M&UMZ@*
zF3KMHai=1EtTNtAQ@I~N8@v9e&e4$_M{-+&&S5RjIfk{oMZfurRCu;Ct%jui&<D}w
zUgW`dWJU|J=+DQlJjlARbZB6moY9iKj`^I!N^*`&dXP2M7VP8fM6Lf2x)UXKlJ%$9
z1X&AZGQK=ZKLYDSra8WzA^iDhSRne9&BGq+J^O9W(74<?=&PFeeh0Q_>gIoYOnkDm
zIRxL1Ika{7i;^Jnm#wArIX{b)+#ZePNFKbLJ_F=yBvw0t?8tg!7JQR@>F@pc4bD?#
zrxEY5KW5b9JvPceojT+Xf7%V+23&Yb{F)0~cp$XQR>S**p4}hEN}7`TfBvhu{@{7Z
zHH<M^rPWl+p3gS|kGNK<)|1SKa~l4Mn*xtaIx@E9A?7N%s$<a40j|Vxt*>EMWj(fq
zbCN$9u0nm_AaV3-(6t=hsD~#4m%f{}9?Mr>{kQxUYtKXa7M(v%tkSa;yRC*T5V`Ye
zdQz`*7%<M>z<cEE3w@>N%W>pxHZkEzY;8aGMa~uV(7%i^e6DI8!SgTv;BC<vuV^K@
zrO<_y_*C`?KPB!u=E&%ix%W5%VI99F`}bXO`}bwc>q%%PK1b%%%^pJ^<5qoR(;Hnp
zvlgyVHQ{`>3PjyCzWx?ydK^0;dq-{X;P<rae<6S_X#U@FPrk+fH{$)@a37oNBq#48
zr|l-UokT7^nX@8}R`;6)MqE`y{_B}>TI+uHFY)_-V9nKE6{_l=L_Cf!?%0bQwXhC$
zCGN>fE+EDouUbz*H#u|Ihi|K4KV!r!&JJu1?B9kDg>OerIJe~=->&W7s?FKIEv0kT
zKKx1FT*Y2pa`g%4H}mCeDraf;pS+n^ZS&?gBJ86asIEGgskvX4{K31>3|r@S3~5@n
z8@h1BeO(juYZ}y_JAr3iWR<l^8+7{!I$RGOs=+78#r_Lp&DN5t3&3X%_&8WwsIA-c
zHP#wZrvRMhfRkhE1Hiup{G0jJQwqYw2S?nqSf>@Js0aCLABSzmk5v(m81d>ADr)A9
zv;Ca$%Gl?h;|mje=>_V@GtkMUxfamJ(k)tYo#?5=jp~r^<vE<Y9jhfL{oTjDEPK1B
zDMi=B=KLFVK7lUwoO_TnnX|;OZR7-RW3I&1{&xD;HEjxeOdY2eFNBW^;OBhyCW^!G
z*F00gxdk7W_;j%wvfmefCi(2fe-EEYVh?Vy!#Fb)bEY2YA~uc<Rvk^q<O(kKN)G7k
zn~AJTEG02^FEW*c{|pkl>Y67{+OSse(;mIyd=heYcH@i2`6TxT1v6@SUkabgXy4AB
zikwODv)7O^d0rU5+IoDnqhmh%R<k!}hdqf}bf@NSiEvFEu0<!MXwg3GwSTA<Wsf>E
z`wA^Odn9$pC!f;Na{Fli5c^ZJ&yEh)J~6m8wp|OK%1a2>vaVcpd{FDDJZE?zG5CC9
z?&A~5v7a3i_P<ZwS<{HYiM!t&Y{cCku}>lUU#B@&xMl<~4C|J6@ul+qy<u_|z=7>^
z8hbayFS~n)b6;d0Ui7aA|7xGZ`W&BmxpP>$E^EOA&R{wH9~*lja)wbwnvo~jH}S2%
z(%3WUN-vnv?o@flu2x2FR?Z-Z&7BWU9J-&@#X72s*kI&UB7-CF_wqg~@&fPWoMR*X
z>Dcrl{`YqGrxF8FXDsvTcM!J#>$*wgCVNWPO{(J+<W2Ut<SdNzdzgM_(65i2n~%KQ
zZ1QqXz_YGFdP|$EH`xDpfi_-zS{M5V-tmD@9&6Da*73dLRI9{htO1B0vm-uqR@VX@
zzhg~;KSg(kMTp<R^RXcTa`pk%B<Re#_wjXJ#zSY8j*=W7I{YGf?PClteSDRDX_v#B
zr-wE++G9ccXb<Cw-8bj~eu7&+c`)(iI_udS>)klYUUbMicJyP1<8c{`odFlwKWIx(
zIiB?XJc9<~5?gy%yPjkY6WRZn#9FpSThcFiz8Y|pJS6r^blN!ofPQm++THgAcE{XT
zCx1YmWh-=>8S*v?-Ri)how$APO={h-haI7E));%xD>*9>&rh441|5aZ%xg6BYK+F7
zGx&y#;42K?2@i@Aym^v$>SF)oWAaSR8_1<{#^w<I`h-Dqk&ny>pU&_0xRD*^FSIcE
zF+3tU2l<|%m$P9$_EwZu{F!mj-inuR8)TnwuUoBCS%D2bf7&}Lz`C<JDr@)7Sz`ZW
zk9!((GsZ<$j>Ajgzq}LP2Z{d<i(CzIwa7k_x3c{)_}m&Cq@vf-&XnKG$hE1Qfxb~K
z72KI$Nhkh8)(^5Cnn8@nw<grh_IoG=AK4FlkNL&mv&1U$PS$r_w7XcJ>@g(183i4>
zIh(3eSMsXy<BZ2frNlT3L%!IakMPiz?cmi4KY3I5b7HUfbA0h<_=K0DJHj^~vZ6ER
z?8M@l72xZKU!oHyMQ_MqUM$PznuxXWRr<hk3jGZ^2wj;j`m2ziJw37KLX<J`lX4E!
zu;q;N!i(7lmDq01&{Z)v{X@<=X|C!v=G2DHw?hNjcmHR~Ek$Zw*DzTpJN?-n=O0~*
zKTdm@&vpEA2FxXA-qo}74~=du)3V=^ybCni&EFx<kbCra_gA?8%}~a|#syQzKXAXL
zP_1hpri}A*?{SXy=bSUTfqL6GD@LrtUJp8-?8zO^Izam2|CJf}9sMfyzvUYPu@@(>
zzg}{a!BmyI%NlPDJQQE6rxncb0(U<k{kU6P*ex$Qngrd0=%}1EOG<FJjAu`=TKGV&
z^stVtA)ahcfd}mC>g0*>0WI)Z&K-o@tkry872bv&ae?3Aw6r{8s)*PS!SVad72Cs_
zYgpt~U<O^v2e+Q!e0Wk}pyL^r$`u+E;SXHkmEuWkO-^>T{3KM>xD))o3x0nCzhjAu
zYqp`II}%e{YT#v3q3ZB~%MN@hF;-~O;Iur!iTq;74^CciI?ld;;7|pPBsVfg&Xz+1
zeGp?>^la8Vxh}@{;!jvFryKbf<}BY1NWA?dxg5K0J9|()$iZ0PL2L|vX3n5#k*4x&
zeq=yv;X$u8XU5KvHD`v@WgHj0*`cXi$z@8eP}afXN53Za2AgWqDkCEL)&o!4L%v4I
zTZx^Nw#5!*#11ZKckbK(w2)ZhG;xHfTgr%Kl9;2+qXxTDbyegs^s9B^1QnKZxq`1b
zzWC_ui1?T91K(lDk>t{cMf|cqGTiJ#?D~HC@gV~>@TC^MRMQ{(CQDxf&sR66jQ;D?
zF;jMGsYyF|UIhJHu=x|Alk8K-++|ENCdiI#$LGlS%e-oLBk$wSqI#3jdmTO!-+7hZ
zGM{yT4o{1rn?_6~^m=k7@hx~i$-2A~`_oP?MsOBeDYmUBK}GE|tm3N&I^U#2$1M}E
zkJwOM%gPnsGvFB_r8tv(>G`5Rvu`W1o8e*4c0(2UM?JTieSxF|SId0pQ-dzehb9u&
za>lJj&e`e6unymB+3Inm<q0mqgseQBzFg>m>@E0Z?}k2TJ5=@<PPnm)_(*b4p=PHy
zSH^Y2XBT4?!5^8s_zmBpc7xv)B6qwKyBfsCivF%AAKor|FZe*=i_AYhp6dQIRw6k>
zoiizdqm0#c=6VA!J%K*r`l_d|AbkbVzbADg&JR@+b5}W-JACuOw`TbEG5Pbc@J?)&
z%{%^IuDjbfw<5eVeHY)H!M|d7HwC<djriuV?0tcc;3=`+r}QH-)XybyD>4+t21{<_
z+xQ~!-LuE5b)rXyu-kIpMq)kjY1s0b?$fc7v69<CU%EbEY~rvmagpfqCxRn#X~vpH
zT)4ZFm@9ab8UF=uQXS$qq@Ki(qQg>meloeCIRASmx-5J3o#gw3A6ws#9SAZ`72|l(
zKlY?EgZMqMiBeDe>?5*I2c3IPU!U8;d%^GPlrhe9h>!Z@4hMe9X?&j`v=BOe%=oNT
zFNufS!8geNCNC_$mAK5zab-sw(CC}&kF^a}(;~c+da|~cxGl_gPN&e{$RKQdqMG7E
z$J?3jMD*MXPuTZKvg5b~=yWxE7L$B|8Lt>|W_4pOK7m*w<aMUyWneQ8GvD7K2ZxaZ
zay*6{c##8<ffM6JM<sWX9r+n&bNQ}jT94!#8D|G^P8v7~-Rk*9Bus3?I;_JxHu4zs
z3(NN~=6ps(P9-rHgYIIlvLnyIf3XG9mc5w+UEpvSnwxRRTxe+7N2m4uKok3c_`DV3
z-;oos6PKg6p=0Q-*e`bz=ask@{R~2bqz9CtqwFc<)UXy1Jr(<C$G)Pol7~V5{bIu-
z_yf5YTOfKY@wmu=z}^9WLoTROwN3O>4VAqguaw(VNaDZy$T2h!Zwn0%BQwqHc}sht
zrI&qO+dsRYnZyfYx9X8Qp)oOxDaXXaBF7@{GKSE7_Ez@W!BN)ee)i_(v)1vmHz#!D
zf4^+RetvMM0+(v==pv`O_bwmf@?K&?WTY3_A%~k(g<Q$m0&rj2yusIadhw-nAJ7)#
zoB2k~e}Qb{TTOnOu}wZS;&16pYiFD=_ALJFoyf8QM`jK}r_7DPe%Zq+X8%g+p2VJt
zZ4{e4J8^!^Hr7nN5@%x*qsXa`b3r~WEia5r9m`eg{KN$Fp_iY%QHh^LMwT(gVb%<@
zZy?79&En;6JNk7P{EkgwJwXg*?>CjpJ@`h@x1Yni1zJ-&ylZ4H*d2ivhdHCne#z3q
zoZsld1_b$Lql~fg7|U3%T<tUX`U$pHbgVfcEw2F^_C-1-HrCd$w^<J~C73?a)-nFn
zt))lV{u{xWypTcDlkidK)+@Bq+(|xo`8IZ_-CCpgWUo@<fUlYUCFNW{oc+E?ACC~f
z4y=!t`ccup0N+lF?s_>7<U__qcg0SLtclMQn<Vke<@EIbu3g-Q&F758?rzRwip{j`
zqU^Oq_@-J%2KFH*NvtF1qubAbLl65Vu9Sktz1YG9*uiJ8gSQil3V(ELAim)X`4evg
zIqb4qU1S68HQKFlHt=Hmx6gf{{reSs9GKph>Y=e7K$c|hm~%elU@rY8P~sDpC(tpB
zH4$sy&}{7GcI;&pIY8ekV=a(`?K@D#{tEG$aXy%H&Daq6UY{5M|6lAn{HWN5%ux2N
z!ENLmwal6@eF#r04f!#@&p(YFYh(|$Ikm9AnR&aBGxEL0_b{?=F6)y8@T!LIVBGXe
zPT`2G0VzLZ-X#ma8R*}~cM#|j-&OefKSNG>iM=I9D890j?*=%dBI^<2f#Jp;5No>U
zWRHF>b%ft8jXWZ2ym3Yxpd#00Kx5=$1o@#{$yucb*7d}`y(~Jed6YhEM9Zi|_E=e`
z&Q46PgAT-yf#^m@AezZpxyNKbk+p!tB#$$089K;*#!~XxN8Tc?7|AycvM$(2e&N43
z>s~gVGw_^`m-@S@ALO~0I0iaIOUXmZnIoN?vh4R7XH^(izB4RhFGKqLzI+2kzEz{G
z6<hd2QNArTeB$tk#@QX&bBGcHNFJ$(Im#YhHQ!2+yBNj(tMSdLeADtd`N;V1C(nI5
zd6{?wd+jGC@{3Hfm&SU=X~ZUDiGw<AxrU~$kt!4xA46X8FlXdk!&QhJV~6_+6)MKg
z`(~;1u%_p^IMXYBU(O`YKa|tLhhx!<6uvQrRt6lJ<3C&RNygr$0V6MEz{p((i8n6q
zcYYl{vsgQqx7Cqr@#zu+yeKkF{@l;m1s^$D_C%{$r<WkFp)L5mb|a1&7MY2i5SZwh
z_&Slb?6JNY@r^n;D)D>bv-81K<a;Ki;a8dS#2dhIk^Fsu;K3p;_G4<s@;#=1+Ptvr
zw@;kGzVP-zq1bpWddne0zFTA2TJ*1(T67=JeWSJL{v+gYhmqrjcd=M@_!N2I-Xtyh
zDtX-==pXwRE$kXQs5Rv{d0cY0z2tITPYiC|NxnC>WlXqtYC?F?KNW`G-*QE`_akzG
zgSBYTK2KrgbtR|!d79c?PVP%`xuOf7^4!gwgV4xDed5X~=*o<P=vWzRV##BlSuEe!
z{>J*w`1$as*pzc|tCQU31A)*uY=p$Du4G~r))EU6h?h98n}b~)j&J_{9M#&jVSVEc
zd>#A`Erh;1XJx0~PwucRRh7gz2ly&{;hT}rgZQW#&AlKtZek7V;u5d;CH%dtsYTy2
zwz?uOBZKGThioH1{eWs)Ci3yAA>$GgzSMr$sWPNLiDTGzNb(hEw-&op4!J%fK9m@_
z3|^`f$1VOFHa~odxV;Y_ATeDH`9RrUYa&0fRrX5q%U93wj!j*ZucfB2USE{&OkHJ^
ziK*bu^WfBL$yYDRccngLlu4=Y8)ZuBBF-Z(${&)t>g?d$3G{t!z9V(Nmbu^|&df+Z
z?*qR!e~<}F6j);FLk7%k!dwEQe*>0k!cqk0N_~~{YS-qco3Nn*OG;g3z($xb^l?#s
zN@|J$8)d@KS;6Q1erbE92}55ck1sZ<oET~cyx2<oBzyRt&b*gp|2{Z@{3P(h@KOi=
z9lYo7H-v<zE3l8H0e@crof`*k+wk}0gUBn>?mOd!U-JF-h5V7&poO&wym`3>S_|FL
zy`R>&RI7vabhReue>rc44$f!1YUtGuj$d{zO8i;~-}Nc`^dEC}=s9rtIqR0M@U2H1
z_{n-h_Pyn~9Qz(bCs@ZEaG}rD>{|)0Rh(-nM(?XQ+fu}u_bhEnDaF_I4Cj1i#i(0*
zUsSEKx9;csEU~)(#9$R2<<b^-IjhN8td5>%w6NsiGc;|%an8ORbBwMz%y@l#bM_fF
z``}$0_?CWDQuwZ_em7?n<;+IeQ1ctMQs?Lzu{|5u8-IB?df-sGUe3zo-+}%zuDu^3
zYlL>r_5b_dV?Su${<VIYNBAjqMDn;{XLi5%g7Ee$`-QghUgBxN6`R(&m%VXm+b%Kl
z^?{CF)&<r7ToCq+4Mgw852Jqv`~`e-1P*=RJ#i$wqFwb^hq1>2ua3;uv?H_e)xFSl
z0lLbW)SLxdOZ)dallmT?+Vbe9@GJigzRP5+9YdH0^yq;$GKVKt%6@2e<Uf#)fW-ft
z$JX(S|6k*EnEZ>4*U5h=2>1LSd;ojB*z?8<)?diE8(V}<v}7UIe#u?o=VdNWZkIE$
z*^!T|+-<w_>-|~CH19k9i2TX-7+K7deBiW?(G~fos2l(Kf5sW#3`V-~Z=Q5@KzL-@
zHoo;Q<?n9LMr2oVev%In8Pfk6E7=5HPjdFgE8oi}X61>z3!glk|JVwz@>T|-f8y@~
z^)QxqCEv=EPaeUTW&FJq`I`c=_a%Re;$~p_rpRNG_ZY3ImnHY|Yj7$ff9;(em?3*<
zUF68R9iv;s21_3Fue^_?tB{P(_n*`B7yaam_%4{f?Df%c^tX{Um(=miCC;P{xthK?
zNvec%VSd3o_*r(Y7kqu3yU4sof9yZm1Lhl)1;tMHg4yVOJ2ZKcxwx?prAyU^+c;xj
z#O^#7L;v}lBYEbo>V9PTL*j&?6ThkYx1uu$dGs*3`rmQMTz&sk5S{--f$<He$lSqW
zH}dz2QtFEMZbtTYM5jgP4L`pPy=DEJsd4^c`xl=T>~s1e`0Vr=@+3R8Q498x2Xt~K
zxaMrx8!vwrd+u7!JuLvoeTyc(yc2x)ZdD)3xs!z-f8*i(+VB?1bKm7mPTF6tTL0=y
zj{NH_6I)&zsy?h4$~gzl0k?f~_Wu1_RcirrV&AxLY(Ia?2EJzm)REEXcL{vx=I;i@
z^Hbv9X6kgq=WkI;4)(MaABnG)wV>^%#Xn2lZwEf|A=ao9H8*EXym=4euZ!;tHhu^D
z{(EHp6n_(Cl~d1s71>Y0r@e}v?<034@>I=Qvd`%yKGgixWBn85d_eK$VWWvZAJLai
zeQX@(KU4vFpxiA-!B@r-AL4VVr8`FPEr&x-(zzEuB02a|1;h>o1#fVsdFUg=5PbWR
za|+(Pk6)JkKv@^;$3MWUBLT)@t_OaCpZG3oSZQ;NeBjzCdq=&dr6t`Gy1r4)jmUUg
zi9N<?`pcfc)Rv!vM>BYckCU-|+OVW%aN+Nfgic=&?+m<#8i|i7hSm}no4E}w;{Ci}
z#!U9bkn?KRekERF5%~sw4tUDBtYYL`zBOyVT7OLBtr<DRUL0t2s1BK%cT1q7i5!9G
zrgw{+XBaqU|2gO9<-3m0@o{3?WxbJwtZh8QnuEWsQHCFoJmme%H8}plHHWPA%r(b|
zJ`XXL*a)4qiuw0H*l!%GcJ~77VV!~=_KoM<kc)E(y~Y{U;eAh_+db*Tdc^FnL0@}r
zzvKSP{`Q$y1)_3xP4fMcKNh>w&ozRzm8|=+WFD-u6*!ygrV){wn1jx96nuzNIV&^L
zS~rDQH;pjXP0i?V5Lx*Za=ekeyPPpC5*y>l;(O8Ik!)v1pX6_3O=!j<U;H<@#7>Iu
zdY<zo(ofIX?7SafWA}32vO7J{A$jOeR>*gt<RpbwD_GCax4!B5$6VOaUZ>*Bw;mym
z+#R4!&y4}{V5TkYNeZx!#rhbTe2n+Uu%&yG_zsmmg_e%ZV@69~?Z{^sIlTiIHgLiG
zbyuYS3jHkQJ2d!PGK!ehdj+-vK0BsuepvGDQ|a%7W7L99$EcPkxI{KijPrB8OZLEr
zM<()KXi+Y@GtP+n4SH^6Y|if<0r#l1aq;&Dd|KdVuF#DBW^Aa~Q}#li6<hi{=39e3
z6&u>b+Wz=lVnb}{$**c*v8Td|!|*}qEN36ZuFBtaYR0x69-%@{Kvx$wOvi@FS%`7q
zq&|&3C*z3y68Ue&H~oNmayI9aJFNX&Cx6GskR277P3+cg@u3YqV0RAa$W}Xi$P)ZF
zKY>rvBjm7Omhb6BwlX-6G=edOFNusPI?@hbnytM)rAD0danpD&>+LP@M(7c5V`We7
zlRIQxWS;H$qFl=;?1ad?tVwhDn>4p$A3lZ`VdBy%biWvRmpCi%l*Dv8IqwYr!;IZ2
z>oO}pCuisRHsEC!YvwPq3G%Jq9q37w!;|*|zGoSUPKi!`j-K_?_i=1RJ$;{qf5@l5
zhdmUD_s65pz3g!vca9caMCV8L$+s;MD~i36_GV0y!8uGl^1nUc_jznukX(hAb5CMF
zdifqm{Cf{$9KugaY)CvAy_!CXuaUi=(UD2$?!={&TAF!BoQi!J8L7sG@Qq)e!VX=_
zJN7lBr<}=tY`J`Ec7*cCUd}&nM|c0VV@vp%@a*t@_;`%7@_o)B5&mXM<TyE$;_di(
z?0@lgWQ@O&=rYdZkBCg=+cFtPczBXI&PS$CZt(So!P$==n@<j4(w)`)Ee?0mUTob7
z^nh4m-K0Aw_KV-`le2cTmG@g@@0_`va{B$X_`g2RPwwUK#>~ams}%i~MVueG1-tVE
z-z0vQQsyw3@5xT^?xD~(9##(=zvU43{}+4j9v@Y8?*H#S6JRD6ASB!ZZ7yKV40z`v
zHkL_1n+qx+ZAE)d0;tVo07X#~s3rlmfdMrZtHqv^fIa<XBC)o`nzZLtF81_*)(h3D
zy__0??U^K~prRAS=KKEa*?Tgg70>zp^ZVnQ*K4x(+I#JFeb#eZ&-1L1nSuRvMtEd_
zap)~~M!TEmDFI{kTbafo<IbMTR|MRvpK6}l@m!;E=p5{uWoKxxUZ+zQ^lwoH<!aBd
z>8{*Zl<!y2&O*iwzml-V^(NMh(w9L`q;qEdHBVnuXuWG=ZIwb>!agIi%35EaVP`yV
z)FJT<IqZQF=Wbvk`y=mxw*?PN&?jGryfk}#b#2cIPqX&eUccAq`T_Xr0oMMJdC)ds
z{(+O|FYhyEzIP6KgHgrU$-{rJ22b8*be+7Hcz@u7H-XW9=I9_aSbCKY=d!m%+0r>4
zgeDgvUmw3s@#`i4pOb;X9DED1p&cXJiP<pwBymF7qnf4l;-?+fdZEu+FHd6^IEMMt
zyW}$Tjmq%?e@<DzPqP>OlX!FGS03yi;{G1!puo*_2fzo_=!iV%Ftyi$efXkxFMwCX
zhPtMJ@g|0)e1O-}kKUi9)b)MY)zvp*Saaa`y+t+Xygx+W6Md5Bm9DOCbPIm;W75Cl
z+r6d)II`@ms9$3${G)N5&lu+2&3+o==VR==_-}i67@Zm`XPmsq??LsS{#ZIQ`cXss
z%JYpGDtqT-$(^a~?@_jN9ckW%#p%9=#cxp0n>@e4l@@;7Obb7U-lJz&aYx8Bn_a`r
zj>8!N+<c9WWi>~Ob_917Nhcy3FX4@DV6p-nvj9GqeT8Rgkb4Q((|nXNR}uSVbxlnz
zV|sjRa9RvH*nCgWUt13EmJhu4l4tWZ=n?4q48D<n;~+Y*@2xA0m9dV4OJ~;hPca5A
zbT!RBaiuFV1E0#Lfvdals~i|*3`Ec|O@;TYK}R2*8`swoAI*O<7kUHivo|z5)n_zc
zOn-ZMU(deWU%_S33(&{SM%F^7^E&&nt?qv<`X#bj4g38OBc-AoyQOsF`hT5<Ub_j{
zet(29fZn^}VQ|G*Q}2zsr-AX?>b;YGiH~!cnU*HF?Q^A7gz8f!!Q)wbEM@oumq8bQ
z3k|=JaqXuKo6&0>rT(XZ={{h&#YhhogKvZb+mX?K?~cvRHB&-=%^K-bKlUM)O205b
zyRTM1&Ox5~3wVzHd66AF%!Q9}mEOS9xM{lwf8133aciM5C!vieSXbT^z=-St`Q`|9
zE8g3O&_mA(+5AuR|CDkC&o9CAAEr&xZOe!5gnM$k)qmCi_L{7@VgBlR&!i$`ot#{F
zO1^18XK|Q(yJ>qHdtV;6r^0pnq)C6_{b6)J-Ms5@Pij9&of$kUWo$J*f2H1mSBfLA
zGhguEnLcw;MGRa}%Gef?ejoYkU2MEHPo<0_`<U6|;eq-{YivZ*#!{X!3Yw3M3N33d
z9fi+-iE${8F%fU2KF%kP`mBDc-}U%yucg2Le#fLqd+q-A(8j-gk@$Pe&j7gPfNOGi
z8S|lb!!NJ~v)li|`ySWCiUwq0(>*!-N7C33)*WPSPv!<_)8#&=A8Pvn;6eRRpAJZ-
zpf4IP_2+^0g|+JYbF^a>y06vj(Jx><;#YeATgZSNy(!JlQSaWyeMS2k_ZPhd4cw3Y
z{@!6`$KJ-hMf=TP?P@*zT2bq;mZG=*F4~Z4@$fan)50r9TJ)j0oV9e1)*<*&a?`zA
zD`VPMsb?)d4}Ey-jmp}~(WOb|?1O$t&s1&M*~a69)nl6}y^Qo3T1zvL0kw7t#~O;|
znOTT_Z@$~&(}{h_9<(2x<9j7_HQ*nW6Xg3+-k0%RDc=-=BTM-PnMkpo>S`DZ;bP%U
z@NH%(zZ2k3#kmQx7hR36y#pVZYRN-3KUfXT;;fqN<oVPbYwY`GV{1lzUT~xAA~n9&
zn7diKDjz;22yAVtA8}<h`zlTIj76Hae%43`_}U5Yk#@0s35ccmlct<KhBs7(?D>?|
z=Itq2tgp~Y?)Mn(5PFU!EnJs_tCjX~MRB<(L-BLK)yG&T(u3@QKYf$_gunp{_;uXb
zlJgd_qK9|)oe`)#M7xOdcKpUaoL&1CbMvM<)87rxC3^n?@9KH}rhBwsHsV%2!nO3{
z7-d2u{AW>DXqb6r*houTLw@-?=(*nO-ErC>pZ0F}m9t$L6&=XoZ}aXsu4>a!%BDT!
zA6;?Womnx6eqkAXT<r4dyq4@L;#!nYU%+jIO>DOoyUaA42{U`}(KNB+LSA4iI{<AR
zlP3O%&9zJdz-2CGAH9;873sA1HOhpKT{4>bx4`erb&U?~gV$94`R3>fjpLCUhDUag
zM>za-+A}FX5V7d*e@?ab$4jxRo&+3uz;nMOc0<$Ex5R`4ykFqiMDd@Vir_T#0nic2
zs=be-M4$~z`X&_*M1MBFE(WgXeR6)C;yQ@V3$F?vtpyHGe7U5n|K_qe@JEZjG1H>+
zi#~)dMWNfhPo~s8iZ7A$f*)RK4174x)f{~V-O##QV%_AiVhpi9u%Go;17{zun;Clw
zo^sbm*n0qrQPNe&qvBbLfZHf-_;3n1k#8Mcq1Ke@UIrZ$Pw;EL$3JSD^71@W&sr}r
zW-eg7v~GlxbIt6~yYMYfeD8sr(ra#s`S^+NMwVG}@~wFh;>OTd`hq>g=JmJKR$_Ns
zz&nd~0w2wxEah|3$~%K+PI?diP|q-adkW%vB-%ffEE-vT`~9i#3~BHTqVI38_U<uL
z!#Ciw-T}|B&n)gh7u<Z<1W$Pb9o=5yQwRHts%joBg2-7s!(4N$#WVQf7qB60E(1sP
zQPzTBFt%!|>(FZWuaz~v*n+xH?H=;3B))==dG8009f9Wv(x1ZhGh>^udnshxn%2+M
zQIW{=alF++8aeX8UU17p-lo}F_wSBJXP;I$Tllws9=s)Eej-b_W-@dsw|&<7!dPs|
zrIB~pQx-ja{}Chd<Wt5Wt*33kGx6gxqm-v_TY&2Te)BD^388(AsrU-vvcEE}KH#=@
ziZ>z}t$KgC&R?5r=H8_H_g$N|f7|@Q_AJVbq7(A`VQp<0aP6mWeOKUvAv{UG{tECb
zb|R8X&Oq1p&BkHvS_|5DpJqQ(+a8^EaReC|J<%k8DRSZ<-}L~W@o|{skH^cH-2S+U
zjR^bP(VOvAqV0_X;Cb5HJ3BrO@~iXF{{!Hdp6`AYeMMHg-XEb4qM?6<K5KkhpjrPy
zS?}W0mv<g=DS14TjomIwzMPC)IjMc@7mRIxQvaa0$|wEpQDQn;^#Nll$G`NJSQD@=
z*lxOJX02dXd}QlH<VE0CFe}@Xx%q`556@0ah|S*fMPto=aIE%H&!v3P*J}8Iqx3=R
z*y0taPqg+#7IEPzN9$}FWjXfG8__xEBGZYt_TJT!Qx8A90(nwpEO4hkBfabq?1SqY
zjWsTOX_ap#b%BU79hfg%#r~iL_n!YT+-rR{j3L$<<CO~R_Y?aIo$)i;C(;_I0q*-L
zd!^Pv5E~-sg4Tgxe^pIkExd)rGjF6#{j}L1{Pz6|HX5wK)b>!L(Oh*`eFrk}aosnd
zGv2~=88lsETgBMT9d^gt;?<SkzvhnnAEg}~@arp!sh9E;|ABD`SKSpj*^$Ya0e2ZE
z(b2@e=R5KEZ;(&>bo!=(yy$<!o1tUy_dlsQ!>E0P{2EV<f7v7hdojKN);9@HbJm0S
z;c{SJG`AevtTy_&-1Jri+^OM4c*?sbqjLmy`dDj%8QLCN1zorZxVeyi3x3#37}x~-
zQ~*cRo4E-X@&iNl@Ic+nTRC-?Gw-s?tz`eclxH)C#bIbUWeJy!r7RXzrX&B9F|TnM
z$lLy7*4d57LC=BD4uj7m1DP%pTo&jsQaO(xcocj#Bm;@>&VzUGGd|Op*Q3nq7RIQI
zd97hy!_2E-W^1q}c26)^3lDaDRgFJ}OxC=*##f6D+?v-;vtgDGd0PDT$M&1R0qEUk
zBhS`p&q=t&!?)l*&P{;lLf(wWzX`@lvyI&q@Yj9lD->Jq{yXYlY`Ek07Z=cm5M#0$
z+4Ej>gsT{vb7|`$bJR17-%e>Zs)l0Z6te#$9n|H}JrlWiu90QM$Z=saH)TF?(F}L$
ze&VaF9d67hn2O%U$gyJNw6I1Mt4A^C3XCz~DTWb#9o<Zz`?aDw^U%|$v=mh}>?>N<
zu)k<|!)rxVDP~7i!``Ch#;<n0Zt<|A`g`1&?FQdZNq2>(rntf-DMs^k0kiq;!eQ*K
z4u{STYyZ~K%37Wu|4+lHyL(Gz>_>(%@Hcp>zq(V}rvrZl_m$M`F<qeoY(S5ErzK|!
zaUZ9kzu=q9sczzXG#GWubw8E8symH3@gW7gUje+;=M{w7fRU-_I_|1nf%|k$e*^7#
z{oeTz_>}%AuvAiHjM?LIh0yEJ&(Yy2p&Mf*);PHP4?{Bx(2v}?K3F@iHdtG4q=e@2
zYz6hrtM%2&S3~dr28>@)yP|fFF+6mH`i9q!xsra&{5SGlQahzqZL!{)!$PIh|GnBN
zu^*;XRLr;EJp#WizWmx_x4(GZ`W3a-HySH<N_f7J68<-1VeBqrbnII7$w;yE<l^I8
z$4AX7z{Yt0vBBN*u*uwbY{V?(nUbCo&QD1Rub?0KjNi2r0(Ex=u%%3yA6iaqgk>pa
zI6p5?x6ClZQ{eknq!9Z?zR>JJPJu7XH{85ukBTw90Xia`ujmUjdUtfWwXZ(Vi%yn(
z_Zfm&FSe*ooS4CRqdwEW*zqO&M={-{o6^3M2fLGTX9NbGK|c^iKQ6gU@)>b1E2LWi
zr|&LD2dj0*nmg2=;+ZX-$71G0`MmNQVU5f%8@lBGEL&H7x9Mu%!=C&LDnvUj0Pjr$
z7kX~bo>b+^M(&k;udCeyKdrcp`QR_vd>5xk?v2~EE}S$ZCu&^4gUGts6^?u;*$|k^
zPDRF1yFwq1nswJOV|E(4wpFxuWhQ>#W@`A}|02eMIjUc}$I>&5X6(@JA9Q*9kCJXe
zM;5u*Xda*~velAr<%jV8iudpVYlHJa+R;&EqWky%6yB&I)0p`#G_(m>={mP@z6V{>
z5%|d-^lwc&jZS3p_NGyc2X*u7(!N|1c-PXY?VA~vPVE77Y8p4$iC)f_J`IlfhTWz&
zfN8bAnt9G+4@J8CYV3|zlNWwNz5v7q#xE)Vg3v+Mk;YqNT?5{%Wbe~WpDLkc!q@Ek
zwaZpx!5iPc|5@Z)$*VgW>pPH-54Gku6z#}wDe6E+x*C~D`=iJzODdstdzq(aho?XD
z*s!$lW$d*|--`V4%ya02_8zW0xh0e9UAZTBS>I*!OYTXd9_ZjRPgBnV=DLr%E<;YX
z<YwsTR^;WQz)UrGM)39Ymo5lvJ~fv<Y*St=@P*6r4RiwF7-0Wv25XKoCDR@NE^irW
z)Loa#Si;|JI$8B%kbAwqmU(`kdAgQ8z#hIUNeM)%3N(+y{CjhNAHEeICVsC}vUb5t
z<RYVa274Eqh8M@YrZMnu#7OEH9)N$#ZWrGwSd-54681IzBk|7DzKinoPJPw&-QkA(
z@w0m^T@Ab-vcAf5+wY^i|EyT`vfuH66J(=%kTvB4ANY;#-%UqmO8pP?3|xJNH#`zs
zYyZ|jt^5wWXAr-3nY#`>WnJoZT%mEPL9T;?$IgPz1<;+R7aLtQz=?cWD}WXG!ep#+
z*BRF}T%3DWPDC-d!mhko=sxSxfaA1@?mF)#v#TsKFz29&|BTM=;hFlWHl^kdZ&o|<
z(5K|1S1CY`vI*O{;zk2M_=bzUx2HtBe+7S_zYpR6nM#Z!{N(#ncZ`@505;T5@227|
z*^P-WVh{dtoqOf|t1+N=>i=@)M*cR^0jS+RZ0S;oN$aI7|Lcq^Wu=l|V=JF8-p}$8
zUs!F+#~;4{eWco=Hu<KKpK(&zgY)9PA|H$4jQs9ljRom@8L{5LLD=7VYb0yy?3gz2
zi4*fTkNRX2Tn!%~KS%kH3UA7<X*~336aEHKbaxK_EkDf?=#F&v#O(6#GitHbx8y5u
z1hGTj9efa36Mu}X_8lh%A2f8v33Ox|<!l00%dqv-o`Yb!m8*QKhT=AJ&I7Se)GvJ>
z!T(ToKY%Vy`or(BA9@g5>j*KKJ#KG#Q@UqXFLsExQq~0UdeH5eeE|OtgYic1Z><9l
zbVqgwnghW}+VA1%!Ce{5Mc7PxW*2%K)^Kw=Fj$dk4D@>Obq8NdzBz`iPL%yFwWZhX
z@i(OzGgbekl&3mOV&a{nHG{8jHMT6u=cRlfKE}%DP4ig(Q<gn2?O#rL8jDr_;>b#P
zGpk&lm(N5Wy)KCTqc<#BZyJ1NS>4K54ePj_d4^U#aT#@L{RP=8CO(!G-_G9%e8bCV
zuV)Hy=Lc^3;J^GC_@qGZDoyrrk&9VF1Ag}JD|p|Jjo>tVMz(;T<)gNRbyPoWL8yQ|
z{70`2)rR4373*~iG3;9KF<*v0W+iQs3=pC{6|_h3;4N5Y?9|Ux#xD5YsM)>1(5KDk
zuaL(yFQPx<O*A(qI@HIZH_-i=heyQ6?&mS~F<2+P_LvKXiStP8c<saGo}UVxSZnbR
zS?z!0s+f2OHQ#njJoz0J5UV1OxOn-*t`OZ89xD{B(w-vodoAC6V$V2WG|wsu+%K5k
zweHqhuR+{i`g|64BYtyaxZ*72Z(pG9iZcRrYvCClg+^Ziyp3k;a?vLqVV`Cc`wqG2
zM79#kaX;(q82s&7%-K=)0MkYov&y*7-C(SFVc4iJaIoY!;~;szVWjKw`^~KIab&hJ
zt})?m_*`^l%_Vo&cN7y7*kB)g@do2i{+(5;OZXMsIkzJZx-{1{sy`1}I0!upupURd
z(!-QB@@?d|(Ze&JInOob8H3n6$A$&&rwr_C0w0|>#`p>4oNZR0b<%+Ewq!uc5q%RK
zJ(dx;|G8nK!@p&&@1afU#9(=DsnPsA;{Z>4s0I1tE&Bd^@T}VB;73Y<xpZ(wl`HTO
zybt#9MqOa5aWV+~D`mfF8S_z=KRuk6Hv`)m^O<g9vQ-0j;-zx2zji@~tI2D{yOSRL
zlznqAxV??}sJYa~xj5K!&56fO;QkQ%M3!A4@#1AySXXa)LTZm<qE^rr*=C&14pis-
zu+G~zfRi=%zZ@3#nR0B@y4?*qDZp+uvQZm2CmUNf?V<VDZ;xQ-A4KOC1YT*675i7Z
zY2ew?X#j7QO}Oy6hjmho|A=&S+LP;@Vhl7*CaweYLa^ZI(7fpR9eu)4@St>PtI?m`
z3y=4YbZAvI{Y4GIWF49(u0ykBPTA)=@@79}uH^iMRW(8BSdOm@#%0Y_oOkEQno;t&
zIY%y3Lu}(>S91+MRkipp^`2u!f+eoziO8+JBhcadc{U9@^J25Py2Nabp6QARxAmeo
z|8gCEjmVngndfR`ixaGkQt*Bhy^HuvV~5fFU&L9<8;fp=_2Xjw=q$XiGFD3WFeXZ`
z^~7x)JdC%;6UTwlKdytmJ$ZLa&PjB)8ed|Z9alV?(lZ0K%g`Yd!gEx^+bqG>v~X|~
z_&lrqFX&yXz|q3%>+qRT9|M0MoYBPh@;&aEqL|BB)}Ds^kH><aWDoP5_lR{s4AbZ}
z^Q~BI`?2>?`_BWG^LVa(V3h?P>Pn@Z=s^0#1FyyYLGfEfU)685yM}g0Xt$@aB=$ad
ztpfc>IyfEpIZhnbFl(%N6?(i7_%|Is>(R!v_O!a`R@^I%ZIttG)JE<3jz{PA?D2R%
z9C#J%RS~~JaMni5_X_G3jC!$YF9aTQ*>{#tVII0H=_T3I7^A(MdgK>$N{edlHtM>M
z4=$NIk@ynu+=9(%)HR)Q=9b|v%(~Mv>A$2W>HisLb;5hUi98_PQKK2xGd;D{vQ21S
zX3p(s@ZQl;<^4*>2KJ1Xvq#lv{(9Fk^Uht`BbI)o3OP~wC*iO+pDc-7f$rg07Uwj;
zmxr;%=)m{<IdfEalxq~eMd{D%GxzN(M+fx?I;g{D<E}>5{9H4=KksOK-vC_j(;#K!
zuAe5}oR}kN{r*re<|Wp$-y9vwCqHLdjn|rX)@81nJtgMR9E)C_xzhZ00H2KKj9$`(
z&>zVuh0vem?@nj``B`>9mP`qsH5MLAyw<q9xL*psvRzNY6FdaJ^nLgz;S06R2ak{n
z9rM-Q8e^^wr9#Uh@ENJVl-7WF1MwXziHoE2QWv13nFigjH?#Vo7fY;|$M8HIW_oG|
zJi@BRK;3F!gP8fDDa^%c@g*4}!yWJqd&~*_jqn4j&{O@mZguS-zFWoM>J0G(<`>Ri
z3BBKXa{MgdbYLZAZoyYh&lGPV2z(p`mUh*hU90yM9}ezb3Ez><xeP0*L$Sek)vc_3
z7TnM>?6Oda>|K|xtW8H}xRvrd;5+ufcSsk#6&kF4p)K$oE8#o-lkx@s=W#aA-cQjN
zEM*)7`%U0v=@O*-8pn9O2hXJS(*?izp!ivv22FszNDk7RicioS3kQi``yDnF4RL&7
z@wJCpYYm*0*~ByPK0e05OP^n6Pv$-L&#M{tcd^?lW!zsP&jHHZBp4%}m0}Jz(Jrk;
z`0$WoK&n04!L4QJ_2%N+rL%b+2G0i3@rl=!eq45yxo&R=T((4Q(z<`)m=$}4m_QRl
zCicEfRvp;GL0{y*ul7|l=9_4b@552EH&IXd`d}=G-l>dOQoj5^T`{^s$z=xz#?MM+
zZZ_lR5gZt0$!C&-e2ll3@m5UAp|SbG`J!Q;WnUJBhDwGg#6Hu-&s(Q>Sl*EKPd{4!
zN#7vv9L5eB><iv{A#p7%`C~ZaFC9<~<$xb*x`8LfVR`pcd_#Q1OZJ(jzYIL?B^K=o
z_;$}(jC}!TPZG0Mx}W!@g8{B`Ik&{aS%sXJxqak#a5pw}ZsaTBcw$K4e{8g`{Tn_K
zv%mq!*<Rpgv*yr+-DcgaSgDy~jj<&c^9;XjE6(p9xgMacd+F~Eeg&*!#R21d2+IfD
zLmV(qaQTI8#)MggmYj9&Y|jklh&nV@mV9`uc#dQ>$!Jw}fA!osvlzXaY;Cc<Pz(Z3
zdpYfty}!;MMpp4FuiDUn%#Yos6<@}~RW?}~N8j<{IT}mWj5U_Zub3vzx2foEYi#*X
z@4UzqW!Nv(po@?ne7fd@YZ@_H(upe(0!M5?c5wXNTkv<^4~&-MtD8C>pFQ#^Hicvm
z`CdD42W<@dm<!2oK44jMEg8_N6FBtZgCzM$W9&nBtLKczZchq(W*RTjl2xPTxjMhk
zTHmbo-CoArOB_+zaS9KDgDe>-P8*DV@wZ;|C|+plgX8S;^Y~un8GNg&HGaUva(+%6
zx1IWq`BS_?ogo@D@+=rte($&AFj{V(rz1E`K2Jx!mCpDIHdCi-{~8?Qi#+VW;}Q49
z?IvR&-+0BB`<M*x#;<SV$U~B`)2Ck&@q9HuthTWK*gVKNChxja@V|7or($<q$a$HA
zcjQJ6V@u}5vA{<T|AEwS_i*gV#+k&E<;;MQ=0NWl;=?_Kzu_0T=9mLIZ=@eT!oHm&
zn#1xJ{QIOx-#No0eVnn>-!r_q@0?)~{I@JSvcc!wk-ooAj`Y!n!xi`$zG)2fxy%8N
z<4ee1hWP0c<~GVc^~)BF@4dJO8a0n+-6I+<mYt>a1lu^r;Rt#N?RUR^foyWdwx8hs
z)}z=1qB96;9afff>An0*{hTZ6VGTyHi|hNq7?{cVq6>-TR!zR%513ohj2HT1&QE4v
zX-KE=A8pS3A}{TB@jJpgb>>)h8qtB4#h$@EH?<g^8o|L~8(*EQOp3vw`5^9}=0JGG
zk9<@{zstONvpm2;i0>+Z1^A5`WY~}CSp*9K`mM4Zn5Z6(e8s%VpHt_jDYjoXKArLv
zY2qiJ(0+VAqu9L3H?$ACK+U0iLlbj0h4U3`AJ2*%@tA)7_<C044{u&@nEAWF9Z3`K
z4Bw!be*O4=M&Du1@c+c;HXe`2_Wu;zXx`ofuB30o=fKie$M=fIp#vd45qL{@G9C-i
zj`K%;Z{5wY-a&LHl;y3vAolWD{5Uj!$nkxH=pJ|$k9ipPM?YC9+vr~>a9826mc`YK
zKRDCEf2YTbpJ9{wR0grM+{6qt+Z$QSIfdX3c(_vJ2M=oy-JEqMeX3y`D=+5U48wRK
zWX^5&1VtmhaMJ?p)U_|a#SCv>AUO?RdF?Hq$NYKuUi@%*cJ56fm(f+oH=65m(__W5
z6Mhve_=5&AE$7^P8+#CUsvp0H`^wP=QrEE%b*dgO?OMedTB-~D`ob34&|z-bepbE#
zZHU*IL7g7-44mb6Q#J3rq^s?8DeV(p&NV0B#Qyw!9`ur>&^Alo0qvF@NAf#haC_;Q
z=xa59@G0yE_;)i;4{;vj`^>F;XLCozZI!j}|IJ6t=4<Gy^u;YMW6fIkwj697nt$*V
z?RQV=ht@1<+E^JY#J@&9EaIyh-NN1R*fyE0%?5nk*E3GizioqGldU-C<ykgPz4%J_
z&Ok2-f3uUa^j!7IXT=K*_cOMYoH^OeySeV-HKJFF>yvk0lXb4ZUiJ<KpUU{m{UJYP
z4Nmz2XQ!}le8jZQa4)C*y^nq|f-KWKc(2*@#Gk$rk&pCX7C4c0(W~{yxu0!{HSdnc
zywtkbjeUdCJ63SM#UsX{*Dn~}Ec{j856?ima-sKm$gx$(ebEu~>w3xC$4|C)KJ;<&
z6{Nq|x(&r^5gqWr?@AZ4kG&3!T?KQ}ik!Cz9ks^fD#k4vK1%zx=|1$9^rhmG8SF1*
z`$OQ3E$9jxh8c{zr~Luw8#=pzNYH<wmo=Y$USOaD+g0CXjOWs|oyZND{-rZIHNKm<
z?m(}+6TPyJG78Ww=c8L*%X|^Dj=tvlC!83Z5d}Wb6=X)&8C^ew*U?;vE{blqlI~_+
z{*`N#829uIUGTW}9Qx1zp4EBu9%x_hyy4Al|KG)t-nYO-obfU^Wl|)XRXXQ`BgI|v
zdHIlW>fV^%F)+<tHwT^_T}#}q3Yz#KcsKf0*4p}YvE=a=J*jpZ17BW$QS2AQYp4eH
z3b_x!`=iSNUyW=30nd>a{KNpacs1z`TbVQ2zegBf<<S_^&zWuN19%-B|9v6p?k~v?
zv%Zd@A0^(k@j?gd^K8c3TX;#N9G&3V{K}cXO4jndti?*!@muEB?ayNePK@c<!qr-@
zn~7ss$@<;QJJ}*tvR*BGz<RA={iiWLo--bOI2E0N=+s;fu{NMTo~iLzvIV*)53%0{
z3a1hmau|Da@H~CARo|BJ?cCdqNZQmg_IEt(#Nq6$uk+V7F=vH!{?2Q%iC-u_M|`0j
zpZ2r(nqKB3m2xc}3^?%+L(YOz;zq-RS-g^XQQ_z)b6hDu8}yJ4uV2Ewc>UNZv{Sr3
zalGK8ZcFe{(tk>~`?T3KJI#jI5U{$X?zYYlzZUe``K<rQ-*ab)KgQ;xri!%W0r3%<
zOBYwgB9MHbSWhvVwy4ken0`zyh}v=iam3*F*%xO1lH~#q@DgAzct|c#TnnRp^^s(`
z;I>!|azPLoAggY+B^O98l8i3dRArjx7snj_ApVV~?zY$g_#jJWL{65>2){JYgbp`=
zuWt)_A>p`Jf!pPZy#OC1IZt}>`CPxwuNK`^1N?X!{!fxoExj>)e+rmwy9j*+>nxRZ
zr8)C5zCOii2+qDxa1%KjI{c-!hjTB(zIGY$oR>8eMJOkAtT9jsjcUV>3Yx%r$!c$~
z)=Rd(!!B1iW*p_Tf~$8}@34*I-Tw-fz+HkR7whAH4UbM4_FDPBY6p1o|GFKFp~{Hw
z!MT7xH@>tfoY!eIe~sAe;uA%0XEBGGqlV#ut{(6iwgHT{(E;wOJMkwY@^xafz&p$+
z;%XSsMC>P^ol8V}qi%HD<D`!>#-w;l)<s9O<k0UdXP@Px^(BctvqJp4nuI&?Ba=<S
z4)G&Z;0<Icvnt+J$&l2SjqZvVb2*Wdf5PwP8<T1G7ijlzYu`{Zqt})hsmqqX|B1Zf
ztG@~Fc6CI$FZJEa`KHKRb0X~TT5%1>1_r46Ck@!t377b{&W~*d{>y>+O4HNdN_je0
zM{+DYr@sf8O|Y(YHXR)cFo!%o7Cs>klWoWXg^ZskV00A_H&po)dq%#YFF~i`@_Tk7
zzlSrz#ACk%oQejfLIczC(AR)h%IiX%K7QblP%$xBm>;Vw(V*@Xnis_|jjz2mJ%bPK
z(|Y7N@(T5hYyX*IExkWDbBFzW=gq{A&1LVJcC_Wn2cL6&(W@M$Jcq95gAc7TrWnoh
z;T86Z)_^N|kx^2?71Q|XtOM=g?E}|quU9xg`@Qn@lO2f(U3NjA@%KcAB@PR6wwE|8
zqQ}C0-{&fNEPu%5$n4j_t8C+5_~3qB$#Wmq)A`<N-#2xF{0~iQK4dqu#EY*xd`mAn
zvnczw(~7adWQ=Y_clPCB)u{+D$F$eog1yO~IRi0(Jk>U=kaH@>S+Uk)?A`W{z;<B-
zytI2#+TnTfnHbwXk?#xF=U(ZlsIL8h{lL;u=o}cM=$U4u!8P~g0P|Q#+$6;;TK~%T
zbAIqtQ%=2ma_9|oVrR21O40A{rtWQviNTDI&+GJ0elR*yM)0zKxbcMS0(-v{sB0&m
z&cy6xKZ?DZI_=XV2fX0RAB&yD=Iw1CoMZWh$rfDg_Kqs91xI&%K>jE^$Z}xiAN3*1
zJbIQ*d^kGF7*M+#u<8D^c3;MN?iqnk!3fqSG_wM@(0J;sizw#;_Fg&%{RMgt^mD3r
zKYP9&+V6a$K5bwfNmn2JZc~nEv2=)YX>Z_ymhFo3IT5>pcdz(tzh#Y)H9j8=K5>jO
zQ=QAXe?#!`RNR)}!z{%Gb3;p0z-hz44a4IxD1i_8`i)JG%Yj#-yM*r5Rj1_5ZhM<E
zjz&zF-MSN-McR5DF_ZQZb8;u^$I)GGf0O-Po<%m4#GYi&pb(t!9{ST%c=0Cs;)j0?
zk)BrPj}?xCUqO%j^xqf0xarcuaOpL~^+T8BwRM=XcRcv_su#zx*T?tT<EWGUuVB79
z^W52Ol*4}S?#?f91`PKe_`?Ip{oU9v$?u)L&~09xMZq)ZTKkWP&&u+ISzp*D<1?-_
zyjDH3&0b;<NzYov8dF@jCg{CzbG&alOD3y*5A$D!ZWdlVL8nDqtI79E=;v)K0s~JH
zGb2h{s#h57EoodPv_Hvr?^PO+v5GOpUTBbY)=qxT4XC&Z`>LArzHpOpW{7bPA^S~C
z_;ioAeY&&Sf0b!$bGav0bh{>om+=#C<Z`Ft(>>m5+s}C~SbGni#fzVH8)M&#U#0d9
zbYK1U;O=(h^)NOG(id+*cMPtKm9F>2(uo)QH2Uo@x@+uiti1-|azD>xUw{m-<TCaW
z_JF_U>7M;T;yA}%W8YyPFh6oEdr_Q$wfgU)W?cp@ISV_4$I$h?i5<e_%;hL-ex74q
z-vX~F-m~lw?peCJb|n1u^Wes}kdFp!I|Rj=&|VPsx6O|s<H`=95587yQ(x4s8qy1>
zXRF<&6|`v!ZQ4qk_Ryxow5f^qh>sDhoGw;*9e!oq*uFI~h5^d1wqu@n-X1Z#U>@g*
zg5R{K_!Hg_;`_OoavR{y>bW+7=f}Y#=o#lNSTS8c5pNHCD7-t4btT&N2lgiv(|-Vb
z89^somg<?Uy$r$LH|V27`)*^eAV#bXYww5r2iaq2;mk<M(mkBRAbw7?aiiif0{6ld
zz2F|%(_lZcM(2p+0Aq>?*@E4|a(D&BT^Uc>#~w|M_7BVnRxC))R9xgIzL53=^?h#s
zMWG$kQ_Z-my~xs5%u?-ttKHk!>-hrZSmzZ`hU_JCD5LPqi^4tNc(qM5-vh2IWWSa*
zmxx<B?JaDE;ET0aV&S*jjpH8>Bl7_3v5<NOz@dt}rhQEGz5YMot39ZgqwkNf_IaPD
zzXtpC`c`dIdlauMv5&#}^}rujvxcRA*4PHnB_!LOYLDaNaqzH9+8DP>Dx8enC^oQG
zyalaI+BFTnD+CStgk6cfR`H4UEB->9cQM<4M_jf2uCWzWoHf+QFWK(lnbAgeiIG}y
zkZW>mmTXUae{dRbhCU`#%zV|SYCmQu{@OpX1rxsZqBnQ=(KclIxyYp6)Q1+Q87(^R
zt9=^w3|iBVf(OtO917Lp^9~LAkg*G~uBM^q(LNrr7H478(tZ!?Yc=|{x0uKKSYN_9
z_^CC^4mA(h$XItn>?f@K^IhK5de@kc^h4*lG8g}3tWozKWxh!r_p(l(r;aG;Hz;Q$
zK5}|?FEL71@jJ#o+qvusJWe^suzlS^9C+<J?BY!AEx?X^476u>6kD6E>~+0NIa<@p
ziK$-7Pv@bH=gh(h^iy-KeiJjX`ThMmSIE=P9@P@bPagK43h7rHvXU9REjE`kn_5M$
zfz>0{TFP#}3)%%9j>jyfJ$`cn{Ynij17G#At}3C+>D>Fw%*Bdv_*c6v4xb*YwBrzC
zUm?Evvu#tdEWdi~-)L`m<n3|$lrZq@ho{AUt!ov26E)z@5N(kS7ycR*Tl3GVs5gz9
zDsmeZuOHU3z2o-B9^U2s?RNS5Juz%+P784qHUc;0<li&AJhX}a*Rami_5<jj9)LEr
zK_?El&Yj&39a28ME0muOxJ)u;-VS_-!D+epYofOr*ughF!1LaztU1ZWtS9ZO*B5wv
z)zA~|TNh#va)5c(+)T!v#sfU*zHo}MTX+WBy7qG97B6$}XU<cZi)p~uO4?R$riZ{`
zOQxNnz3j35`P`RN{#>8O_a<W;qK@84#z5~1qglT7bAZK4_`Ciu8(ksVb1QiAB6M)w
z?mLV6eg@8XlC!WXjV|FkotGn7x`K6@j_+CqzH4s++c#iKbuO^w_<3wGKknyIRr5ws
zUa+I619~VshI%vAI(KX(HaDxVJ-{F9nJ{(kqAjaxR^sO#vV3;V3Qmt{FZ=8uwh6Xx
z2e@<5E8x_EQJ(OtR|jj$uL;&7VGmr0EYU>VH`d~!@@ssx4$e$F!ygU;`{I9+@#cTM
z0ensXKA*%-47%WlH!A}^(Cwv#z=iUgdQJXvlvjrB$VB>Wm!J80%Ks0QkG+n{QXPsL
zj@^=fGv_E*QeHWAVV{w<fO=H-Z>cK;EGz&{Gk{;cXWv3+7FBTV0)Z`BnLoW^%k3Qx
zhrQ2iuLm~qU070K!DdCMgnP+N*GTt)jiCB}mF~x3H{~|gyg&TGobS+wSJR9c&oF*!
z&xtR~PB1+!#&<!}o7Rut*ZafE)97=i`W(Hvc+T1+{bH=e9Ed%V-W<Kb-PMHO=3%~5
zJs!6)@DTo)-)9d*d}9;$QOfG0{BHNJi+X<sZ5nB?KLvkQV085{9#tDQ6p8-HhNhP`
zNygZKK3ICd%V?+Iy)Dg{RSN7%-&>4)thJ-{G)C(OyPdXzczk%pP!oM@LoQ05W354x
zwYQwPAZCzdd*p>DN*#s_E;s?FVtXWh*z&iQpEdhGb@kMzv6Y=!4Y7?^64w};#(@eS
zyvg@V>NY>%!p<7s2k^J@Ba2#oAzI5d_8Rs<54=5tyK7ieR-9ADN__7^#z^bFfIfaa
zZiHf%rT&k7rjX4)BW?s|SOqz^I~b1}v8pB>H)3_oP}~T`ixzDc{eK0%VQ^#CXYLVf
z1<%~WnHTt4FM5vO)<%Q0!Mcg#DC`S&A4NwY{KT0foPQd(r`ZZEd;^|qD|ku1sEy!(
zM~P1-Iu_2z2;Vy_BTSjit9^li)$pqQ50upPBcEw};g$Q3kpD3Fs~6ZQ#6BYxJpMFt
zU>SBAX_xr0wGGrwLNEVq;sf47jB<a9G0O{I<mGwvLDSMpoJhk@6<F*6hJ_CVGs*Ds
zDtoD|e`7y_JgSHMUAc|Mn#%RQ+NZvN{0U572tMwcg54VR$`?WB{p_i~7#%mU1Bt(n
zt!8sOe$~=tS0kebr(lbH=2s#?+EoqjcIQUUM*^osrd({<{|&OHWHaugKS9nTP|R~L
z=V|TZD!=AOo`PovZvKjnXY@O??=bol_dj=Pt^X74)mrLhofWRHi4iD&hSqS1HLG*=
zy!fzfURM+AXWbnozs379Pi0xgZrMs!Fh^%GN0Kithlc!^d3}@e2F;P7rx<VX{|&5z
zA7khA7V|b}ruLgkgR2j%TU~n$TPOL%uYfk_{PttmFzqqZ`^Dp_oF9YF$rH<kcQASO
zINvQ^zq&S)Z|B0}ETgP7z}@}p*2LbfJ3IFLx;3?<*5Rkmw<Cum&m69lFMsCqhjVKs
z7oGjVs9BHE-ZuvZcRx>?e>^Z^)-lzSF&fwzZMCrje&-mtb2RZy_6%DX+JMc^8-gw1
z;0<h}ew-vD?cmIe9|K<<$Vk|WHa`p8iTBky7H!m8UJp%;zB0V7_YwBGzUpnxBkoL)
z_1jnB?)vaWo`VY?&N61yPchaM5RX$hV>5HF^IK)7UdB8e#LldbIp|NC10T;mzE09C
z-$1RC4CZ1hbMY2^+hdNh==oO0^0B2iASW`G%*{QF<qJ!1sJ#z8C}Y3qg{9}zrcv*W
zjA!$@8)H9NdQR+xbvM@PxypGSJL+SMr}7?SJV!B}&x=Q7Jhx!~bT9Q@fgGZ|9d$Rv
zo~yf|_Ho8>6yqp4b2)ZrkHJqq$2bzeCd@q4J%_CMnr(abm^F^r!!eFq8AsWkiSA*q
zReO*&25HyR*z6;J&Jb?DhIkZZBRJ2BHua812LuiD(xymy;cTs0i(XTvwN{7=Q$^pN
z1`n5$zh*r7(QgO`G!cU;HS5#A`7YmhfuFtyi>>wV*e;8w>4mrPUsD*Xyr!`BI&9av
zf5W<`y*}DeNV(CmoaID2@OcXt(heW}>Y%*f1xYr?;F15G&GDp<*&GMm-e-<dmi9i`
zz&U-aAM$qd+lf3~M1JA1*THT0yT&wjZC0FG*>A#6GEc?Cc-|ph>K^*|;-z)HuUuN!
z$M+S~C;V1l=c}EE&Mx{$vE@%F`OfhvJkHtm!fC=chxw+B*fb}&qFdY6M}DWg4=d(%
z_5bX$Io|~4rH2xIjcR?ccAU5m=<WwjpfivDx7pRSetk@R*a41fL(lTS`Y*?ddf5Yl
z#y4?a^^2kT5N`CoIbzn=fF-LPlri|CF(5wb9KO-KeU1BX0dtz~cH-Wu?8JO){nD1r
z%r|<;f%>KJHXp(hJV_ml#U^{s+eUnH&cDo@tN-e|@UYYWl2iIWVE6y(&)NUd^>rWX
z|JT;fiJgqb`(Mg^)lUbl*y)0A5B;zH+lW~&v3?HIceO+Pe+@bQExr-$)|z?=`h6Gk
z6@@<eXtRg;7wtiJ-gN@KEBb&%f_uTgXp`1p^ig79*?FU9=0ti&px;7|Y>gjv3C9Wl
z&1KA9qOR5se0Qktb;|n&-^;Gd%YH#>19Umv7?5tpm&X}$_$IRl+vRUC>I(0~hPq)x
zk#9b{AL}0-YP-&c@$*ZA|DRr0UAv$TzkKNbbZB@6WmRz9!ug2AMC@OQ9kS@rY30Cq
zBP=;^JThS1ZbN!`&clShKEVDWa`ueDd7mAFR((5&OsBZ6)tpu1f$l|t8O25+_J3M*
zywSBOvvBqS*~HF)H!UUxb~bBgJh8}FBhm@|868(0_VHuk?W?B@YmUMnm(C?7*<9l$
z`J}%JpSld1d4PHfiT~<hF1%CV6TowdEj<kW#UnirJcICGG9Q4B%0HDj7UCb$Wn+sk
zmD+MOdhsWq!NBSw>5rsys>T=T4&b*5dbSx_)&Nc0BzlJY*F-=2koh)4%OvYLaM6dX
zw+UT<_;Ja6;>RWPiC0y8vkc@u#XY+RUz;1;8S-(mVwH55r^G5DzFAdh$hTj7>R#x*
zVjr9u-)sx9&9>UH%~pouJnE{@5RWR_AQ?|<UpUX=+x`Kb`&J*goHMH&9<C30#Ny$=
zaiY&^djdxYr_sL+$ot7OLHMB?cxinzj)PRcXp<LxvNwq~MVK!y^P~CGzEQ8%9c#{d
zt~JH;Ej({R4mrpiJq=uVgp+}rxxh`^w68?=!WRj4Wa}e%(OheNYo0B<PWu$srWsv%
zUSE8!+t0isqS&;_^G&?CuwW-Q|H4ody^7{n`v}st3LiHiXB`4p>iPGP@u73Io6x=U
zF7qMa!;7v`c|HK&l#YjHFm6$I-mFc)O$6B*SRC-8?;3k1IuCHP$J!ehYuSzYIom73
zvnYE5+AGlhfSZ1`5z`j_n*9N@zmd7u{y-&h%UjW-Gy!+s`k_4n(VHgZ5O2NFHJ&ju
z9x<99(wSkLU9a{?{uZrJpY|~BKl$%?UyKh1tv;yjUcM8LeyV=b&2yFE<y|Vgvd0`_
zod*IRteEtfIjjdSYhjbt33DYIGY@;ZY3QZ5(0}P<LfC`74Q{*)d8)8(Wh{d1SVkN^
z?BsT94?yc^CF44cu@;}rJPVJ)XUBCl8Sq(q(EkU}>pj*;d}Y=lx<8B07N7j4wFi)6
z?f1U5G!#2_btpDyj_xmJ9K~;+cTK4F*wT>2Z$}tQi;r76tu~dq9^?ISVCZf1^e=EG
z<mlmx(p~`G?<N29<ayIQru_=~e*^p;{O`ay@O#JL_l|uqVpa!x3NL`$#5X%Ua{;{G
zvo_ECEIe~EuUCwpK{BuR2E3lm0hg@3mOhPzSK0=iZGz8q{AXIhBf_hK!)oS9x=+c#
z(tAnv6uf(&$11}kp3fXxVfnbBA8@|8U$mw$5b;e9MAA*~GxGVwM=HGaqg|U@<PXGr
zY<i+)dpYgRMNWa|T$27#<%O$GR9@I%W`wF3chL`Y`N#8iwEQtnOMVr32fpbeH!(o)
z6UXK`;s<s;`!;PS27$knd|AJ5$@w~PsD0HcS3^$nd5Hn`7kS<VE+-yf1IIL4da~V7
zY^6%MH`qrtj!m=mmqT&GrPs~_=a}dnFW@|=D)hqGwv0Ob-y?1~z?s~h2}YL(-L7aD
z`}1AKXyYT(Fg}98-`3!lO;N*QoUymD-mp!??+gB^X`IpJVqCSClC0xS)`_cL1N#Hn
z6Igp3=L4g(UA9Sid>dsRypdl=e8tEv{IG%V?>!U$tEIu%67-STzz%yF13_ZWEJF`m
z$eFS&$adQ{G;Lo>d#cY5%vpPpp)zL+uc|%E*n`*nBAaaMMlV&(w^p0u`DQew9@t)8
zf}LfOUS9hGlGUB_!_migIeP)O7!S>s&4KjORjznDzCzu5U9s8Ad9HR{%X8t0DWt)j
z?HBQ$J>;KMebE@GV(mO(bk0&fl{1@nRkU#idsVr(Xwk+cTKig8_2hqq^P@c2n5aJW
zI~Cth_!qxy^J{*TA{#R6Oi}SyPW)oocp%GL<0?3F=E>(VGQDSf+$L-XvXS=-R(?z0
zYfk+5`!>pH<Oly@jawmbr81rUG0rK%4&KfFOA7nW!>oPh1A`AP_5wdI(+|(yJvT+L
zxsa_ebuCd}G?ux;jPu}!mSEFI`!9(M;6vu@;aKOR+WR-`_h9d;c*U~)aC4TOY*0iu
z$NG_Tw_yw7@8(RU-(!=um$Re3!+2F)kL?U?4j8SAP1>+d&uXk^Pqew*=YJ0vMIR_1
zitH!WrH|1w?Y-*RE9AZPOQMHHdsPm0IF@bQxOU<@Y}45ZRhPmCKx2xTyK8wy0D$(Y
z^7ykxo>lTp<yT#9415E-&<puZlpi2IO{JdJ#hor})@A>TEkiVwePzZ(d&`etn<6-s
z4ar*ig+0a0Ctag%D)nIB&U=^Hf`5Yc;j+>BWVO4o8PVQ+?#95HPb&kR$hJIUh3Ok$
zYujGVizqc)7w@6|Dr^~K|H2%sVGn7^lbrvw4A@#rzl9ghrVmwT8w22k-EG7>@Mda#
zHY{%Xl4sIPt|l>3&LB?!8th?wym|PYUW(j=-I~r}$r^18q)r_c8H+u2T1IxbYL<Z?
ze0Df3Z+OIep+UIU_<1cETnmg1R{yRoi1*)RDt<|}{~4`UXshOT2W?e9UZEdR_HL@*
z9GuY&EgVf7ZUp!5u*dFE-g}Jk{<eYmcLD5~-{t+O>)B&8Emn+w!J)^~dJ{I0#DdLF
z{U+r#xQwm`Ed4d-Qw}!<)J9LCk!jH9qh8+gj5WHuka3Vc6*|+!V%;X3GKBw1z#l{F
z@znZHVDEl}J;wdaZOUlPZR<^H%RThjfOg5gFSizZung!Hv9C)rJhNW{=dz}=m6lC8
zy2uyu8_r}8#nn8E`m0#S`i`siNZ~P3kRJ?d+_bNJl=CH_2Q#Zm0-eH*CA9w}{SjVj
zMekjm!#B`J&+Y48%r;Y+g^T>G&o*$G;Dq^D68|>4-9>$B=Q-3By{-1A7M;Kc*YnY(
zFH%Nkb&k<>E%h)a@PFCu%c;x3h40&S8iGN}t}0+}it_v6$z*e9Ag37(*gZBh6t%7(
z4t)Xkl8q@HMt;M^hQ>KII8)DMv!Zl>J-*~L>wc!b*+Cuy-gr=RhCHFMQ9h-$XMP#i
zY;aLF_rggBCq1;d_rIRRAH*AKgy-?31iE@R8s{r59;n#P-@=)bQN}{^?=$XN?8$#A
zhdea_p2;2_y#EP&oQ*Aj&bgbxRp%Wg+Go0&U!h#5ZLg{hU{>#)_IORhYKNX7H+1Qm
z`vqv6uEj=|?5IA?eiweC>s8?E9e0X_H?^lNJSx9|3BX$$^VbHPyhiN9+&uU1{bk<K
zvN7m)HFSCAT>fI&B44<VI5PR{1qR@CzE9h#Cu~^U%`@RB4`u9gc~XCDw;wn<FQ9RI
z%gki2*0MKf`%;Nd<2TR3^V$AojM)hCD{m{~<uXQtceDM%n<me-hQz!6%@en)gs)(~
z{F8RVT2J!7a_IA*+k+1YXNf_l4d!yk5%bVi%4^$rRV>)|FN<kI{|;ch+if(5c^*wG
znUj0aSW``Vp^eRDzqxDi)7Ra-I4!@l^Wbm(?WXiarJdzm>uGy~S-x%`u&I33x&gNv
zXSkYgS3iytKLR-Z5^c_X79UvIh$ZLCbT!|seA&jDU6hfFt#|+#Q0aYk-H9?Mx|*w%
zH{DqC2IG}UnQD(mZD|Z-sx1a>F?si~I%vz)`tCww%@)QqzV?S%Yd>zYl+`{_YoGa6
z{Ra4+@nVmq#PYjxcn0K_t{^-~^%!D<z-yti83@87_07cw4j!ZC_SA<<iwnb&t(H@d
z_JFH-&)yk!bn$(5>>O@7?3PbUR{M|H``e5Et@tgKtGV?N!%F&r)Z5)xN=M+iC3lSW
zONqO*sHR|&F9;u|b4*|2d^M--g|xllgTa{^r#{{ZN5H3dd5Ptc3V)lMA6Vl#Z&OYX
z`L=swV^R0UjYabH?cR7d_ut{yz;6S;JNeyJ6!?D0NBXY!%gAe%4Yu)7V9~ydQ(di#
zd#6CB>@h$`(bb*XaB&~~i@ZO$`&ZQM#66LHcQ<yS*nin}VOj0c(ZI)V%j3E1ygxQa
z%<XYtI(MzHCgYvKCEIx)KO5CPFM6YRI(TFHCVi23VByqL`Cu=6u%3B1kIM@V5Do&S
zJ7n|NFg$LnypLyRQy1%N28eB&)<Z7#$>9Dak|Cn*maBn#Yh78k$nLm(!>69rS`?VG
z<Eh+E;;mYCyvBTsclYNZFI2-TU{kOLn!Cgc4?s+^X7BBhhiC0D4k23&7{Oa(h18FZ
z;LywajYE4z8plg%Lly4|cwTijd#So!9vJwduH}J&$-3rno{X+F#G}@A7B*SBULQ|a
zbG}ElkvFSqXP~Q9&zXZN=&|_etCUWqUBX4c=ns?@{j$>!krv+cz}H-&`!Dhi+GF+M
zuj@p+h`+8F8tk<OgPquBgo-JrGU)5%-64FJ50U@4hkmR@Cs9Q{`2+Nm#~^0jop$*K
zc)d||^FEobn$XpA^qjeJ+H|wN5xu^}HAeK>!FLu9Y|qV(thi3*L-uZWKULY;1N_jx
zCr*_ig#)XWbIy+Vb%VN>vk!vry=;QCCRsy%&X9Ug_l_L7XN2sRjM<&w8<U@C$;nfE
zK?dEahva{u@>`F%4yhd1_=d$l=l(VM_M=zQ`rPBrj!mII&=`LM{N`R4Iys*IGtX!f
zXKEXM<-LgXRO(vBI_`c1{wJk%@lu{u*?GqD?!<VlE$ZQ&?2n(=I4SmP>M8}kBd+<)
zF3zqg={~=?b&C7YBk?v_y77p6a_natvtzs6xt-`nthN}~__l7mCU&RVN}Dd_x!NK4
z`WpPg6O1W!_~|Ej@#8*^8skUYZd)fNzNvNba?085UJ^6X<MQMalx?+@GX~Vw?Ysv@
zj(MRK;=K%T&K?&$F+5uYJI*xlj!Qgsx_MH#2cB-AZ45LWT-k<vT>~zA)Nfe6i>(C>
z7ng(2+OIb1YQ7{}FU}UgmZ6<GzlQ#ym3}-**($e?dYf2R@)w(nO@G9l725}F%2#qc
zb+-M&;9P2B<{6By#yxJkpKIy)cDy|JATeCpt>-JSp`XHjE$x4iGMT%Xmff_ebJWI%
z6|2Ybp#x7ZvFeNjEZ<dP=MncKEgUAUfpmhsoT+vjvg(t_O=e?phsQ@>|1u)dy5a7k
z9UJZ{5)Nxaep25BTRY~tb%vmSw|i_1{mhk|XV^Ilys9>|xvxYYKfWJ0St1+xR&bNP
z$w$W90G(*vc%|l{{dcrkuqGKii~C05+t0A)l%3rX`m1j>zv7Vw!ROK8#x~?Ye>bq)
z##$}}?<v-z_!X7?%8Trm@O(V$UGn2z@(b?u?wv!>Kj7K=o_EjkPPUsG<2L&GbMV$g
z`d4T1`xB9Gvn<`EY)O7Zo4bwJlX>U_wz-V{mtDkc2j@sfE1$G~rK}0yb=E+3CvCZn
z^{)DN^IYw_5O`M`ULuXnvL#<Tvh@ewvhCV7#_>L~G~*<j=<)48l}sspCgrw*Hy>mU
zMTdVudk5Xdz*iY##@^~vlrfFok@Ik`^xN=P(BSQ3IcKN=dNAH-L(UxE@APTs`44Vi
zlhmgt>^>c4PepzDJ!J*$KK+h+_2~t!-{tpdzB(TGJkA^Qi$+Q>&@+#CS!U|_ce9Ub
z%{y(>dUkC2l6`IpCa@;S|M~@zH<4xFW1pJUu=pHky7b`szFOa7XI)F1evfY9y-|`s
z<>z9}k^f5x_!{STbKiP$a2Ds{%)F5NW0@D(i3o--1h=*ow2qm3il4M-z4)OG)Pp@x
zmttaw?~UK*r(zRi=~$F+uXHHD!C~Qa<wbVYx4m<T6G*I*LL;8HmG@4$<}GpGA$=?S
z72ut*HZY+313ZHdIBuX%P}-@ZjXaI2V`7|Fqg*ThC*HGvp!%J9o%bHr#$nni-o@he
z;8V)^r8R!DGg*&kjNN;&_h0bCM!qv9?!9>0RKu5tyyvtn51oQ3y}}QF9r5tJ_#MGl
zRC>UxWV?(G9UY*L_W3;qabCf9**r7;sk1PhbVFs#m%_U|WF`9JEsn1f*}h3{=9>y%
z2S2O&EIA_SEHcFl5KL*@mcS$EOgk6XChSmqz!A)&<s;JszV?(Yzp&6fVb&)6C~C-0
zA8S|}mhV*-b17db%P0BBh~_wM$!;(G{osQhc%@C?XpK=D`jSof4)`*WTZmyvJSyzc
z7#Ct%2K|PwYC~gD+z%gKJ?VV1?z!=K9o*=`MtxZ1gKrJT_hSS)I1f5FFFH8ld(jUA
z9b6Op1L_CuZ_nr6lTX{(N71<WMu;Zoa`uws)?EKM=+nzJ)0&BO^~?nBCp_qDo>=T|
z&gOpGkNnMrlg5VO=bF8Zm7Tq!o7{WYck9I_8hUfQ7#uZ)zRP#0n>ChVR>oZ9b(`=>
z=ow7+_qNxwM*axDAwL<dDd|uG2L3~wm18~QJLg#|I#oT3QvOBY1kcIACq`2~yzC3c
z<Y`vEcdsa;-=*~btBk{?__`6JVWX=#VC2613+l1*F7zkL{73l(56DQnHBQCAO(pBf
zlLxJW&(hfFy|bP~>rL9>_}~1ac*Ya>UcPE`;kz{l_-Xlb<{`UGF`8$aE!#`kLo;r_
z<HfHN$If7G1beK_t`C?O&NZ;k37YJ7H+!bIn<ZZ~O_~&*;N>g?@Wuf@Jfs^r8<>-y
zfBn3R`q^h%avtr9kLv{gQTW9?bUxBo?qK|SpauK1XN!*E7Ru;#Px4F8EZUK&HlPPg
z&iixn(w;Rz_x7Ap{QftA+xwW0UhMeGCdTbMD$NO@Wwc=qePM4yI;1t=Gb;}I*YK@Z
z*&`|Y6$>Yd*67^A@$Kkfq-&cg*b_hT5WI$bbmZ?OnxH;R;JYiCi#p_$I32r`xxR$C
zp3hv*i=4c{re#mXX_;v4+mv;xzD+(Dl^)lcz2X}_ML(l?w&X7KMZ`bqKa3tkbgY;8
z@OS(=B0Lu2Cp*hN@Q{CLO-#>HC4*(4_XI|y`;l%`eGq+;ZQc^}J-O$ClT7n`PdYwz
z%<0YW-{1+xC98ce{nI=!@BYAt=rnou6f{<2<<LEyqvQCfN<M_Id_iqBiK{Dk@lmH_
zK-yY&7+E)24%|gq^m)epTs_dGTx_LS51cJ$%*^AvDr;QjQ!_tug1yOPI%)Ahl<Aar
znEVfk{u8^Y)kRszl)%;!bni3dmo~W34K7M$Zqk^ebns9H{;BA<(5tDvYOBWNJz!rv
z-}~s=8Yt%x&XqmPGgnr_V$L-5*E1%$RjxJp(z%>TtWd_VFlE9l=_la*Li_aG)?M#F
zhw=pdi(Y}Qq9jfyBFynVcw&vEc<dFl8QnmaaQ{qmY+CKf5wo?Pi4~CD<}&;T_#R$s
zw(8N`<#82{6`+lx$@BQ$VC>$#;xhWRfc{m0W6HrXZhK$tlX0>*(^5X#*50(rkqoeu
za$2El<AHO@QQD^-pN)?<`#Eao9Nt%h=QN*sXRv>-=U&qo7(dpiJCFBItjoPpV<!Bl
z*yP%u{|?V3OG+;^fqQ43_rhCwY5z9r(;9E3kH{dQCiKYfx|?#;w{-GL2dc3m(9gE`
z+W6#|?(w<xvgS^i-+3;}2THge`G1?PJE(6Q_u{cM&VqTR1B`Rk&yB7s<_4Syf1cZZ
zEAc6B+fTg8<*w#B7y7TCDsHDSvkDn)8Tr!rPO>X{&NWr|JN$9oEuHUT_g%@EtrfsQ
z_0N%;!C6)9qR%;g$uqC0ADT~iVB#m-f3@2PZNuJW7vmva{`1tWF)EcltkJOcPSozh
z@PqGa{8HjE3fh>5YTBE#{+7<|w0*{U&gEG@vs1j?YwKoqs*O*$0>4w6!Fh|Se`<6^
z`Tlv{tB;4MhyJ%G!_5cZDhGDTl3?dE;^NHn93mDPJTCS_z)QE=CHchfI#2N9YBs5>
z(G?h&3tbJc4h{|v4BS#+T5C&r9r%cDH0ye=;Ox1>mOKL9vC6S*PQJ<+^R0{ndsx=q
zg>Y}Td!m1Ep7ets_o+I0gZ!3$(<VCjC+dA?V{x5)?eglgCjCf#EiiU}@SS4LXENH~
zpAEjwH3ohGJ&on+T$h}7o!54l@8m<-Lmk_xJ9f7bQ!G%GGr>L4l5yV2gSI^u=z0a%
z_!F@4BCvtY6Y-(Bvey`;{gbgbh%(>sf%mszU+l$xARYUd=v-uG^ov1siz|t35?)`U
zn39>{_5Rwq`O`wZW6@QeG0lppm+X&Wjn|R59b<l@r~OvODsM6}Fa7DIp9APXnd3}^
zuT0sgM89L!^)aq3*kw<f7MK$z_V)q$){5=QVSEo=@N>)QpT3v9RUvk!@LiVg+!5eI
z=lyo!2iL%vID(fCq3zSL>59$<$Dva@FdAPmd;m6bg|Awpv%%jVWeoT@>*g?RDXd;!
zdlCCBrLxoFe1WDk&#d=Z!*h)Z{nEz<zy+%NpgrE5oWWQ?n=YnJp3wT*7~_<KeOD>=
zL03*8zK$Duy+iADTzfTZ#l)xGg+Dv;&_GXC!^MX;x;hR#W^}1O7qK!HL&Ng2*iYp9
z?hz#&2br&)NqaBWx4q1jF%18AZ^OkiSZ}9m(}YiH)4|1p6TxtNPD*L3;!m^xF))g`
zL5DuGm$pU!80=KPbIti{`oISlut(PmfATc_9+(1OO`NL|`mH&+XkTHt8#sIop6CGO
z_aonxx*1bsJ1_bP&ELVr#sD!0x@zif?qq*GEm(I!r{2$HE(%y<@4&b860gJuue&}C
zT!$`KGQGwvAAA8Hg#MA3<BUg?^3@*CAA+446U7}Q9%vWeE^_jh-R_;#yY7O{UiQ9q
zHiLXC3yHmT1?8X{ovC#o*q6RfFrq$xKpT?#-40&-kUp!f;QE_m>bqcM4*gZ%S<mfz
z;N#S1#;;j@ETrG+Z~6M0JJnyoiuzl&{({bG;;E2t(KO`x_N#-jP1g*?p_I+RH2k;y
zyet1`;ft(?IzRid_@Y?r#EVW;{nL4=y{wN0#!R?T<MuvduXU3}U!4ArrJrj1UU0s~
zOnoT*Q+&LhC7<w;Y<0d5P5C4CHx_;ZpWM$JzAW2O`le?d6CMm5*Z|*r!rlb>D&6H$
zz7eh#-nMLez}MdfZ&mLvnIk#Pp*c73Of*M0yh`8Du1zijA5?F7@ae*EHS1t*Gjt5v
zlWa2*m&H7hcPg|GAiAiS8AkIs%4mRooX6FG?uhQnMy#6lezd-n{P;C&bXmNF=u#VW
z3!6vI{PFlJhLxqA1uhc~8+lczbGk7yM11QdbGbGE?|tsG{OH)y`iNN`fu~p5z3vRf
z*PPj68f$8PAGTs|`GHO56#hIl1W(XaMj2_PKH?Xoa`s?a`+{dHJDImb+S^$P4=)?V
zYIr;GOy*U-PU)FE$dZoS?4_NI$qdf(u=Eza)DI4vp>sf*@Lv<IOhs0&#O`hi<@Can
z^}DC}kJ2aXrqZ-0uXmmYni4S=#gB@%X#O0VDEK6Q^&Pi=SG-UL;|HAV4#F=+p)t8z
zjTn6yP}^uH^wE>hX{($n@*2cUAHi9DpHgl+b1~rI%%R-Iz;SFTmYBep$=NA`@%h?)
z09z8zorcc*8*p^xPC4&hVMb)LB|gq7hw<=IR-xfZ(-`igJdd|D&ErkU%>JhdV;VWP
zsh4u|poeO^_@Ygz#v<=sMoe%Z7}qoPrGa)N!&Ndo10PmAIKh_s>jmypsaN_H`HOk@
z)<Yl6jMVV6)YnaY`sN^g5sp*c8Z+<KK&**+RVVY_EFLop+r8v^)sB<adOF1x%5Fm;
zSG6Mo9+Cb~?H~q1xSqB=MO((QmfMJh?!ms=Wd0(WKXgQDkJlU<mV8mow`x!1o<QsY
z+7rRo%|-rY1x9mTzR|oEeWdcl>p<s(zPpWl+Ph4)uTWdHW<Me>=K%EY)VQ3gOY;=x
zr(En~nC;_8TjRl5s;|1nhly*~AEDiwON{e1wo7Th&zu<c(Vl$Tj|{r46}^et@8P*%
zqm{Nyp#9m{vC5Z!IdHD{WTFXGBR!WRt37`3ZTgR_RtkLkGscHEan-ruCg+A1@aw(x
zj{D0^BODzbxc_G2h?M7Zo)NxL&KcsNq%*|lafWz#qj3n|?k5z3SajY?`&e&>d>P}|
z+V+Mo;0*Db(aYc?F1y=9n=Sc2F5?Zbr+aFgO^u!KW+DAb<Cn@lK`MO;GS(jCmDJi$
zOnyQh`XpalooTCbkMh$wjv2M*#0~&wXVq%GXY}{LXOB!z3#ZmjkKL<$_<BFhe&uRA
zzw$^=@fLMz?zN@{=cOF_Xrp*LgY#>1{nHtvw7UYG$h6Ip#m>T(^Q=GkJEx}@T}Rzx
z{9BnD+EMWsuzRDKUXjarWpA**&wbjM+SRelJIt)nuda!WdG);5=-RVmV`^8$GGE2-
z)s@-5lR3()Ju7w`o76F{PUF4&!!r9fSkKRnjkcd<@(t&kTF*z5|Cl?oJ(IGIgX`XQ
zk3`lO<1Zj)l=<xW;kVK4aPC+Pqrm1$V|0HT{hJD&a{u<c@LincbuDY-Jo><yV24_G
zzmfNQj4}ONsdH*WZVb2?ILde|Gsjf)n3-uQ)Kg9$^EpH8M&8XeT%mk#D)H;s>%nJ?
zcq^ULDDQm6V=v#y=eh%0yM=E;{4{1dtF{GwMaCb_j_n0bbk@=q#w(+CW$ZQh7hq_~
zs0C+-kAXvST^ap5nK%3?*Bpb#TEIKW^embg(+~Pp@1iXo^}d}v`)DKdYF>&(uS5q}
z*E8_Tw&_5sza2W@hYnOjmw=PZ^xMDvVtVyTSk827-h1hDpWE-3O@W_0?@*@RCDVdJ
z=HH<;T5mpnQM(?|5Yf4#(76uk+DctDW=2{$bzM$fBdb?~4@V~I>W4;dh2}uh{8nAO
zD}P{f&SrQHXwDeHpXg&B?{mRjM`&LKaRbw;LosYF`r+x87<Rtixw*0j>JReF`4+m`
zTxohmR|iTMXU}NX4fw(^Un>H)E=nsl4(Yu?Jg6w^XC7mlXY9S$sBJG2{#E^qBX$<K
z=L?S~m#y_6{H%P!(bji$5ldGtJth1F@>;I{>-dBk{2g1rCvqSAqM1J}9vHnLqdCu&
z`*Loc`}fYzdiQhQ?To*((!U_RKPmky(mhG({iIzZt+K5Azad?alzy6YNmBYb(#w<5
zzazaNDg83(ok{6GlHQ+`{tM}zq;wBy*QlZT|3<nXDcwi9Bq{wS>E%i3w@GhEO20>X
zXHxnD()*Lre<$6Oly;R+|LCFmhm$TyN~e-8NlK3-y*w#BhV+J{^f=NxlhQe)_a~*l
zNV+E}T|nBEIaL3bNEalf{iI8h(r1%io|HbH^oFGLEYdrZ(if55pOpRz>7Jx?32E1u
zq53Z+U67P6CtZ@1zMS;(r1WCa8<NsrC%rQ%eKqO*N$Gzk-IJ7FPTG|<RR8s)3zE_`
zq)U?0t4S|UO5a3!LsI%y(mRvV>qzfUO5Z`cCn>#wv@3h4{<}#RB&9c#E=fw?Lwb2q
z`hL<I66yOgzejp!QhGb-{YmM6CEb&h-bvau)~Wx#%pZ|1NJ_VpE=fv1MtXTt`lqBf
zB&B~&dS_Dl7o_(mrGG`bCn>$3v}@c@{l6hykd%I!bV*YBInv9M(!V3UAu0Vb>77aG
zKa$>`l>Q6po}_dSY1jCn`u|3{ASvBPx+E$6Ch6r#>9<L5NJ_s)dS_Dl1Je7G(tju2
zlazMNqy7n2{lc-I^=H~IPhhOCKPNpJ#j^gs7{9R96aRx}y+L<QK0BMy$)RrgbMk?A
ztv_gt^#{*s{lT|c-y=U*f9$DPf29O-(w{4SF}m%7p_|s<!YT1Pi)iq~sn>3H;=?pM
zzf&K4h4uH)*!UGb(fZ4=3pnxjczf;}6@Tuut2Q&9hNrOFTRJkH{=1!CXy+fa(@wkN
zx&G(>t0u=w_<z^`Hx7cH|G&WjaBlrAJm#$YIE+uVLESVKI=9p9M=8cT=E4>`k+?Vo
zdDzWJ{&T)gDyYzYA1}yBImMIFxt;N`j7}<GKP97cTl%q#b|P^(wP_Bn$+L5q##M>D
z_RXoEI29~Oe6rBFz1Dv8`G&<Q=$nax7CE=c1uZ)5_&NnS%`lC{&aG1r17z2dxcsAj
zIc+eFE1lb+QWhmXw{K1@#mRc3{ho@Q+g<jf&o??wL0b|9Epl!h!lQx~wK%D^p^VOL
za*d}SMyE!ny$qvs>lE}khOyRe#?U9uT-YxR<J2*8vK~nEV4-vSTl>-H8#5>O>q7+{
zvv1%19~JbHo%_%Bb-1yPJ>h~Dr{Jjl+-<CLwK$2R_CwRS+P+I%PVKRi)!{Kl8{alY
z4-UF>ZjWCkw>WQ5EL(q{W8|Hz6NWx<ZV4A>{l$mTN#zY?bZ)19ETfZ}F_h7{o&T|n
zPO5q+qjS6EV;SSk82W$ez@*r@ixLGba&DbE;!y9T77k@}ZX1$nT-4&E?i|YK+$J~e
zb1V<L095hTAIoE?AMv|Wd*f8FEAh!f=k{^?(dPqfC-<L+3UY3LZL^Q2vBJ6SwjagI
zc2YmE`9w0FuH7%$)i?#3#<ia;#X%Q|!cOh|F`Hq$Fww%(u8UXgieI-sbz_Ou;*_&H
zQO=@H`}W_59ytv>ni6l2_33E4&!~c}KggSNJJo(<<twxk*AC@#Zk=JX@+JCe-<;az
zZoB<2B-#~p+U1mE8t9Tf{&#9A$Lvx(_9(FS@l&$?oQ|8uw-(wR{j+@~*Gc;}CDDzA
z&Mih8)*l}_BY+*3{b-@n*_A_&oZH&Oqs7kcory;ao!k2oj}|+(4<#NgbZ&>n;9K#k
zhyI^B1}S#mhsNMK&ThB<wDF}s)41*>`_=&w9$jTu>vV}n@$5tYPpvD@E~PY4@b$0T
z<DHTi-0Od6-#$L{=(qN*Goq$({nSrXfBjI!@w-#2Uuaibov8k_JlI}4>#Lvtlc{!(
zoYm+u&Tnz<Z%lyeRae<vy4JqBjB{I@`)?<DzSJ3n7m~7_uAilLEmtLKyXJJC9JR9!
zL2r#S*3ObOjhY5~%(vNB9-Xe>lb<N~x=$8--6sn^Ei7T|W&PzP2IgMFxu0r3OE>N{
zzUw--<-4wXQ@%Udd0J$@%}#!se(&h-dhVU@UC-${RA_&Fu6+d?%&>2rf?4{fE5(`p
zXrhz^zMPyG+|xp*v&?rTK3VA8K5jpXlO`u+Bs4P%o!b=qQ9PrQ${xz-+)hY5`j&IM
zAn|CSb4$Do>+f@nfz$fQiBc9hx927vRXevh7uW?aa&8~D^)9AS{gQoqbm&n$`_TVW
zu|canLN6r-Z?SVbRLXTj-^cGxEyd{s@nEb!gc;}786}XFbDKAm%ei&>M=s~KXegI+
zJ2b4<pRPse_Sa6Gupw3UqqT{G7dp3F5(BovxxFv(XyG>dcBuLlr>lO6U58UAoWPBC
zDYc1$PYc;jDS^Z%L8o~`vwm9oKHC18U`^JaaIAA*lqmVMjd8Mm+y2DjP;jQR{+wok
z2RiLX_~}`HJaXXj)#Oi)+KH1x`JCIKfxb3g#?b#$A<t>mPy<#twK)}h4h|GME9>u@
ziFLd1hxY9*`}+AfXQ!ZriGmh6w<)&b_H#5RV1GT-oEqo$TKkpTXsT~<64i-^o9j=j
zzHmx%K7!l6(f)p@iKiX+we}}?yIOxK#^@$@OCpu%>uFI(lU+coeFbG6uy0QeJ&IQ{
z^#4>a_+%;9x7lBJCQ4c8+zu6dy>n|MTD)+mmiXPNbxpOiE*$#AxqZP_hBL>`?NR$t
z9DbbCOSV>>jLz*b`_bnEG^Y_V@7AAbEOKt0nweOqI$~Jcxvq6?JMBlp2F|_H6uyk-
zANqglAe7qm5<SE&`Lr{At(|pk;*+IA<;U;-Q7uECT(`~s`iJ(_ZEQL{%rCGrznYkz
zYG-KvoEVzw)3xT`?NVO1uVA**eKOjvFgsE4RnF~w_9K^Zug7W3ZxfSpuMM?B6`VRY
zh4%MOIk>40WscvS`pIPblj(`p)XcDNiBM$yxeZW=lPF3&+;aLcb_#VqLK2#9f4{)K
z^2oVen0WLp=k}_^qwAep>}ah&K6Gw}y8Es8yP^N5cGszkh(1m!1Z%SXhDtdt*gB;+
z&4fkyWGUCjiyiuZYFoZ-SG*<BmeayciVX~<2?#xHk7IV}3lg84wtFY-PtxsAT*i4V
z&izo$HA6j%-<{e&r<kFdPdg+|EfW%rT{zvooj>&GbQL>jGxqsEA!>~Emy#a8evWmV
zXJ;)M`oy_ika)Dhxm{>Kilg#x+Nr8U#?wx{leKB+6X&)&@o0r}`+DNhLgzMWKZ>`&
zNv*ZFSfM)3?UuwYt+tk&)P-Z5kvT1=duqFe8>4^H&|tPWbvi{k&*KFT{XZ3uw%INJ
z!BD51+t$RRYj@eVFW6U$8Fi|RB|mf$27W*KW3mhFo#$Ql)%w^;JZ?WEpL6T6$H>a(
zBt|F3a-nlOAvvFu$Q#O6WZ%vodbGg4T{86OD*Lu-=+Q2F>-=&1s<zp;FC`vb_qu%>
z9eU*4o|~A@Yn@wXUaU^Vhi2&isgp9@9+aZQ;9MK9Z-<)siK0IT8*$X0DrZU%Vja5y
zr=dI=YFPa4)aF&$b9<wGm9ojX|3PBjuljfUHk!zGZp$(I{$wKCKRJuQX^1$aSMABT
zc67W2s8zSww?9lgs&Q_2B_1vPKdikESZ>)_AG$x_ocU%BdxkSZGRzD!Au}W)2}UNO
zA&Lo(M2QmJ-v<*v<}foP{5hO+&|r#69FieQB1Y0V3K~?}4;3r5rxq<LDy_7o5iPgn
zdbt++a9f_|^7PVs=`GhwTWYz_+;{E$`@QR9Z(w~V>6vF(zxA$n{oX(8&t7|f|CRuk
zQObuYU(c_ivSo#z%O9a~ic${3gz{KA{AVulfE6mr5ss<oPNZ)C#uGMyXqlV`yw~KF
zpwyH3Wi&8FDX)vLT*v+u!YUQLN?5C+SD3$9oyac{&Z+3e5W=;??Y!13z)3r4258H&
zI4?ho36>mL*3~`dU2&47pDbLWa(Lk?-O(ZH-v!*WB0F9YijUe-!s9O5T2+soXX;Ca
z_z(u<B}J|ao8y;gYfWvvRF1)`)HxdvHmm4%D_}dyQg8J2JS&~5mzx3PGAi|kU(ats
z$h9I*QV917`Qpn*?hCv;7f@Q0e2cIWqEL?&yM%5Laz=%Et`S;80{3kq84R73Wqk<0
zNnONKLM}oMOUmm>W2M;<>T$U@gD$+*nSGMDLPynkWaMVJr(JHI0D1_`ys-nYPesn-
z>k?GuqmSXgB3|0A!7vW#2s@YTAykjGOBdmZigJXWUOJsCi<eaS_B^;B>;fL4Ebiu>
zM14w>A@m+2xASDygWk4_a{xNg#YQkN4ABV6Qtyke=UEw5p*)R>9J7Dp+ZRdMNv@&e
z=s$^4M1)f+>L;90Q6J%)if$3waGevGwq`BMJfLN{Wh07EJT9`(O*!@?S)314R$+KY
zed#&`JXKNP@}&yXV_2t2hHw-jGX*nw*4C|JvD_otB}+&)!<{{cJL}?}0Oy)=J3~!&
z>2O(Lu<{Y|@SmKc39Bn9%GCn4SW!FRxD_n`?paY9?}%+iX*R*wzxdptN7j6X=B=$v
z(pH9MX)_vC)*97=4B;|Fk>c=MBgaNjM$(wGiFZyVz0D@Q&C=T~%}kb%{zdbIwI=m8
zOIYY_Hh-SCS?7L}^tPi6;gV1e)XcyL-j^*R!hMM330*buu~j3itcmhw)QBe_6E?!h
z0<}5dd8@Vzc=C2H{AbSkv48Q&6Q8>!-j{pg<6&eRkbUIY$e00!Z)Cf8>-cb0WcVSG
zO{c%y^IUp5P1zLM9`tf-qUbJ~9`;7P&&s>k*iL!v6G__KlaWlmWIg;>Kuggun&PyS
zkD@*8(I6!|Xeo@NT|Sm+{<T#{Wno)A#+GAU*cKn`!nTo`h>Ig!*fxvdoJU#M7WJ}!
zUE^Eoy>aAmfG4oJLLo<Z79$u6_YnR*N_ii^kvCl?f1WFwuBY?>t&bJ9mKde0)9*P%
z<MFu^lvX0A=Tfk-3Q85BowU3iA#IFQOxLib?hH+pX_a>(n4)I7f{jgQlxm{ZP^oS@
z&BjqEJuXwiXvq9Eg?Vp7NLodO2`EOXsWYuYV@D)H@o{OyST^ZWbza?*OSK^%A4&6^
zAwG~swv0g?#QKp#(i$LVxQN<flUHskIA_x}Q5+)TROO~59SJ#mMT>h8C#`6?a`N>A
zIEGQ+nv{*St`a`eVIv!bj2;`A%dbOR>Un_;A9uww9}45C4}~q*Cg_?7Q~9`WMLeO3
zyJ5yP?!`spe@=QD=t4VEBB^K~?tv`j-8d&>4aH`x92<;ri+DmW>HSQXy<YXZm`^bl
zmSrf(GUQ^}hY#LcB29TcrUtMcrF;tbU%v6Vd@HKmR+F$#MFHW2?fg5^nbo_hIY7uy
zKFRTske5?&hF4VX#UiT5_SuS3I-0MHG5@#&nWHG?+7U_-mE$v9rzk}<hjqTF2a$l+
zt3xZ=ep^I8QWKTZk*j9eilR3AH@?wrA@+TgrE(z1vvLHXoN}8It3>oHZG__F?0>2}
zK@E;)?I^|T&cul=V1msrIGBH;wU7O<)+V?eFlR-Z*sphW-wyTxIg7(ZAJN*sanI`$
zZsyb{_1t;%kF&@%d&7(KghJ~{gyR0>5;+<;f~a5;#<vlfmz6aUVKqwGF$MugP=*PK
zZzIw*>S+J|5BG_Vh%Lge*QW|hm`0Q(-V6B^Ob>e{y?F%D29~H?5UVl4InmF(k~*KR
zRL1Pfb%RIlIh>v4y`+TuDjFm_QqgU~a?E_;BIG$+xH$QzbP?PpY}H+6ka^_}Azble
zYZ32p9Yb_eD2urJ-G=G{;xd;S#+pW8Mn=pC<p~QRgEeZ5b{5eZ8Sw&SX}LKGKl+lV
zWKnaIBivC@-$?9iBBqn+avuNE2(V5Eu*)u;2*nrB3RKrn${RCE@~muFVOgFPW==G(
zI(J{vuc}9bgzHK^S(0aE(+bP-tXPYaZi^Eb&{-YW=kvrXkjVzbGv__*%;x<F#7nwy
z-*Bbx7>uVV<u!*?o|SSP-<*qQ7yUW6WII}}i8|Ti|3D`kn@|Ux8{`Ry1NB9Z-3Krr
zy9|lDmDst<>|(|qqcp34nEO}}YjYU;!<Oz7FB0ylC`Y)jqD~%Pcy>v7FS?R^7rked
z<z>P-6?MB<=AmkR=}!9MWNE-r>qw7W&bii<=;E}}iZ1++eh~xGi7xZ%*sHFLY(jNk
zyY#ra4B-s9p=ZfK-bQZXOj*S3&P0Oc7FjB5A{UCdr(~BUHSFAIlU<w(G1<lW%1SvL
zs!+$AuUSt)bwRtl<Qj?%sM?G<9Xmu94@s5}jHdH0JKS#Ue&*a`w!y!LQjXw+mc=<(
z71-3|Ti(KdMJ$37c6pXvf*Qc~=P2qO0_=O2iU<!OGEbm`JZr~RG3sIe#;?n@FxRc-
z25HW+INz~S7jxQd(xlm~jjS6P@%B3ziF0i3m-+za<jPj@j>t+CO5?#g@CHgztAsOE
zD2-YjaDzHJK-i|DF2bCOay@{3DjFahR8be9&BK5lq6ozY>TA!#?c(xqyB_{+sh|CX
z)=%foKtE40CCa=vwmj#ejrS_zQw8xZX4r~NBAqLyPg87ehtJI7lRFf0c5@=7ydlCG
z<h0b2w;tD`VzcUeN)&g(I3D-G$moJy1$W}3FR#QT7r~w6NIPGzslt}gpj$`K2H0*z
zCs>bVy5NFJz<MhR0DG)x4sh9uW|6oxouR=IV4ZGxK^tH<%J80_l?AJ}2DoiS`+(d?
z<w8Kn-7sWx&9kON9tJpC3wD2Uv9u&u`jagEE*5qf)iD`Z0o=Bt`)3(UvN*33^kq^F
z-%PUH+(GLeN^{Rd>}mRL5~d+CYQ#NOjc`^)U9MoKV0b~@blzCaLUmEQIIYmvssjIs
zo7CBt2wMu&_*FXHR;>?k%8Cfh@6wrna(qhVS(&wZQLFtMzw~Tk1@Z!6-T{bZ*RE@)
zpO8nBwD$#h&sx(n&*mxNQj*P`kgG~4t^Ekay*Pvyjk@@6(TjEU;?@?RCBEe%9t80y
zN;$VJ0NPVRzl&uNZf&Z2&J%Gte62tkzL}Pl293!%k;<UTjZYrxxV#-lmnpT<PdKNd
zTZ9`ba;9Mgs<z93%NGt+4PO0{O_y+7MX&C?JL2hnPgJJ7SBoXKESVv&jG>I)C^CcE
z!Wk(oo<J&}No$1h0A<vjwVb+^ak*B7z^1gz?ODLwdl}$u7fUr*1~pBCblRqA(8W@R
z-Zo7=NtT}bWih7_GFEE_dusrjP|7QPHO;`ZD*FQ=!!T@2(2C})w+Xpw)138wJ$}-v
z9FYjmbHI*}^NbYFt%;)w;nt#*H>ICv?SD)lL!{;`HXf8AgPgc2?`1;HVWURO9Ecjn
zU{%LpXajItMZp1JnGQ>k2IPpzA}4HDE$1=#ymWGsF;IETNJz&EXOH##X3~M1Ur*Af
zbQSi`0MZe;yb)gRQ-9JY=a!pH%Jca-I1uO@%OxFn-hICW8pabIepy-2cn1~}@ea`3
zDCR=gmD7h&hC)_abRG;4<{&ES&`l@S)UR6yfJZ1FkrT=F)K7cQR$niXzt849<R`6p
zx<$viU}W2`MGW;C%WJ88e8q@fe8H4@qQ{u$(OGspk9Y+#=}TzmXYUSL_toqdQ+cMw
zu9^&CpxF{V*GxVqOh(MeWFIEXSw{&ukwt43tqiL$L>o_rkOM9~FNua@FIuixMlpK4
zs>|lG4AGVjtnN3>I?vp1%0=%f%d!o~{E01>d*|$shsapL4tf79x5>iIwTPEBnblF7
z1j6R}$OTC_VGBgj<3-j^tRi9cH$;6SMOP>zFy4S(MV$WW<Qlp@;7yOG<comP6wtW`
zz3I^bd1st7QFIJ{wGRdKx}Xn5&2UZoxMCWEV;+oMkuN=b{>eOjXgw=-u}y(3t*OqD
z>8=$m0j^q+i+Bda^C(kZH{q&^ZqQb{5<6ctnnmv;W$7Y|^|*^3%g_FV|K#lB@|eNx
zXqOz}zKWb{@C0r#p(S36bBkmj#v#94apL9UlP8k8q9}u_<dS=|I8hO|ZPj3@w}CeR
za>>fwE1|X3y9+IwvFs5<T*Ad{WazSoQYH_fC3fEXY$bfTa1QXxgwexmMw-P}!Z{W7
z5-vb=`DR4!HfZynS-1&jl)H~`Rz(+1ITF*2W!r_2U$!Y*EnzMdsTJomxmT4tLrB6)
zrV~BfLGMFlx$rp`yHNF{_%3CLtODgFuZz)29aI~%%Z0OwU6{XN?Gg}{mqgA=wh5~s
zDlXgPmfvm)|H*NUkc5(L!b0wgzZjK%^9xZc)X57E{P8X{B&Xwx&wKGs<A@>b#LA2n
zmgZUEm#tp%RjnjHLVtem<RyCvyU_VsjXNN$J2N<})mufvW)(T-Emd2zOF-DIA}0$~
zd$dbHIIJQk%NSHwwM#&_uA<(3K>JmV7oLNeQxaR23|S79I72v6%GrG3ZSTdzSrVTp
zah9-AiThgt+pUOjv@A0JkUS@@7?*z~Z_lqn#&1w8Y?B{e3jZ-5g>6xb{mW;^7yI8q
z|Bu!G4#G}&A!|DBkci@b6tU0BZ;plkY+?oonIKt?<#|^4U7zye^e(#ci*U`#f_wb3
zOcC)rGWk80B9h+~3;)^guM7y=(G=cQGs5*kAuHPu3f~?ehekxq1i$+;<YT1<!)3gS
zjhuuP`DXvd2W$k^#?=Ams-h|b62q21LUAjcO0CvcLVg9LTr&t4p;g>9gWR3UogpkF
za$g`w)S^ULLV6}skg$;3{h7iR+~suZjaWd~15t6&((INx84%7r5GCJa5^xb^#LZed
zt%|OJqq%K0mmwsJ;dUpNL~BZvB_yGI`Dd~2tSU<f;k-uQPsn(UhaGv===UY}!raa1
z*{+%k2#-|McMO=m%CrXj7ST#8BD7yD+DBMtwfH5bO;&Uacxpvuh_zf}4k`g_t*8#L
z!HNj^?Uyp2ThZF4T74scGgfrYmve5SwM=JIA0bm5?o+NYZADxoHoghKDJvqp3(-T~
zg!kOI{07jQ59BGE)3#x4b6M|3ADWbm5YnXVZ-mUBXfa<*mWVjR?%BL80WMn+Q_1{E
zN0*Z;aB>S}5j!r2ph-t3AUsr2Kj8^P#qB}lZd9TS;gO1N5*Bj1_X%=0C{dP>&dODd
zu#o%WO_<A>-1W-cK{%zNKEguojtd`Q#JTH~sFUzOMZJWD+?`JDW)SS543`xvq$*-g
zFfw{k%*=zy4UNHht*1j359)SE*zyoXy@dRh#AxQRwt7t!U2B8f{O(EfNSrkM0!Jg8
zgzW{C;kTPt;Csu5cOX4Jx0O<Uv!dZ6ZicIG@hbl9=l}S>%CEA$`DQ9VT_zuxPRo;1
zHuIYapNXqg%GajXy|HFKalGM8H&BmXp;&#Me%Tw<@}=z0Ous~}08YGB923K0e7Zt-
zRgdjC=vAH7%gG0r#r}ymT|tc=Xg*{#qc3+Krfd*x^0{rc^*nDrmpz`EPP1_sN^c33
zkY}sL=DSckI~<hG6}F}&p=lu+rF0doW;o*i;wR8b%tp>Tnfsh2q$y%KkcE>iT#4k#
zVeW)NP8p^{gsFVo@ley{`8YhEvg>IPaLbCe0r#w^9R5_IlpTT&+(YI>v;=6g;9TML
zAY>MVg*lkDwsrvbt%yk(wdQ94=~)rm*a!$Gl-PO8G7nWQez9@@5q%QT7<`$s?zsl1
z0;<E><x{RMjfpP3t}Yy#J+%@Lwv<PmW%3g8+eC}In3H=)xif?$lp6}dLT>lPd>5Rj
z%IzE}ez$5l;!2zCqvVZ}>1QZuL(7>R1D7Y8$oTqazQ__Ty=qX^Y7&DwKn7aGe2h~U
zv5y=hAt#y`=aYFlG;Dn(-1a#Kdii~C_G>AflWQD=vna!F*<)ovg<tqwo|Q!_d_CU^
z<DKe6ZU}G~WyolUCPMK6YJ>8)@&pXVetDg9Yhv7$`gM{4A-{Ok%x1K<p)78t@T)5A
z7v}}_AZW1WE{c=CvdG*0d*8r83)TS#-=`wN35YKD@M7)^xrdZHLs-at@mju^J4^0i
z<<1h4TatbM3F#p5s1kP&TH*`un&|Ne(#lNBw-B6+k$NAEp^%kB2z{eDT_JzuyI)R9
zC_X`RW!PL}nro)ZOi??%U&7WhI2~zKnP&Mqnn?Megstf_T1}?8Dbi}0-Y8*f#Tl(S
zqb1)nV~U39of2(5qty^Khgwb3TP2lftw#CQ(EE)Nqqb2p9hQGqGW{X8*PdZ(F={PQ
zE`sTm61H|j>(P*{;*GTV+9px0n&yvO*>UGm=fE5wj}zc1GaMJ*1;u-DX<V{1$GdRG
z%gagDs|dM#lP^+me-ds1f$XCc*9iN*F|s2!t%QRr3WfmZ-mh9qfc4*`q6pZ(ai3{^
zPt9itX;aoAA#F-B2xruMFCpD98&4+Bnsv&#tm)LQI+Z1)C-MZ2ke<j(V1za&{e*PG
zIF&ueseYTI2wjw^9d)XMke<lZn~<K!gGoZBN3;kFo$5HpDd#@LOl_-EorLs6J~~TC
zPf}hd;k*vtAYq|Xo#!|;=*rYR%*-W}518+5GdExqETiG7Y3P!-2cf=>@`~J1ikQ`H
zh)az+D>V&~8{r`@WT&JSEf1LEUs}3Q5G1-#(i87O!Fr<0CM3IwmQzT|pO1USj2<G{
z)@MqN(4sz5aFXbv5-f7<l7@f_&028{*dk_+heVsV;x+<v?#MfK31<q_W`P$AWW>vm
zNmoJ+sj;w)X69JbnB2QMD{nG)mAa?htc?XK9bFMtz*ddA6a;{bN;ckIh`KS7A{qo7
zwxa#mIEz+0hP(%*h$aAMt%z_DqVPT<jZn)q<e(F<+lod2ZDIl@rc4tPQ~=ss1%%95
zXp<Gr6mi#;Kqk&+>((f;WqrCupDgh$7x6JzxJc#gk!?t@ofx;{YfH3}wr;y@aS+F0
zz|2D8Wys|Fp9xnA)Lhhk7*h`WCGVf%38NZgTBpPOsUAQMw`|ld!%TIzod$$G5Jfit
zto2z%!of3&tj$?P!ud0btSwqa!h2^FS=+LTgxhBnSv$6hgcXfZCZb?itAbQ!Fk$r>
zMb>7l;yhs0H%E-7FJLvw$Ovl_R*`V-jN&G0+g5QG@W6`7za_F)k5cRswy3Cg7I0og
z0pW^@oF^#G3J#nc*a$glCdN#jH4dC85^~fcMb<cQqDaV5ixgSoz=<LuM=erhjRPl&
zgdDX<k+n%3!wlh6!C+_dtl7cN5OUBXM%F5HbTWh-beM($$6b6RESv(Fd~yn8l2ahV
zDbT1RnIYs9i0pC}ELcTC&Vop>*zJL%FNb784!t4Do-+}$=S_rcJ~<Jx=S_rcJ~<Jx
z=S_rcJ~<Jx=S_rco)dwCD#36hxq?MRSU8f>H!+gg^F}gz&PZmHBbnt$Ht7Im2@6Lu
zo99R_T1CRbk-Yd7NM0_IOS<E{k?c5UBs<O<$&PbIvg5pw?9h=s&~3SckYi^iQO7wW
z*>T=TcAPVk9UN4SXvD}G2UYH;2sxsWB5NE}Q6!wh&_{~NmD-UU-wuv%vkqGaVd408
z==k2ViiCyZd-1El9AB;tPj|VX6Oj8_czA0>Gy%#`IEBhAN_opZA)}WQ$tqemR4dp4
zWD4YKOwBiu^0IZRnmJ~q4uOVtnTs}!KH!9B^r4<>n`%I$!y0_oAWRRd3te=fTCH99
z=$lz>24PN#b4lV0Us)i_AbN8kB$o_xPJMB*9D{|Inj$_|F^}Lmazz{~+u=~3I_69g
zhw50n1cYTDh=$Iroxu5=jYRuOlp!o6az8O9(SZ_W2}xAM<6+unFmm;FO+>0%D}k#^
z6;jlSQqFbVfU8zi*%a}#qZF-8z&$G>Z2n-REsy>-0Jp5@{yoYhJ<23K%Fv^I^(aGV
zJ-V6n$a(*r%uzP!Q8wvOmL46dM_EGa(O}Xe=R>NbM;%FzI+7lB(4!OesDsdYbSvqR
z^G<jIlVwDSdugj($G&$pF&&&Y19c#5SK@x!paEG-gf@u&KG>SK=96(bADoWE?2?*y
zE-7|d&@NfRbrm@uj?O0xJC{Fwv{szHZomrj7hdnmk+DY2TrL1)Qe^{}g6OVl1&e@7
zR+LP6&b0w>uQ;+Sgf-vBou!|!9-`v*cyb>rcZRT9xqAr<x!v17xet{)OGrX_dQMo#
z?LI%(erptXBTC8tI^YJ%=%~VMXfVzxFc#yHU3(v*DrFgP4cY>_ETb&qYDLvG?c(&6
zNo!We0>TzX9$xEN>#>T2GtHbsy@U%86*q_I#GG<x2<KJQPq?U}4B@hh`U%%mlp)-M
z$T;Pmd_B+}QzGZi8aE_!stSqVXCFnBgJ@XO<{YIoR4cTLbImtGb>!>m;*6N%ys1_K
z!sQQfR`e6DK@`mj)()(qb4|d^mYT~D-cy!dLK=w1n>A~$=;$`oT$YeFWd9+g0b?$k
zXU&>(UZ9xFbv4&PxbW>v<^bVhK{7keG3VT1_F=|T?qCvd&Wh?_rXFRuDK?>!Ln*WR
zF5rw6F$KF;<Qm`#7-n$tS`JxkBAv&}=0q5`_8?*yvL}zgtp#;&AZg2aOiQD8m9jWb
z6;!R&F3t^r!KXjWc@PlRv{2MfSPxOO&Z1`fH~vaCxyzM1Ls$(WIS&#Ra=SNCa+fK0
zmXL(z3Jx=c-0mxQGdSCoJJ<l+L>XPd!Ct1pIMY2I<1troh^myuxxg0DWd&ssS8%GX
zYZs@lOxlt<77#8o^6(1I+KN>qTs@=6TJ?8$;Xhg3gv~1ICu~(w(XQ5Nmkc4<qP?0m
z%k5lLOalq!$uA+<qK%m~%bktFw149(q`M_*V+Lh8Fh^}KL`_9Jepm-ft9EhTmG+>^
zJW6@qLuh@uNnf^9>n7nbMCN-oiBBPWM856hdV17+u~Pb}>m|?T+2CP#&MKsy%~znI
z>Rbh3U;}e3+c#kg`WR2Tfrn7a54w7JRu&<YHAlE?MTDnTMCfT=oh$Q_B<7U(COxvm
z&a1&Da?3=>fH818-<)T+<mk!oCxE$9{p(7mwjsZXX6v(aRnpoaEEMsR$DOdkfs`F$
z4x$D1FQ~+TRO`S5b%1saINh5{5Z~k^ut7SH1S4RvU7T+Z=z*_O)_uZ?@ASfd^0qU=
zYKV%v=8}6%xif?$l=)9s$nC!7l6zFSvxMd9cOPLPxBHq)?n&kDAS9vegoK6M?pHkS
zf|I>uQbk#|f8!f7RU0*~fN;E(L)1$+2~lxFv<}W~lo!3(mF+vwi{7jof3quF_s(d=
z-(btugELz3xAe00@QhacExl|#hF0vI$P}NPA*nHMye)huGFng1XvN=&%+>}Z_-lD5
zZzC*pqYRI3eW*;Klqo^j4O^ieE5kbI0pVz&o}Eb%iqEH2*l9<n;@(coUTL-7b-#wp
zRq=lN6!m^$&iTrZMD&tD!e)q~<-pp+cc~)bB1DnmE@~Cut%@$s>BOQYC_`AUe)SU4
z6JsuuXKhpc>LsKnks@o>uU?m5EAZz~{klPOE$Y_|7t1PoS7?_$vd~kx$4R=^=OW$&
zahVc#k+{{0=8%|mO^|c;?SPmwLB11=#6wEl?Q(AyEDhS_CRw)Bmz&ABo!4q6k`qF*
z=klcuK8(Pyc`F|+9~Q`5JY&$E(g2({9-MC@c0CYILKH0=*0!u-Wn1J>1IkFT{d*#5
zfU<}SA)VMz?hGN><fE;X#FjbJ10$o~8yPifv%t;mRu&=qH@<b!gL~>hmXKD3I!$an
z$e!at`Wz3^)^>#A9xTD~j(Tw0Ltd*ileg~yu2_+axDkZoNQ<0s;{FwJ`_}}PIyHPN
znT%U>@6c*BViY(UMf_}43v5lO$Nfo<`(1Ijfu$3roJezkW$NBQIpC2M5mu`C9L-lC
z7`ZVbv~dl%JZevPbf+64JE87yLJg@$camwnL-SSY(Vb+b@7%9PX5*ntT!BVLJc=19
zzcaH2Sn<)wh=_84cD@d^BM8Q4$QX^C!$bG$XLM{r?&w@7WMv)h$*Qd<-iAyRQ+Zap
z;j~dC9)c`XWQ9=~#duhu>3Cd5(G}PrVwglJ6KfR4r%=ipYg&;-nw19=a}d#}hz=kc
z)p>g}Id5+^V8U>=m=SS#xe8afZp=qo2HijNzK?t_Xe0rdHX#ZV$I6b?BP>Tu=O(y_
zD+{MX4P22o((!85rZeO_^2C8v>jY#F(v!~A!YL8CGRNJVTe-Z|pYzDF+~!Ky1+f{E
zW8iWf&D$K!JuBiUau+IQG<PxA$~4$P`eY~AAh#hq!3J01lAU0Kbg5pqp~1LIMf}<!
zx0O}($hjkoLG>=mGVe2MDd$8UhxUvbdTADL4rTb0D6U~$hB7xn`Po%h7w(gtI?0_e
zRzkH7WpOc9LAzcJz0?5Mh_a{{+o7CO9%qb`P@T~(&WD9xLzj85FR2yhDVM6;eu~&R
zsLG{L#5CrLwyUU@t7ulYj9y;3?UHfc>BWiV%2F9;HnKRik-6q24|LY)TXAYRvc;K;
zIK?#~WJ`Q=1fp@xMnGs2bd$EKbx*lTXmjR#xYm#`A26<AYo5@W@1yxjH6IXK^Uhnk
zOU(CK^MrImF8_qgl}uH7#4Hpsdxv1d#+5iRmdN*!^Ymx~a~>I!*QG9A1a|eh<h+M(
zglZ?s67S1{#Js#bBr^Fd{or%*VO!TM?gmefy5QV-c*$J1<4m{(QFKFlh+6Qm$O}n7
z;SfZTqRUBITvUr0LfVi!F~T-Ammw@P=YEpj4Ku?^<earV=(38kM1Jg@{*;5p$m0Lv
zH?s_D6FgVE*SzQ7;k-PLL46Ko%6lblT|_S96A6}XvYaS!_bDKATEso@J#<-7mX}<<
zunQAf=}lDpq$Kc}M=Rd;j)t0NDr#!q{%oG}Zc~W^4tb{zp7SEdi0nW$<cV99#`$3E
zGMY-zJmP)UyIwJ2UVJTi>bktPT8#$UDKAuTj{7Kjuc((n<@ZIYtwkw|t`V>aWpRs+
z+>6ScAuLnwenOfx+?hOU_pG98z-ewl&1DHsRn$jF1IAqT9COYEOLOze-9bnjGO-B@
z&2^k(&Up}-g_&|q$Src(9Nlu|Xeq&RJIQjpSe9+DnOh&?15HPc@T5SE*5(j~=}J7W
zq2&k}S}`|Q>oBv0GQ4r+BqmWYXGyrxpzhpk1hgzST{+@X=~0$}cu?|K%*E1z-j*du
zvN#W9BVb|IB2F=kbWhz62y@>bc`Z-Z2}dA`_662X;aCxm;c0GH&1DE%)m%SeprQf7
zP8Idjd``{xZv$G7oX;@n(T;kQC1ljHya{PD+D%xq=A6rW3uX@0obwd54OJWZZ5poD
z&~LW@wp&p$8_pGf09zaZnYzi$577La4#vPez;!Ef&3W3gspuo@QI<j4vN;}f5tpHN
zxv~U=3`TCQlEltkwF!ilWoR5C>)w#dJ?7T33@n0$S(LQzL&QN8(NS!67qeMTf`)Xm
zM#*Shc3uOMEJH~aXW&x_Uv4H@oEt7DT|utaK)i`k_B}!y_W*6}>k1hlWM+%lFlS(6
z)!HJYEqNx8rm-D077#M;M$I)>Xl=<_BcxTip(SJ<Bn;YTghfQQ3>zzItBbH8GLOuA
zh|JvN5*LIPkIakTz?{NNwPq;CJ*?G=;xus<52_8?r7OweyjLzmZ)?~&4U=7*7x`ot
z=hZ2l2=Aq2c+Oj-aj@J&DKoEvcoQ=D@@4bY%N6EP0A(ENwE4#7u*EeTi(p$qDU;LH
zg>$A7cV9A72?tfwOE>{hbOK@Ru2n47Tu!@W2+3l&-S_?#AedDm=V;bKwNbkSZGeFl
z(VZbHO2&!&+GyhoqZ+;Il_f{BtyV<y?N&s{Y!q>-yTn$LB__1yy9gO_5!0mwg!Ejl
zi-gRf*^!8C6wc*259SSZIUuaaMv0b_AYmOu(L`jeyHgeI&_pOcKs2|n<}zeyRdX4_
zF%{h*99Iz-ti`ykHE7gmm)o>uJ$4=r*TG^v&XJ`}iF1U*DjH0BoSVe!dOIj(<jaw}
zO3h)8utr5M6V|H8xx>W$Hs>Zf-VHB}jM#b}5HbR}tt4dnO;6$-8#CcCM5W%Cmp?^?
zuWE|$^?W5#(1J45Y(u3}^W!}BZen;iLuKJ=l$tE(QEv+@RT|1blEt}}8qnL$F6RZc
z8C{s)B3}PEhOZ|m<<c<&mS)XckW6LJh<vnYUYz^sI*99(xQi?{NasOg4=hJ0&CC2R
zO{ZC{0Qpt#Mkr^!26ChR%5<7l&KR)7{UM9p7tY^_%E3<Bn3dWB<KnA}EeCaaQ^dEH
za5I=gS9z_Mn?VIe=q<8*uBTt~p81S<B0Boi_1B+y&3iUqiRNmQRY|q$uZyDmD0u8&
ze2eT(xa~Yvaokt!EF#>)3Xuy2;R!_11taE7;&e>z8RgCp9;@gM;SRXv9ls}W<_oFs
zDo>VhLq!9G1=Kr5Q?Dpb2jQ-Dkv~vr=@Ns1{`ZupldyniDrFfW6z5^eI4m+8t}e4M
zS@mM1DZ40PtBP(D_Nl0ku<d1byiK?ck(|5hh|BOIi@aThu;JCHr%`jcIR`h()qz1m
z`X=vJA`Gk+;rI{G&6|X2TuIH1DRDDo=7U;*fr|PGdsK9junc>lAtP>sOg<Gu7^vtb
z;Z8wM;u9=Jaf7f5@0AcT!g5W$^J>HVjUwmr-Rwc0m30Wk+9qH{kEW{<u+NGJ%Rdom
zg>0-;KqzdLfHhV$3RwQhg02y?f8+C--nSqJ<_to7gqNRE-koE>GR?~!rf9=1#{+8z
zC~j^M)8`naY%_aa@bO5SLlg=*I0f{3PWlQ=#TK2CFZKWqq70w$vofi(?M1>J72V=w
ztJ0bEB4<{g6)_L>nwl30n=v91(2>Uqhe^(<gm%P4kChb+qv-J$r|%)vDG#=6LgI<$
zJ~fB1<u&^r;(f^EHTxcU&A!Lns8hz(Dj!FYHrBWl4GZxC5*2A`4T&k_W*(V5!$Qn4
zk62h^PK~CGF+vwbx~x;`%Nt{?tU)NBl-d}ZZjnFovj8QgcwzdhC2ZY*)+3=-o#aFm
z%x@L2VG9aRMGB@_wL)d{lLb`TK4Y`WC|5<4HPZ(rY~4Ad^+M!Q=vnLZdI?*P&uFz8
ztycN*1}WO6*GkyR1tgor#uzI*SXEKz@vdxT#v`o?!z>SPOksW#fvsGOp#fG#FbU7^
z%GS{{TJaHJE3ah{S3DbRJvhS^cb2W(G0x{Ib~;TW^WlDx+_tWJc}+B?e5g5x%L|hv
zHxh(=+hM53N;&pj5tip!SwftlCM!&WFcKaW>akL*mz;oCp}SVpjP=CpjId2YG>=k5
zyx?$yG9qk8d%7(JmAD05(kp;urP%y3rD2S$a6-$azJZu&4i#D9#59V;Ge~`?$jT;!
zY4bDEZ@yXjWS)`(JqYv@a^@J;V&mWp4z04n0TN*<&&p}xXvI%zp=QxGF`njP%`vtE
zIz-4(G-|}vdR`df;BsV*n#+SV92U7cWMa6wP?g7jdCcbOGLN;#DIf<k4*V3ZT_WPe
ziKj^s9miH*I4I0JQ*MrVI5OvuND;-8CZc$PMC9^3K9S`%fu3(;KQ7|VA<iNf$Bi-F
zZ%7nLT^_}+BxaQ9(lT5sX5`DD+oEAON4^=VG?$idfr!>1mu#J`PPVi_(uT6sd+qgn
z4wXJD{9L{VJ7=HWLB0GuD$6KS-iw4=g?b*&vrQ<&iNZ>Yo_l-x0C!Z>-G{lehcfKS
z$|;0p-fO$!BBmGDsGI|jJyynb?)6Oow)aG%DR+v5oR*=L8MH5=424IiaD|6LR%&&*
z_woFBpodb~t-1DR^`1e5jkvX4Lm4urv1%&|H+xoEAS~iT7S&k5_K4mYK-8^kJ4eWa
zdU#8~%7h-#I|&a|G|1Ctl^)SMdDyh4_D&Ayp$=>(?{U)Dr{yOQcn;-(UPOevR)k|3
z4V(QNKcjYH?j5ML9Ic&Lk?kL$I7>TNMs;#`adLA$7x9R!IW_>LvMTcp$X^r6P)Iv8
zV#whw6H|n}QP{huqYL+KxbZ+Ip~@XzZa{h0!O;~FN0pn2h%Dv#8RXT&68DpMRA*2>
ziMMqIIrsh9gva{$VqA&!xx|tZ-*kDro**8i$DI4}N&-DzRpLPxaXH+oRQI|FIT>VX
z@5E^m&j4%Czs~Xy)~g7>lEp{75gOgvMb~kwjfp2|o|B7sYaS<brxM@c6lzl9J4s^a
zR3b4)!+fm*nK>Lr7N;)e>la$!taZAJkmh8v)0*Arx(I7Ew1Ch?+eJt>g^OPDwxo!2
zT|I0xt1Y||aq%dpp~^>g1<&B@kUE#dU1VonhjeHR#Ovyd^VKQ(!X%iNdYJ_}V`Mg(
z2*qb^QO6Lug1(;THhShD!pe^B>8}tTsOS@f$0~Y-@Ki-TgxsXf+wZYoH=z_qQh8Qd
z^wRTk@}wf?faFQ#PV%I3=iHMD&mWC?{%|g+y9k773QryMpXabp$jYSp|H&!9dsegr
z$SZxy!x_hpXnZUeVlJe-Pt<~?PKiIk^wAB`vXtjfl40~7L1_-$<G^#u94r7XS`nZ0
z*+WTg2dBl#p2(P7gHLc$OJmv>@$QF7oN}g6mU(a7P32iz)iaQD+&172pKr@mV=6`8
zn$<_#(nT(tzwzV`!uO%#V;F^MpB_K)^6kY|=FugMOS&Aj2`eBf^*;T2z8aM}EBu^u
zFBpU$Q|b?13cT2#NvO_i7iS23`ELe0rR>#&_aKU18Qepy9ftu?B%FgNQe<t_DiUs-
zQDkk?D%#K@6d%?aI5DZ-_R_CKyiK-<J7UH>rz}}Q#w>T|B(78UvV;s#-U~ozgK%EB
zXns-6cM#IN$z(^K9yF^59fUM1FVhiP51jKP=|Sgt9(1Y)4eCKBA<fFMiO_n02Rn8+
z;{%!W;KlPicu_rQR1aPx>{iho!V{eYFA|pF{X<0@@2W8%?I=sUraW=C4%SPA2L)=x
zmFm+=gv^edPYCC&7U80bULoAqU|{Itbk;#*LW9K);O;U5!{#bN|2UAvJjw}Rnpu$x
z2$NB(F?Ge6i@4Pr2k~8$#axD<%7s(JUeE*|TT#jnwWso|(CZ?e)v-&v#_W8e#V%ii
z6?QSNV%s5(P<*My&6IeJ&T9{&pq(O4@Y_tJ&e|J;fJ0U^3OH^>F8>#xx~*Nhb^-US
z$i>3T!<eoRoN{c(c;YIdTBBWZgbga{YXWRjQLYoPM@4;v);#VvE;he_-t#y#6*2!;
z&}9c@nK!yrnrCg#N|#IXtW|(sbbqfj&svq0{!XcLx@>^CT3yAh)5X!T%Qm{o7gLnv
zS=qJ1vOFtvNi?rIJz9V#r|OY2-&AeJ2S#Mh6ShDU9dKA{w~B<p8AaActs>!yih2oG
zRTOLk-u<B{fwGSgE<hBy!dk<pRMDn9Lh)J6FelYqhHwTV!=1?|{c;{A?}C6tlEOKN
zmerg_w_`;;KNvYXh*IV{;joIj#sQ~P6s#g08=9$L6L80hTsc{UCk$E6@yQ|ROC}q~
ze@h=v_92Kj)#Cxe9Tjzrz|$%9c!0L5bYPtq^g|FHSz_y0gyQZ6FgU1&anEWy#=ERQ
zm5DFnyWz_b17nc|oOUi?&ggbcKtQ-T9Jwc}f^Y|-XjQOQ^~0)Y1By^QESlR^bD3Sh
zW0cXVa1nJvdq$mfZiN$2y{ldD%9OPgcXt?87{5%|WYEspIRch@YS=maW9TxA@&RvL
zzTV;a>ii-EOYw#tkPo7iw~>D?KZ44b70M$mR8~=5k#9?oua00~duPQ*s2-y%>YI(`
z;2ph{cl0v*HVJrMa&h+OVA6JR?u?v@Z8{|b!to!8EXi~xoP{Ww&eo9##U}%~o0U65
zNJ5z(goWJhPZRZk^Bzih9<$}KvIODd-gJ|QpKF?yZ{?pZnZ9Z&<}F23Scc+LruTGJ
z*K~Ti%;?lkmrYkhJ-14z)Pvxkj+Eb6lQ);2qfWIUs9(zMN?|)3Z2vUJB3J?3w4$cJ
z5w*6Ul*?NW;D{BC0?t?w;XFj)gGW~Ot)4d$8K^`l2670G!zLnEF!8L*y%uxJWXUkD
z#c2}H&^XNX$Urf7gEV9l={#n~yU4S{E%!TrX5dtXrs_^LU@KBq#7lS!VA;_@?mq<d
zbXfY6BZcR9Hihvuxf&xjxr;L!SsGT#S$bcRuUGk*=<8MTG`xaV(}Q?bd&sY0XpcQe
zIjO>*!eFcUx)wGtS@Kk(1$nDL-pq?i#EqIu=cS<nrt473$)E+W+ln>-w^igM&Ovon
zyExOo164*VUleV}DnjuQ+f8(FI+pC>yvbnN1D&?LOmT~*+PP%78Ek5ofN*#;3Qw*k
zgp&{zcQx4o=gE(fXt4apB3Ox19;Gz^wy5YPVW6Tx!ftg64`?Dj^EW;WX_zfn^IhX0
zoKRxtS-2X#$CTy96yTf{(LGDtHv=2iW9KPq1B81@?3`=IP;JwQ0{SutQFw`9W!UNw
z(&td`2<>wD4gbkSf{=lPdQq$W8&7^ScsP_Y(DaKuMLb4jmz;W?X@p~zC1bsaP}~>J
z+9?|o;l7G;Cx8{7iCBtwNJ3)Ek|9gAvSbLyRpeZiN#ZPtYm_BRXo;O`A|7{{S20<d
zCwBw5BPnZ*YSDRKplX}#LO80TKEg2-If)tKs_jC!22r#pv9@g$33tvYvUX?{2~W=`
zx@H$$J5r(yVIh(GfL!+Dk*Nlhvh)ZWA&O#Tt=TFPwwzI9t=%dT24@smTeFIU>t_^M
z+qQ~?yJr+#S-S`AB_--|bt!)>(x^vS!~$)AYLj+x&a`Hzw%9I&tq>J=^`rK%B_bR-
zL&VygRV180qsZEtRdnU-2&yOArIWDYvr%Wcp(~c<R9QL*tCVGcuofbdCihPs(Zh-{
zx|1c`R8c=+A-DUdn#f(LL;<0VzL&6&J8(W#Iz}$i;J)a$k=R}iz1VLMQB1$&!yzYQ
z)A8RRVrvaZ<nt~kW31Fd7<G;RFcDkp&uGPePl>G!XSCwKr^MFgGg|RqaAIrg8Lbxc
zvq~+~6{ZNLS4!AA1}*+zQe9p?<|8`hV?IY{J4RV0cl=RXy(!Emj-&`baRiMt=3Z@>
z#*j!pL`KGVFW0>17|()T-r0UKR`kr^pvn2USVMPVsE9|Qao^-Vyw2%b1^5f>5ZV}v
z`D&Os5G|oB@!p>&URBwL^Tb<_74b&w#Tc~&R&fq@!#UhpSDxv{p1Kp90&?{i@l=GW
zOS<<3gv$kcUyx_5`E%Uc0>VKRId@;0Yt=3pLb8~x)_uSrQJWHF2}xAM%hP1(RF)1x
z%i=tUk|j`<PD0D#yg4JwIMN>Oi;Ji*`=M|R!VQ$MZJ6RsG@ri>vvuc;R(!{0>n^k|
zx-zhR?+jaf&t>bu8Ljx9%hsbaTJc?;ttV%+;yW{28!$B7nbQS3^Ay?^P?n$BZ(Ylf
zBh#XT?>v^V3uk^2JLFu<$4kzO!BHyox%1)3^%0b^84%_k;TrBG9E2!353*K&T@@o>
z|MJE(Zf;o3WeDrlTpx+Yt%#7eE?@sNHv=<sD8n0hR_>_}{e;UZ3JBL!)K9pfqF@Vf
z$BGDdRn$*-sG^__p|xv>{fv6diU?;_6bx2G*<D8|19k}L={N*6fK1mVyBu>h1sj&-
z!Y767vW_m5>dS>sCccg?)nIQ>D_w-m5S4ljHF;J7t9K93ChNj&nhuhs6J5<?W8wv6
zzDc;Kq6_cl$jq_mw!=hN{U}#Ze=FdO6%p=16s<nH$RZS9YBblb<}!r!%H2yyv(dU@
zjTSFC&@s9mn3+Op@<zO@F5DzsDNrM}S-43D`qWeBzzu?NMvV;;&Z#Jv2VArwLb@SO
z=?HhB7494RsGJlEJ&uVwI+zBu;S4gIHq{CUJ5`h=>{d}gIHICK!Z8&EgySk2B%D!E
zK)3`^7}N?Xn}xz{RCZ8a^4yZczlNk#YnK7~K59kuYR`&X(|A2Wd@D(Oi^Pmk-ds#*
zZMpX|*xE!XEQCiY>f`uxoaJ%CJ;cM*%J0y-;^Ne@!~uy<)mBgjVrwg)jdjgoz`@(H
zA`YF6K5%(7f!>qKl5=(0hichlk)~XX2y0c;N7x8aw12TSXBCSzm)0&B!b%l6<D}D`
zcF7XbQ`zqb>85cyn`g~Bec_!hS4J7ku!}6a*Dt(nWv421s#72Plct^Xc>%qbl_gjK
zT(u&?Jry~}ovQoVB_KRjk&~soG8*tolrnn=YgCjYtW{A!SO-yY7es0|SR&ViYlLcx
z?LydkU$&{;W{C)MDsm>Q52}OOB_JGCk&|Tts*~C!Ae>c^lZC3w#dn#5>V0&f>Spm)
z;$7suxf>V1C4vhs-s_UPEq2+0PkZWHK-lz_Xl4~RF?W+hu8B!QwJ;=0$JON+R?^z#
z!ZA*_MK_0QxS!m%cddjw5JeHPc4!p|kIpEvRxuvAD}EDJK@>5v)?gJ0TUFFYc%q`4
zRiF35e{DY*mGT~q2-v?oDaXUCdYxS|gqC=K#CtFx-<~q`6H$jXlp?By*+w<*e5AuH
zH;vPLme88Nl{9~g=C{=REke3sl9|o3W}Ui4$TUTYkpuScMVYG9Omz@iS9|GdrRJcQ
z9?;w+HxwL|4NROKq{ZA&5HCYk#49<QpgBe<4_EJ&-b2QgP(J8Q*NNDCl^8{v+9VCr
zbq(?;h$05_n4yw)*Gb2+=@L_1oqkU|vF9q;3`Z!Q=Q`wfQ1cud0-jn?6|zvT*|=~M
zU{d46=Iu&xW+RJJ7xP*9d3Z)XS=)4$Yy6UJiXO&UjAhc$tNZb0NAs221w61KGM8xz
zott7CRPBWC=Y+Sj`@*9c!z2r5w0Sv!*v@Wz0K?ON@rgpq+?3>SS)J#;P>%H%3R&Ug
z72(r~jUm*G&)`r~JphP1(t=%a5T(3uwB>%`DBi1x%{tztn7NSb<NkiFaRjod+kL>i
zj_Q6Ji~){Y(FEXKD=Nc4*bOlt<Z#G_SP!iR-8KUbMY9#T24V&NuBzY88NCJ7J?#?A
zz<GOR3ka>pda<js?$Kkr6r9(;eVAo>i`di~;9jTZ_$60f_Mp12T|Px9KP?#kyW~Bu
zJoB~S@RZX-R6uyBqCUbCh@vCSMIOevhm|NpxU8aVu`GSI3*o+sdM{$(_OywVlutyO
zvT+mEKokYVTCG)daUX%ZO1n5`DB0VzOF-Cu#vRsjR*`V{jH1g)YL8eV!m=+gC%G!X
zIx8xc*s^5E(xfaI!qzX+Rv%#}L?-{4JZr;N@%}x?(t}3zAWLY8@flT1AHN3dAy-G5
zv#%vVNfu2|ySkULUPQ>{OY{am#@Pm<NXnX}cb=oD+M^x?gcB-qt}?0~+b*YoHtj{T
z%%iJZujT9aP}x%IU?0$03uvueXHUQh)n`SnTrY!oMQu43G{c**RtRSyiuM=Q7OW!S
z@)<>^lhEF=M1;F%h*&$Yii9U;6kQgnUHwy$rtG1FH4tGBMXlZ{5;mVvbXlZ!k0m1P
zJ43|UuvH`+Kcje&MP9Rbg*(+tOF-zoHR>G2=pv$a4SGqk2%A)N;k2SVWNFYY8Ny)|
zW#<4_QJOCTI03GCJo2=NC-^j0Z<z_x%F;_nVv~++p0!4+=*mzn%rKB}nU6v^uRa8u
zfLm6y2go2LxrB5iWMidPy}EECWX8|&DwStqX(S|Pg+@e}(mc@O!}1ZHM=QMWH=a|q
zZ_m4u(t^mCluN!EgC57bnCA+kpczM5>V4t$JS!6r%4_JefO~~{E*}@5yrMjvt}X!v
zV8{*x;V?wevSMw-DiV&KQDkl0Di-TRPP=3XX;xMVAq~ibQ$lOYd1|HVqS^`wPpTqE
z<>4A(#S@Vz$^mOtkY4h&#+(B*x2)zegtQ@}O-KXATqe(&HP`RTB+V_Uxh&zaM%PP7
z1JO>wnl*Rffq>Diz|4Yj-(CXTu%b;sPt$fgX$#*aVFTnji?-Ha>r{zvCRuLU{t>!}
zB>+pfVX%@@>R<?vk%fAUZQ1G(uBj+X$gpJ(B;18o$i~W{b{%9um71x5(2mN5r{j30
zj*zj?8Y^_gyy6VQJB41+1#1uA-eNNw&*>)YY@?Kb328#^v<bI0+<@><MSV&0eb(^#
zLwW$SG?4O!k}UX!2g?-?Vh1eDli93^E%P0^%$ymuq_qp5rg4Z)5<Z_Z_RfKBM&5=r
ze|HGSRMf>;TM)&4c+C5Bp4R5=L5}c5MSX<n$tcs&zG<_5b_C<xb4rvUB%wUDA}r)~
zzcH77FDQ3*32*~twEel9T!Ho~N;%7U#A}e1i)^|?p5T|fQ8ryo=`mU>3tP*>A54`W
z331t7NAFFPvbweaNi3p^SUBOhoEz=V(gwI<MTEN$T|Rslb7#mMD0haC+?TvC6DO`$
zmMmejiu#ha`e<tbTHy}J$`XWEyz9UF#^>^^ZdgXbO%(-%)_do^G>G0)%F^W;r7@_E
zYnKb3HZn&XvNi1ztOIUa(M5*20=cFdux@2W5jNh}Ql@sFB^m>qw4$n?jvQ)5Ddq?V
zRWv|&s-k{EIlPDe%*+QYV<~5+AYX%8ohn{<c47{au4j_2XXtvfI+Y=$b276D>6DyR
zlOA1oyt>$<Y|^7FJ!(;pvV?R)F297<qioWn3+FUFx{EQ~)UnLDrq&Kr_iUFmJf-LI
z?(rdrMm31w9^keWxok~Bb;fofB-<r#w_uQ*GdZ0*0b#`y=Up#hJw(x7$y%FLbU96P
zooX&aSg9=igfw8xW%8_9bIxf_bBk&&OLz>Cc}zh(^fQb&OLz#8QKJLR>S>mcJ{dJv
z4wzqhVvbcS@P?kqiIuQYJ!r@iSF5A92<fn48$)xoI(mz~H$r68i0Ql-y<gwMi_Lbz
z`GC&Tt59zWZZW5_q0ueoG1Ozl`gP$YpVPPpE}Wt?uXe#2=dOro%@R8|fj$scX)13f
zS#G-0MwY@MUr%K1HnYZIHiJaWah9*wCG19oMvd4G`R$~iw_SdY!Y3|3x#>@`47gav
zz*3_*yOU(O<6@agunZ+xhFmNh>QVJ2AZ&Rf>MRq3up6Rie`9UID!R;#z)YKV=})pa
zx2-X-&@H*hCRv<U)LF1B*wF6*mVcR{2UCD|t*H5LMy;(VWu49<9-9j1l3a$Z9W~$O
z%HCSSy@6V|HLC6n%mdO*nWV|=I49|5!o3TRpWI{)(B(uUavlh%Y7_44Qj>^ykP&Za
z5(XJD2j-Fw6VUx8^d3?c=NQuPvUbtwYz;f7bDYJzxg_p?F>g3ofEU)AJ8_yz-fX}$
zEGAfPl4Vd=?M=cF6$ONMRdkbZMn%q)jzM)&yIlAfmmc>()u!Beo!&%{M>=r1O04D@
zUDeL1xP{(j+NCSW;#}3cV6p3U(6tdHyEreg$u7<fGKa95bSRu#zz(_`X+~ag#Zn3O
zTD8*c>JlIDVt%KEJM*TR2?#rXHZmxe5yByeE`R932}tf;<<1-e9$OJ%t(xm^25hw=
zSL{h!S=u^MTUkPDt1oHGdAO^&8+p@$(p=~O7p-Uwa6?7Th0_4lX4{3(+PY2H2Q71s
zBc>m6+@mWt*4xQgokzPZ7%9`C2nf><g@^A7RIIfiX)SP#;y$dATBcr-#koL_5-iS*
zj}v>@hDo>uQ8edS+p&tSppx8~^SCqlBzLA*?ge!xOSqw;0YVxup=8zEwkl=`8C|64
za$*<+b4rw>B@$io;dky9Bk0ZC$g9Um7Uxxi1`pMjfYAH7C=i)cglUM1+t2pFNkUoo
zgd{ZFv48PbQTTYY>`A&45VotRkFXn}$V1kqtYXZXehncXe$w2jKIzO5(uO!qNCU=P
zCeNBR=Zx+IW*E|$2l{2^jr;OYzd~CPhk2o(5;%wQVfnV)H{`o>_#yzE>ARqvayt8{
zaE4#uTfpH;R@|>}YpaF9dXzHk4S>xm%C!N~P0=ExXR-)JphYJ|%jFYQm(*53IQ$f+
zP#@t0M3>KKP7ZS4Q|=5Q31xB+7II(wsuH<Zz`2Gp%;h#JBkK8uw*i;(xRSO5I|nEw
z&n+++sOg{^u*Zt}00*teWor*MXh1&HlFoOcKTU)}7ZVdaZ;cbyRqId_)<YBxHEYdQ
zk+9{AB5Q3{k#O*gVzJ&XsJ9uy9_1b&EaY}io+WUuDtACwtK7YWj9o^VFtA##IJRNq
zNNrtsP~)6TgS}F%sNq&Cav5gYt*_3bCofpFdMyhY09#emM;NH+Mh>uUn)B$!Megx}
zOk4HJk|CT|mR`bTh@vY;vE0_3Y&Qso3W(g_vByL#s7DuWD2$6;m^ky$H};R$?06Tt
z8}4NdFgb`a6tXg_{se?`g?g+oZI@gK=mbZ#Q^(^aLXK|u`^2o2s|zm?(tmTyKuk|A
zd8ZaV7=h(O^`JYJI6Z#EyG){su}nOpG%wEru3Hh|c0tdt$J(k=zxuUMvpf5yyjQot
z$n1*9<=`p0l<C+wGZ;XXGpmSK=Qybj)Ji~D`-_o_a#<&AhA6s@u-5)7s^|);?Uy2r
zL6i@9U+$6bJnVT+PF^FBjsLAkr?8E(Nwmqw)TAG4OXu{UY#D72ggtW8X$tnw=|tIK
zyi?=fj(loD`Jg9Ek=qnCqv@(?l3#mZy&7+ZEewYrV{4pGhDzBU+M-YoP&-6<MUK2;
zgw-R6OO0_>I4*^jz1Y9__SK0&=(7V9NTh)oAj&v+X<4AtY4d-KG_kbrf^7k%d}-ar
zn0&+L#@KTe!Y+mR63v>qh^G<d`C4pkI-~W1A$eiC#1yU5>m_V$Iipn-nF=k|Odpi6
zwGCRep<mRBJgbX}hNx(o-YTJXJ9<45_ENo_5;g>9jJFu$Es={aOn<e6t$k;-TB8Wc
zOkut+G(L@@q{Ov`Fv*5dMp|);Y`u3zE1tStv>u<)id$ss$r-IU7h4<VqoF<DuOYM!
zU#i8{duO!b7R#|2HKIJ<B3rpcBCR-A<g@)7Uo3U-q#or%X7#->UuqT$WsIELLM8mF
zLWzaUYBj{+LT04}LU}{ne5qQnenlwm9ry9FpO4z*&bf*>4cT>(O;^29CF?IOf6ba;
zQ&pi#t2D}&*velsC)rd772mMP{Fmm2>75da>(Tsp*es1yF^Xm(QK6yGREspqDv`ft
zk+5mIQ00ZN(WscE&ZeVZh~f-ms*pz6TI8?USx(Wk@RbWy*fcV0vqfBq%icN6yauj9
z#Uz=S7qoM_@d8tZi^e%BY)TiZoQ<4K+#^Dkv-#7j2&T|EDrKBqg(_zaMJcg=<5R6_
zCTiml$cto5Iddl>=4w|D7I#{3LEt5&h*#IzVQUekyy1Td@YISpoI@B+(V}?{kBDqU
z5sJq(k+2n{F_oH7%4vKMaMy~C0Rv1p(dq`IXChjMXv=CH1CFZS!31EnrtQK9K|D$?
z!|zp1NX`{1b7;GCZKAhLYnO|Ks=HXO56RD&RlNCT>67wnY0OwNa#Psm;^n3^2VQe;
z;ObM8NchdkL@J%H`kla{r-Pfz0rpst%a?knG6!-4m~sZNF(1)#4d37PzXOw8lk!-p
zD$lvk>s}~yIUi?|8-h5Gh+Hgt@aI6Y797T0lqEsp6Fb?tM=WEnFj{~cR>Z?2Pg9~*
ziJfx;rHJN`be@1jltz{tP#P^jo-{<nF{r~PDWYaT=2Aqi9JF9cwxX1?{l-|HwHZi@
zc&9~QY;K3+$k|<v+!ZyraV8nbI8PCSI~MaNym!Z9J49K`nyrRzJ<4#Mu+pl+&&bbJ
zqtb4LCHYB2epfRfAE{<#4#Jf8vTK}jQ0>t!U9K+8i7wqk5OGcy^MhRI!Z|P3LtYvu
zb*|r8#O*2Xapl#5U5I!GD<YmTcsdX+&SD;ti@4mzZ~DwAj>8q+&ZWH0<nrsJ-5p(i
zorJt6meW!NZ#TI9jEw$qX&ISo0M2uiCotx&#QTCrJc5kLF@VnzR;-B5(^Jvn6{i(@
zh=}68izx28h+LkZ&PN*T`jGb-y=c1ndKd~$82JkMjWLdV6*3<R@1IGo7fB`&x|q`N
zsZwWb&ef$l7KZGlG<~9j5>y}_8<#9^7j<KdI@}dWZkdXR>lmK!x{~r<av9%&aV`&8
zmb^d>YFy6j93@zshP_{oTq{E<FOg5+Im0B%OFnbWb7Td2?<mX5Gw5BR?svPAu#4WF
z8h+K)<rG~iwad${E)7s+er0b<F5)}M6?=!vu2wJYcL;fjmtnhq^Sv~`rW>I1kQ5Ih
zIv~V}BB{%x`12*RbCYQvE){c4uEj{V>WDkXf~wuccWHn}O`5DOSAgqK<sMz)eR-JU
zTRtE4HnRKWiP9TqDlX{<@ad@dFiv7&$lgcW2YRUq$`B9(3tvKVMOKOa%+S{p**>^<
zUM^zy8%LK3l=3UL^QC##79lO-3b_hZ=B0=(wa6Er!xgdHjibv1O1O*KBFZ9cuR@i_
zts-7F9K+@_h0-ic;uXk>*o9W1dZ1kb!c!IXRsX6N{_FmYs1*MQS0K9lO(DEK(A<%7
zX9&w+Lv9`jX*PP@mo-`};w~c|iY)FP(u}~Kk<9@gp_FMauNJj0M9~H)3ttwYEQhw}
z)gpO;r4NF^b2?Er9PdQI6dH_A#QWzEt^a!D*)GaL&!QIlH~xsK?AM~Ua+Ki%zOzqs
z*;EOY*yCD?tI&Mm<60_I7n(ZzxRFgYg(_#CC9-LyQ046NWj0kISLZw(Wm9#b%2`8f
z;%J=n=#vRQM&i#gWHTS3c>a$u_3iQ+;FPQZtGrxJxT2!lgtRSMgmy_d-*kJDFdxwT
zs;<Cb6L1wdmrG0?61RX-L@R)YR<r?snJCd}{yR}3X0cO*7a~@y=gwy#4e+T^-OLe^
zMQ;0?FD*8sdke}d^2G7^cjQ?m)dSuel{011;2KW{AGaChqkywaE)Rrr$fN2~z&${8
znOF{e5m%R1L`uu%QbA19@}_QXI5cY1h^+&INe7&BZUPQiW9P6qKY_u0;4bE5F-Or&
z=++~%=5!Yiz{p&K%ngP-;XPrTsHn$hTkvQ{SC;eGx(C&AyUc0<tv_;OOMmut&j<)P
zTjWa@{*ip?f-BrK=(*;LIJ%w0GX1q@s1?RLHC*StR3#!_(#QuHaTRu-BA$^}Cs_KD
zEPbxr#aY7bF3wZbVZ09hbZS%?m+=;;E@+p2SC<~B-qkM7o%kM9ZMvOZIx!5LxCo^A
z$jUhv2hnp#2huqmMxk1v$5rPI=qb81YL{1BiEDsrn|5(pS%m5m$~0f?x-biTSLk4M
z<jy2Yxvml}J{>j5d6;kwqRS8E<R;M;xWmcG$~|Sja3+!G9{R6XA5Q?Qz!Fl|pwd_<
zY(}LM<t6tnw08{hLG5yT2yoPjE*eI%(8XEpa^VtZ7e>>hU4m}F9xHMg<{%x~E`)v0
za7YITM<I%al(ov|RIyld2Wl=u*rVq92x%a?^<vGMbLNQA?W?&gVW*nAN#Z#xB0P9D
zib&3Mjl@Tg$=Amd(j}wjN<jmxG^w?q6|mik2m=+}qMMT{3bp~qY9g!Q%w}Z)LRqDR
zCxv>fRK7jxEP8~K5QTiKOj*4dz$Ggp+%4?N%AwUGTt^l|6RhlMYJ+`1W?jC7gV{bV
z?8=I#lkgTHM<p~7#c2QXj)==?3aOm8*(F?pNJh7bn3<O=Iz6O&l1FPMLKhh$n{@da
zSZ3fCS<G3KcpYsIdq3q}-|*fTPd!_GJ^fUE3v&8@{cQX7)U)}Gw?$4LqcpU{qZr5s
z<y%CqS5#jwc`8rQIGW0}$&hjKaM%kvx{^c}nHfnnQ_PXQ<UGZ3-9^BMC}m40oT`aj
zka4Xeo`p;vyb;bJFr!Ay*)D2?`vq#m2at(T!Yxc*!$xeUeHS5vHfr(t9Li$Zi_frX
z3|<pTaWp=zBI2kVsh?djUVT$6^SKPd6(!Dj$XSE3+~%+|IdW$=g23;h6!R`yM<6~y
zdC5D&=^lL;w!Y8@1}nbQz=sv}MK_If!9Ei6FP>x0!dmST5KgG5mv9QA;*LY)u2-TA
zAqnOACt)GC`?E*XUR3UYaO=LDB+<MQWe7J^)Js^%eX)~#NXthcdwQ@9jsZ_lMwu*I
zjD{(V^78zWp0tPHD)nAV<ykpWn>S7Y$sX#(=7p{ilCPl?jTCX`x{fZpYPy?{rY~7A
zG`tz}_LB1}yD+H?^pdL=yU?L(WL&xsw%yktkf=(DGK7Uh?#V*)wIC{$8@oI!^(q{7
zzwTZGWp*xN=o-<b8RaDz<SxafFj5;$CFw#q3en}$I8L;O<z}wc#GaDBL|Cq(8-%qg
zdZ`Yu9;G200v@(%7tQ{QeUe}Of`2rT@@^1XYtQG2+pM*u12^v1f$;oyobaGK?m?)R
zwAbyjw+(70URE6;O~~3MWQ?NKgfMNmU4(&VpeqO1gEE}lNjIHW(*w9!snjpWBV(Nh
zSeciEooI{ZC2M>NB8r4e*ZC8e7AgSD93$qflf2`MuoY^OEJB(VEkc?!WHb;jX~cY?
z5^<GfM^3zUD@w9Ie<6Drx`k7S6`Bc!tkC9l@5j9#_TF3g^8<{KKAfWx_bH@~hZ?sp
zlaJObHM|>yEh_3Fq$9FQ37O(^E<)8HXi}oY3T5vhRS5{^RMbnj0MYp~XcVoJ+A$!!
ztD+p?jEVw6(w}p2WYay{i*N~|$SKyAts;;XY+AP}gvToCB|L@b{Fpb;O09D)F>ESN
zMY^Iw*r%di!Xb#xH%G2&?U*5~Q&Fw~uv0~SgxxC25%#F455Z_rfu<@|37P;~tcZ{{
zWcZTYfsz6+&~ZydxT~T*!hMLMw6Jz)6)&QnP?ZcJIpv8cAqfqACeNCs?~T)sfp$*m
zbL)URRuu0wkERV(=}X#5j6%GZyh`)tn-3(sg!m$xbWf%qp>-n{@5Ru|N}?9&ML40N
zKEk^YMWe&otW~^-zFbu@gyfXbAtYfmI;>gx#OQdStyB8`PQY<1iaS+{rktwuC2b`}
zhrR02t5hD^C$2_Rq8E}*LTfGY1f3Bst3v_dS}Dh+pKueRXb@Q2wu<q1Nx!c28Nv$f
z)jJ2cWJO8t-ix@`lsijELb*#`h;fGps3dzL=PO{{SN5PBRMzu=a2ZW$Z`k{y*YwP@
ziQ(A*4^t`cok)5y5RY*Wy-w7N#M@}8Lht0|_#|;++}X<#=LjuPVnf|Qm?tP@8!ju0
ze6B<(qBg+5isEtYg1}Ri8|8o%RzzsIUm<L=T7)#4@?MFXJ4pE5#Sp9q-Dz;vD|a`c
z<$m=dZX0dlFn$E{mL)NYbcgZDCqAm+hV7L&vJXOK7^R#DQ+Za#Y#4;&s`nFKehQVj
zD^W;tral2YwW4^q=a}@=B>CmWne2l~_0kyNp%onirmxb6L}nO{<-S4gNhP{*7jWK+
zlEEa7rb+Hko+2w{O7se0rHVdDNV6&LlM85FRIOLm05`0N@W6`V8BRLYL#M2{9-3QL
zqL*pTawjIt0-{?%nesjnH@}FcHC5>$+)&Xc3Aa@Ai5<Xw74;ke(tk164u5m%cQ)<;
zwV8Lh6CrHSUY{Urg6L82^YUNy_1B-e{`xc5U;n)K?6dhLv@uDg-dOT8jGTMjItK&7
z9*Cmr9czPDk#OjYVmu&PsDhTcRV8jwvKxefigJWBEvX=+$@A`elLqB?*1=k1+3Nvw
zR+MB<-uIHd9NohEP*!Lr6tY5_*X6Ev?CgCnBcu=KsKk9b_r5o7U+z_Dy;{S2iLhNo
zU4(Q*_AbI9s}&#8S~Rt)N@C+;?@d(+2)7`L<`rwlR*~@Jj3R642O@Xmh(}lsQN+kv
zyHz9%&M3yi8iu_IbtOkQsiKz&msQkFxT>O;3D;HB9XB_ECfW!`mX#?qUYF;&pF2Bg
z;?(D;Tx806lekRN8>^By08xcLn#D(aPvg8nNIzvx5nA%Z)hJ2+ypl5+!ZZszmMJmy
z?m}f*T}oUD*qf72h~p`%!c?i%S(Hc_XH%c51cZZUCK_u)R*`T*MTuKPdXxq*6CSWa
zMTxhhu@^2rp1g8MXnQ5DI;rcacRc*qmC}bR9)IfL>!}wX_q>uu@1u`>>$PvYQc~r4
zrK!|MAM?Djw~Oop*F5h^tylW+hpt@{c-6pb*FGfhfkuH*C(ld2Q*=G=!AHX4A=_m5
zuDw;Hr4Ji=&nqtz@@v<kieD!j)sJ}I!zvZ#M@+?-iIghdCk{V)wWaDSFFf(Q7`cAM
zD|y_2M;ieiYxGRLvOqC1_pT?5S8p*LB7v#CRk~H#>f?sRR;!Hf#;{R+;-`Nim3scM
z>+*!*$uIpxO8Wim3lh*%A{L8ATzxHc&hws@D7<GLOIg3)=4*nQB&r(Cf>hofDqe{K
ze6~PQGW6VAB>Z<h;d!-J!fd|dEh$rb=i@16<Xzt!Hq=2PeD79@YsS`l)DNk=_c85Q
ze{P08EbQMPIVwoX`=SVc{)Hz@kl*+|3Cs9u^4a`^(Qh!BnSP-P8qXVjTYZ0{SMA$0
ze$%yZk~M<nnx*;X_eI$*5Pi$jVa6Z5n!DC@<p;$74;a_X_{#aG`Vj*@Sm;lUsC?^{
zf<gPXYvOYAIgxtaw;S#kA1CvNV7(x&56kd+E$@^+-|-MQO$J`D7NhvT(+Z3Otv0l%
z{UhhtH+lOmlegy|L)yNZHaxEl2{qO}D(MRY{T?$_O~l_Tq5B53KP?l_M)0u@gfrp$
ztT!Kh?88qOkG>zHE-=u^CY4OVOp(c!Ey%XCb{KlI+L)rw$2p^=^+m0i(`IZNc~o}b
zlEOJ&YPXHDcs9cEHu<=sYx9~}a94F2hE>^Pur|YLnv3m0Gu@&E_)uZ!QSPrr>!#eS
zNdFwm#_q!r1IFPIOA=AYo)b>r&`*<2*>oa-@lrM(TX`(n^D1>}T{Dw5+;hx;ncXJb
zt;{|Xt*|hbsshK1-V>bVPg-9%mQNK<@9M%0>S;6A?XDw+?XDB<1T_U_q6KLdpUJ@6
zHS^(C_pD|<tUjli5398rUAQFQ5nUnP$t%RW>}BEHX%Tlqhrd*v2$NEFW_4UC*mAEH
z4oEac4@AS9w$qH4pTgbmTETpm^pqFQP(KReVTSQYK^RZ`kz4^~0?D;4b?Ys%zk5IQ
z*0Acm>!GMLe`~5`(l-l8tzCJr^z=PZOKF>wW#2D<p7yR>mu~6Q)nBQV;(?Muqx&C3
z_j?k$Z}CdLXj&h<`e5m260MJUB@3qYQ%^lu`j?4Txip1+fAw7tmi`G^OSX;vZ;GTp
zp<nKm{1sdOO``Q-uf)7qk@_v^`*#zq&v;Q3E7CecTP;TapG#cp?+{-3XLImgujCce
z`c-NDPl?v|c_rrYf9g-9^=Y&3p6Offm4wV2()v-fmfSP?e=3rZg#Jgol0P%8e<rPe
zkZ5i8N)AlxzmV4doM?TgS8`PzKBhLM^{ID-jub@E;FXx?&Z+-NTE92Z`i)-63#Rp7
zO6!j&T0h{G^qAIvC9S`mX#F0q<a4HVOIrVXqV=O*$((8ZpQW|6F7DO0!|tC;>*vv0
zvT5}H7m=(a^uN=KvbSw)QUBEF|F0rxd3T)uTfCAd<&j?MFQoNH6Rj;?Nt0>)*V6iX
ziPrD)N<MB{ccir}F^j&-dtg-T{*cjFzf$_+Qidz0(o4TC_`x=DrQ{b(>njxxmL4Sf
zKZMp-rS-2k3%_dgjpWsY{#Eax->COI^L#Y*vS_TmU6A}M{c9;h%O%lYFa4%S9yCvT
z(+|p@YsQn`lrwTFs3>`t2vT*|A1s|p7)X0jYrVAoFj~t$Bl=~jo-6)u$h`CX|M+(4
z?$2D6(EL9#CvE@ueWKw1-qUg=^uJAvT=lN(*T~_z?BTF$$#?tv<|Oa`ebG+&sq3ca
zA4{K7|E64n%lwrGOwT&G)Lr#|PA1O-{!`+8+8=nY#Ncl~<arPI|4Q_)`GI&)?*9YX
zjeP%~%HN0m+YicF+kdwVT!nusm!RwZ?|*|_-24gAe9V7E+^F<_v0ScY{-28VxB73s
z&GR1jza*Mf{%0kIC;WdWk|+JoO6ybp`=wX4|9;_o+W#G~{*3>ENZ#iEm#1W#^nY1&
z-tIprwx0E$lco2Z|Jb8)!u5Ya*xup)qQw7B|4$^AcljTC((~&4XQc1D{p+In9{(%8
z9Af=%5#Q?l1;O9oF9`qp{9lu(ztR6IdB<ym|4Hffy#L?C%KQBfi2R%UzYxtv|Kk$H
zH~T|k>s$Qy$f$h4uMtU;{~MzJLBCSAqi^+}knR23{GXIuHT%87(Coh=4Bzf|iMJo}
zKPLFY{*jDAi=UP4{yY3X6pJtTzbQU{r~g^;s@3n2z8~?^()wNgzmwMQ_P;0@Zu7q=
zRzB+gZms8ikN<y2q~GgrNNc<QUeWxR|NUb3`}_&v|9-z!A`Scxiia8hNIcK_hr-$6
z|GD()^j{GFU-Tb-*7H8@mkIs>|1-~dUe5n+@vzJPl1#Ff{C4?!!@nk@-|c^=#Q3uR
z74hvAzfr8b>i?;XSC8+@{P~1GB4hMPe?oM6{ih`Zef}4Pt>6DE8O;IzkHq>-|2xF<
zK|d|6xBO{oz3u;?%!E7sU(2R3<ktzq5Bg6_6hGvDN;38-e?xi=`yUsbAND^Y@=yDp
z5{rMse@dbo@xLrOKjN22uOIbqh@U^^KPjG%`adEue#U=O_JJSw9~FOI^B)p#$NXN2
z;<NszCEm~Z9~7@%_dg_k$5Z}8LihQU|3PX0iIks_RQzPh|Fq1NiIl%9Y5qdW|5aH9
zUrhNwC)7Wc^5@0($&~+(C5=Cw^52jwe<|g^MHbr6r2IbVH<j|IgyqXA|9=-B|7Oac
zxZ-(lr2IF9>~6|Gk|2II<^R5r{anhw`i-79o$}u;)@M@wq6GW%DZf+Z;xDB9Ka~z&
zN%_Ak(aom(3UT)rQ~sAk<(E?aV-mtIr~Gz_XD;Rcx(v(TO8NgrR^{JL`7ektpYq=(
z#eB;DEwT42Dc?(b-mj+o{~(;dmh!vB>jiOF`u%#!uayk_os|CtG5Z@S|1~KVB}_5<
zcT@hqmfCNo{KsXO|6a=f3z>uWQvOfNME(1c7oq;Gl>fsru>T<CuSp`8QvRsK{@ap4
z$^Gx7{C_VU{$a{Lsr0;MsmYN3t~ep9^7q7RNx|=@{2!HmE7DI~`U4q&_jukPru@H_
zet(qm|57Zhru;vUwEm-%|BM9vk5m4n1op=%|9ZXWt;q&<&GY_=<V@1@Po<x@`_EGT
zu*`+^l;0!M=ATO<WyHRk^34kXf0FV$WT^hHl>g(B$V175)c&I+SycXS@kKiPr<DJS
zSU5`gBhumjN%`*=&c90e&x?cquL#An<COn#@$5f~P{RB#DgQYM`oE_9k4QdGQvQ$0
zeEDw@rfgGxo$?+r+wT7-VU?w(D*Q%Cmgj$3L@)ShIWvELzQ+G4(f=o(ukl-D9RAs_
z)c7T0{;T6PQP2NP94ssSp_Jb%4txH;moZNHza$AM@$00i)c;G#W|{vFh4+fzD!IJs
ze?=UA!2e$PoAy5|mLBx~o>+Luza<e|^KXfy-2Ya|knew!SbErhR-AjpZxMNg|EDsv
z*Zl+O`)FkUrWh<sbv@+&f%LfQZ^}ft;#G|NrFbC!hUEX$5B~ONg)+J@eba;fYckc+
z-u2OsrMy3shU?n`zG^_j_oci)7x3us3i!7M{C5HWr+~-)f5N^7&dO=~|JifSY0jCM
zrgNrqdd_Li%sEr@b}}`incj;=MN*nxP*;~?XiB5JhbXr&h?x|HR0tt%2qEqugb+ga
zDnbaQ@*1N5cYXJMo|)X={rvlUdS<V^_FjAMwbovH?bq`&K9(M!yiINYh2pKY!_g^}
z6FH=9Mz%!Wi*9GN{S!7%wOtHRC@Z`zBMoujJpQZtnJ_2nvg|OdtEtkQ?6xl#NguKz
z?MEwXEBJ^6SD_)1>41OI8QOqYhqOlj(O{LDmHq597@6Jxx(x)aW|N-XevGoJ^IG7c
zfb+n32fr5Zi)DbX$le2T(dkmnE3<`k%=<6~p-f%Vj%u_gxI}eSqfnrgy98Rd&Y-Mt
z@IRWh^hxWZP)s#Hy;XB=N^g4^WU_gV$BHCRR@RSb8&XUJdm{4z50paZr;9iuy8!Q!
z3TX<`KDi&IZcdl_0rY+i9ap!IzJ25=%G!^*sK)eBV4qzJxD>)vO{8uw2F&J~^zm_q
z9gA3+y$tY`&|xS2JAmJZZkgijqsJ@j2dRxoe>>n!=s9XZ`Z?$d_71>zplNDhx({%?
z<|ECC8VJ^I|2JhljaaoVy;w9MHvU+Q4<<!NRg*T)>Zrz`MPROQ)yfN81ap&l6+RPS
zh*hRHU;b98G;bn;TKxco@_4PpK`2B3B$e0eO`Kh50H3!_q7LGc!c-ftKXEe(Cy?$9
zCf-Lg3HZIyL_IWUfFuielZo|UATb%<QY-l<3OOqi9j9Yb1ac;VzAniy5|04wHnC&^
z!4nYlmHK+4Rq1J&-4U}%r1Gvx3e{zu(4D#^haz|js-2$W`vN^N-5(f>7@r?<^s9hK
zKX4X4$r<=ujAA@L7Ra9lrJnF6lCZy$L_LM}UIf_^cp9zxH~?=6Rzp3DR?SBSk-T~i
zt$GT2H5t84{R^$y4TjDThP~h|O<aO%EJL~KC2vJy9V$OkNWbjuo!AcPN{iGh-hl}(
zG81^!drZPcw-OGh_q>A>M?<NP5}9oA4(;?KYA{TI_q{`v73hM>6nqEv?o(>JH_--3
zrCsV1uhl6EeGs9lPrVJQ({7NQCRP93yH0f)f(i*o)E8dN$TDXF5rY9%!@c?Pw?ZB3
zO?(UdOOoR_uwf?H{eu8Q(el}7HG$*N@{f_MNZ2q8EthT3=~CtikZ0!G$S^h?-1Vw_
z`5VN_cA`6KFOu@4DJ!uJ86~~Pqx@Fj0MciA5%uo^M5U|F(vb^uosZ?)lY|hxfh1!5
zQnf%Agfe^Lb2eJ;u~kvwa7isBTRv8RX-@_wISHRVP&&_d`SPbhjq)arL)$3G(P(H6
zEEIvUkasDlQaw*XtH+??7r_pyzoFH#b1X(tor+c$plz>Ucu}W8-p$ZAu@~wL$oq7t
zg)~CdLf#i5J(Ep=ywAb#yjw8Sy+e!rYN|JJBGlmnp)w8CcoZD!BXT|$1tsovbm%;9
zP2wwvo7#1OcU%H%C)O${?IQ2Q#Ai_cQ;|{q!&{f|lo(Z;=be$b&r#3oyfYIYLP*rE
zrQTVI8=&k2?)J{H*qu%kyYZn4T!ZQ+7vQr6UEcFmzWh0$EMMa3Zl+PnXC=Z%7$D8(
zO-zRpv$-ChKXEF00nJ91FDtRuDW<J2nD`P5XPMc)aKb_h2(<G>6SGkJGo%}ZeDOpV
zVA!W}e943lA|=q?SD3h}5FV~13;RkFcfz2^lvPE16^Usmlt2ex@5Be_EDe&(_6<x_
zf!c3kZ==4UiT+>?^)%)imv{pWrpP<`CMF(*i6xNht4kb%LTRhwz8Q%OjBO3V>O9}f
zgls8MGxB|N5^~3uT|D7yNbG?S?vZ3kUsGZ+WJ>WA_?9G=LE#=2Oef!pL>358n>zbe
zCHA5Q>jYEiTa!2u?4<&g_?i>nqG8mTly76=1V=-T@NG_<fqqI}clB*e?1z?+iRHd+
ziB+IROr>u}Vj5J3Ej`M&EAcw=<cL-s?b~OSNSdVN>W5L<vp;zSSoIF-7?_k4)Y}O9
zZV%ju*v#ATIYKI!=_!!EmQp{ZB{p@16D$1145E0B`Z+D}ZxoOTQLA6ltVAuCJVH4B
zXBu?akLc}^IN+I6JWyGl#HJ*KEs1>|otR4<ezZ7oJM?wDWX<q2TbVWzeFS3a`?P%d
zJ5>EAEzw39_1cc2;*bD!?GubwZ$pHn`(>Ix@lSAbkWkv4);o~}y%{RN{<MKs=D8rd
zQlP2Ia~Z;1e^6HPYJ~ft%2`88E3yWqy22tnf~c$^R_a)E9a*HxI@U@laIQbHXB~%0
z@`qqnX+~~pH$)`N%gD1*dtp6<y&3u5R1jgtC;X`=(a9NKkd+c;XMEpa>i1$3K02IQ
z1A3Vto-r_roht-N(8A1KU7iMaf|-@6=1!PPBRaE(mC8ni814xhDrtS+!3O#KC8A#?
zQc}xe;2g_y7E+j|W}b)e!{~GB^|XBXJ5V*JB~AeIuLVNA2C)uQFQg?F0$L?8FB-8@
zQaoswxfb!Sqvq<lw0!v+Rcq1`U12N8bqsikjp(3XNbYAK5Bd4AZv<GM7PLyF6PN4-
z$Prs?cUG=PJV3J+6u{mk<d4sO5K)!heEHj;3cQKW(bFmNLYT{M!BPUn@JhtcQ{_uw
z!UscN*o8}B!q-ANvp`IxV8UfLlwJ5p*hCwu%nEn+f<-cHni?b*BK>x7J#bP|r2P?s
zz9j(}N(15t1%$usMO{TNj?CPE^cTR^s6V{<@;9h{^CslJ^e!p*cT{#ZOh3E+K`#U*
zRS0|!T;`wnTqF+jFi*bx4XP4Pq8O2385O#EEQ}LfJc*~!y;<)g&~4<l%>#liL%kBO
zf+uv&x_SJGY_y!fQJ##%w_w|;l5VIctJtfK@g%-OOufV$>#>gTszIK_O4Q^Li5U#S
zE1)|BhIk;tDPSr2dz=*WIX=%w!s9(bD<IX*l!Asrv}#J4N3xN7V9YxR{}a6R_Y8=u
zmi!d(8ySG_419@Taz8#FqOJa0yU3rQe_`q+G(yt)7g?#^=~|TjTfiwBmMgO}K5v78
zo)w;=LK%Sz%MoJ*s_^v>m5}JSM+_+IkhEIrle7Y-3XRG5Y(p1O$NKW+?-Di0m$(4M
zisq=n7}Z8VH)xQD_!_K$5DVNQIq$-!6iTGVdh+FOP>t{;=0fnY@}*7$-zGX-9|;lc
zg(ad0Y9NAFV2R1mQJ$>CFJK{o(VpzYX^<%SIR^anNCsBjYXvfZ$?SknE;^KY#FH<7
zGt@1f#PNj?1X8NoQ0V*Mg8|YK!W04zdAx~{s1AYEo;Hc!(8QHsk$Ttzc1m<Wx<+7z
zlp?OAc#`T%Z$Pv&IUlj7!p99vqvDT8(D!11i^F#T<rn|4%(;yRUci<4306xz>ytE~
zgdQdR;91{2i0-OJHG=^zH2Pi8Gmus0-1!s%s_EllZPhkS=6J+>Eo8U(#7^2f0drRQ
z72$3@V4VlU73RP4zawYcdz4h5P?Dp91_u(LyjiNSw~e48HZpMnx3`T9_>qZ#kCyJY
zw~aU&kp}>Gm-*`6HsXRt_5%J?R9wRqYV0&a8&gxy4{8kNRroU+g*ph`oSFh;`bihs
z1G>UOf6|4@&I1emNf){gFbn;Og?3eASfqyRo@m!tq4rA~@xPB$W0#mJAh_1yLf8o<
z+2&X`WH=|xHctTol0PRbZGuopUPD%Riy_gQ897n8NN0S^$#~IW88u}84($2pBx+`O
z5>&&MHOAlYUtP-F(R0yZ4bCddIv$L~zXmC!J}DgD6=3bwAPW~9b_KZLAWKS5KxYlU
zyPi*f!^D+B!fpqj><4r*wU?1r?m3Y2U{gTu6#y=D09iMf<p8Sy%r}5l{u|Uid!AS7
zptYtd4n1i%o)Mf&NH@`_9^=9PV3DXai!9%c3TAKjv}7(@WC#~Z1E>Fh9;n)9vVq5-
zx|DwVOi{Tg*9RiRb^8+(*Em%QuQQ?D;H;|uw=k(OgEVe%Xf$RB4f{91WZHrZVVXS<
zCX*~#lp#ZteF5N6!o*vd->yWskJRbr4DpTaO98VU27g5WYjvf-FU*jE*nTU+bT~t=
z2K|<@y(L2|mHh)Ol22r>@jb7EtZRm85u-_%i)Li@QnfcAI;Re_79(I)R*3YzMp0qO
zx-3KHI+ZgdaxUm^lJZw(h<9Lb1Kcd#?%oV>6r%5mxbMqYvJP7c@;XF#xGqa5ss~us
z%ZTpX<{f-{sj1uXC*C?yP7l=h8^q>3jKI$b$UoM*xplp7Z>jekPQ7C_Nlb!_Y^1+m
zH%D2ylMz{Hvc@h2u>J&HCs}Ek3*&u7C*(45vFiX-m`cNPsGeMdK`PPE-Uh*f#<{6#
z(r)luu@%U<?=NwWA<m06L-{95WY=IOFX;;1IGy)x#La0HHxKC~ZpmSBLIEXNea?pm
zq-M7h4N!flUbEY+1goOG3J`NuyGMj=fd}yQ%RDjgxP&BipGPFYWa^s9Ihl&tce>c2
z$r+D=mwhSV$rNzED5?xgk>O1`Jz^$v!>e8jbDj)!O1)czeH@@eg;uH%LSwinEj7Lj
z8v-aaRP0Z^4P|7wB$%p0oXloIrBTaQ4f4LU@{Z!ub=3Xz4A8Oy;`5hZjAY)JkG)(b
zXIB5RQJS0F#;yMiQR?Z;$OA~nuKP5*ZloJBkLpYuyV(TjCi(PirgXyrCB;~El)Nuw
zrsc@=VJISUK1E=x1j0x@5rOzRQ<|9EoVyWwDPqwVEL6glg|o-uI;syc#e3{|EpSOJ
zv&z4j_^<w*>FuS?Y(jKzYbm}t6-c&90%szyRszikG)rJKT&+zKSc1S-34DyeP6Vu;
z`|&+!2#*uOACd5Hk}4F%oCgLYXD|Xe61W6`d<i^{Ko<lCjK@bVYO3SXJ)!-GJr@x@
zd*KttDzE&5)GXCA-P23e3`ey5%Z-8jZqxpl0256Wq~Ba)5)3y4axX`=1_zMTO$LZH
z0JGEp>~f`6uJnQRPHM@z(Mc`9=9bjnM*kwe)lCQ<FtOHAJw#bTN(@ewN1FYlYu`Bx
z9Bq~7A=*2rl|Ge!2&?6d(=90!RVsW9b+7_&;X5!~7f55HH{h%4e}J;8uB9~Sv-+52
z_O7KI^|k_j5T*clF>;Y3`<jJho!;)$&n&}Nl+r+-1h})%D<{3^a|LdgMs1BLnZ~$p
zDU5LqjqzU4r7@0uwhEos><buU6ubH%$j*(U8KYe(Jv`1TTWJi)JhV^MD{-I-^=Q`z
zOk|fRWS5Bi0(h7-zfgCfi&1HgRE3$+g(B+#_X!fe5)HRcgp0#2SIqSGn}CPHB~YcL
zZ?{L<kI>f~cm-gNWCq_8xE*lsRY~T_5LV?1lx@o$b^4DdvQVq~cc_E9By-(Jt*5bp
zur+nqX_0?o4rQghMjdIzP61-Ii>UDh=gbk~KLye2O>|6vT0==RQLOA`h@0=mjpBeH
z+P1<eQGiu$0?lgi2Acm8cWDyl-;LwIp%V*%EID7mDl^V1KN2i$|3F%c`yxJ!RX!3O
zvHg85(N@)4en@|UEHY^iCtPYsc|lRtU)crUbnSc00!QQGi=@-{h`bDVov5mY?M#f#
zWNw!BHR=F!$0d*<Yv}ePfGNSu45^L%3t;YPWMptpV*rfoi~`Wp>B;gntr~VUT5!yV
zkYM{K(zw2B4Vo><mt?BG)RZOEl)jzCFfXB&MBhU}>W)lt>7!qwJauQLIJQyN^LCwv
zTDp{4+ArEC9f?+E${YeSn0wKwRrd@-zdPIAH%oZXo&Hty3v_Q)l_Be{nr2V7J<4`h
zvE9+2^bHec`%IW^@4>cPgBqnJ1Jg}O1G%ddWzCLB7sC+kDVjPcUDk+oNrSnQq+6)N
z)}Xh*9n}R?n6nFW_T|1(7j9!&gI>iLq$-^hl{y7Cx+-;w!M|fz^-n4km9PfS?gn6T
z;VmfK3P@C$V<u_Rr~gNIdY$g!z2N*)4%bl*R+-maqt{8lkdm7+Mf8!WPSPfwbV$%7
zMNfs-+*drlLz!Jw4e1?XqGP28l$vznI#uG>hXW6keDzAim6a8_(;=UgC0=rFDdLBl
zoZW<s`-nhUor&J+69OyYld8tHw9F!A7T?&GuJ%)aM~G_O+?Hd0Ix0znvw-RCrRWM|
z`@*(##bsTUYNpdyA1|79ZuVAFVD%1I1~oOi4m*YNuW};(+A@cxm0Y6>ordwB{`Oj3
zXcu@|?1PWB6-}^b0G2l!)#GhNI`)%**(VLY6B;|R5O|Zn4)8akNe12kwR;B=ao{Ov
z;IWea(Y7~07L`p>sXQooFAQmFYg<{Gu_`x9?1N71HzwACp4%Sb5PF+Z*|JP!#pBqi
zlz(;jZ})Vt?KIYk&%?H>{9A<o*klc|;|$7{eJp@hx%9Om*|LRWpNRs=(81Z#pJ99<
z)}@A>F_G~O1JDhC@eM<jt&?;C64wCNKpcQ96Bp}(1f_0*QR+x1ry$0fs>wLeDC2+_
z@7V3YEOjy1MFnQGWE9&jiST<|vGlH(CK|zFt5tQ^1FM6+yb7M2izZ#xtIWjFr|I1~
zL8%p+-Ut2BjcZ*cS$7}%Ul<vEmi2>M<zjRLME_^}C2q_BjQ8UlMvY3lmMww7rI*&<
zU}BPNshh0DOPgb4%+!kvK<=+KfV3PHVk<X0si%P4RtFHdlw#vr{?Q$*Fo0paRrMtX
zI{z%XVq%Z9g$fQd$#x*0suv$Q^dhuOyy8$MG?|X^C<N#j&qIKY@uvvTF}?uZkdE=w
z2+%P;gn&54ti{q+wU~z@g2_{L9al?v(+`c8X=aW8ZzydD@`NRD7XnEHdZ{sG_%q;Q
zw6g-8L+#D;g#G|>HX?E=(1sfju#R1V?;Jx`lnL4*;)Su@WMZqNi`GkLSC7PKoz6sV
z_LWCsGPp*50=ym_1bA6UkKBXqz|LdfQE-LmZv8VR)~iF>f*Bka9*@cTCcv6pvCmJ$
zq^kiO_`Tl+?e6dbgewMZ=b#T9A^0a_vRH0!hr07L!ecQxjbK0D4I9&9!!>pL<Z`&z
z!hok(d3!tHmwkZOu`+f;1v~?3qJcjHOjG)3jHa~oNMmZB(fJp4x2(^F{u6Ahy$>**
zV1w_A{#ATLOL=brR_QJ989i_^OqjVg##M~Z0Ix@zoccEQ1-$~m&+7VBqZ{oJPw45G
z3}4an(LPhx>LAoX4a%*R^KAH6JqwDZPVczlbOU#XAk>!~%O+{~xbvjm19B^8fFE{q
zPaHOc<kX;!A{Fg@9Me&}kLnHLS`F=Zp~+a;EE#t6#+(rDfEv+JR&Zg9Eu^)70G+;4
z&^e@I4@CoLDm7d=P!etHW!4YR>nQ7oR=in;9Q;e-zugX$Kf(~A9_+|fymJAs6rO3=
zs$QQ3;K`0V&d`~x$~hp~!PB_Y;=!2jI*MM}4?-1WIY901D2ipD2&*+p*k$my0zOw*
zu&1Mp5B6TbZ;G3)@$rpyn*2=E3B)&B3sE~2$o*1Aw@Z)0I3mQ;bLl~@27D0`Dt|5u
z`yOzcHZC6AX_h)dn>)xD`5m<fRQFjGqRo4$?D5`z*F}z%BGVR3Orl<DKXITSk18+=
z3yQH-13X8AYY>=9bo7Mw!4U}}BJ>~vaRe~=P2tZxqY_XEjA6O`dZ}qW5#7tv*lZmm
z0X6wV{K@$p!ulHm7%R`xHQ5Hhz7|SH8IH-Nzwr!UcG<DIv3mf&25zfSxpc3S{c&J3
z;=)lbERW8Wp)$VG5M~qAgfFCpr)x4}kZqi(;OV*2cTr{{1JKjCO-2%xHE5`P4U+wx
z8kS2rZvyOtDO2ZYI0V+`2!0wxQ+>L0@A_Qt*}6rQbA(6^3?04RYjWxF4*|?3UaOlp
z6EK_DpzHP!U^ek;HZfi|SyQV)H9M#?*^C7`>BmUQW-Ktxi0?Fsh5hzmRBvJwRk|Zr
z=0q^=lfm&_6Er;;qL1#V#zIkGe?>p6*pJm1ZjEM`NHNO`CSpADHEy)9Y%o-ft94Vj
zsAfUs+Jj*73^Mk?V2o{Y4Fmtgz>BvaR(=eN${jca=dKKTs2X2kx}^+!G7y9EKz)X5
zx3L8hcMUMezf%Z$8h4?_YmUQuh3TDc<c#Cd>D@@D<}uF+DDq6FMs$2eV@R-KpPmSW
zQCum8j*n???8T8-vT>24Q9CQP_9TpYM!kfEl3@%n4X1$TM*c#IPK85CJfxK_a!gu-
zw1eD5b8D<vyK!*Sj06R99q?v4o_0NomHgXW{3vf@??rx1!HP{p-fc#Eb-`Aw8FAJW
zx4~jrtk?&L+~P*+sdLzxs#D41B&z;$u~oTQ9CM4HGMo|Qa#}(2#4)%ai~gzyYB3es
zr3$lT56!+G={byb%HlA#2XK)LgGE`ieM1Lg9RLg5syOQ^bUnMK8fqe?8u+ziuxSDH
zRh?PBeIj(~9|^#Q{%3$W12OnFpa28XfiKFE1w(t(Q1nTukD>P<;O}703_g06v`y!Y
zJ|1w>4G^bBc4Jg&R$Ax)Dn<9E8)`%MW)cG8-h^&JKpdQ&;^0g(Y?}o>i=)%a3l=XI
zPv>~;=D?JKru_%{0{eK6EZXcrP=3yBduGY@upK$p%y@e7Oez-_lfslCS-#NQNPI>K
zioOm3ca`zNbF{=TKv{Z~v2Gv|^-^c+#m0D(Nf1Q>dp!!M0$TOUlKp9WFW}e3Aok1R
z>?R(ZrpYam)SZqq6Q&bb9SjH)Q5j54dehrFGfVqRjiq$9G-&Swqkj-a*HREsp5#1>
zLbl?&&(-8>LB4}Jo4j~M^P)34>;BHj_bLms&jEZe1$bi?r{nRl({<hzlGmxjM~Bxz
zgYg+A=|r70DP~XY(2BVXbUEw$R4d*ufEz>^KGQ6)V&al|4cE}E9G4U(N%tJVCtKlr
zxVA#$`#>#fTs(RfCNMI4Sl24<YV<%^yxQ6-?i$36L|&_2H&nW`SQHqd-frRNpNb*P
zO<-(POTEUqsL`s=U+P7(<KoA7v5cor!Iu7|44IoWy9sO3q_UEEg^?bN-2cujtv}!<
z)C++^u(y$kSoV1!c=X>f#<+2gd6S}q2emE+Josz<q%IrX1Y^>I1IentCL4tkcDE!`
zVB&uhv%&{Wl3G#P`Xy=j9@I9k%P?c}4$|gD<^tvdo5qV0?i7vnw|!t8x=TLB6`H(1
zwaKdm%-(${i|Z8+0&dq0>6KnI*$0?wf@y8((JdK{qhF=K8@SB~Ty=nLRGzjpnUer>
zwaVL;*5f1$S9go&9%xGw`T^i!c`fi%j96oZUWTUsGGML=X6o|Khbuu3#MEcSDD+&R
zXX*8pX`^ukMT~=?|1w~jT%A7pRM<_c7j&*|TYJ7%-Ri6i;Erosd!B(Sq+TQ2E;2AJ
zn_RR|^V)hsqsAD^mWhCC*)|(mEtYMnwrpk_CHCZLm^vDQdfXKOLxZ@V*kCZR50Px8
zo6PA_*Fw>L0A_tFjJOrj*))Nz2E&Pc)&;sDR(PTb?LvgApVt=OKX~jvvKY1J5cx;8
zESf<*{M=5q+R0fiI}Qhw>T!sd3ha@9w~OI1_<ewP%JjzDj$Y<ba4u*dEpA5IivbUj
z;?mktUG@RytXA>rh<*IY*hEMN-q%j%P<A6=P6#~h8l?P}0Mqap`t9JN@F-~;UEWE6
zDPDu`2nS(G7tqTfUW;^OyWoXJq+G+RZ@0w2@pUGEG0w8LfY@`QA4RO3rB?taw=29z
z=ce!qO%4%TaHcj46l753&=Ayes4}T|sA0DQ$d>Vs1|YGdq3jTYALfv;s_ub2{3~TD
zQ7B!pkb~V|G|uuj>a~<XS4B|UnR%)&y_%VMGOvizVZSU-9Cj<*UzYyx??*~L24c$B
zfzHuRY(z1euLBn(miJeBLBiL83lc{Tz>S6+H@*E5;35&dzXN;r&w$DLbkd6_-_a%Q
zMrlx^XjwVZw(lU0R(z(x&D1zQ$KKoyX6Yi%$zGgf>@$us7bWsL$n+-4D&%#LX+N}I
zE=FuIO%kp*qT_fj!_a36;A-DQ1Ly?ctzIT<jOt<XLKm(36;=R&dE)}?`?SI=h>L6m
z^Wa5Tf@+0ngx^X`?&62gws&>2tv(Y(kE<iXTqBU`h;UY~=T}F>{#kwg3;;bYF1^95
z`j3l?v)PyK$+)=izAyQs!%@zk|Hcefc=g4)v<4Am{r)7rkJ}XIT-1`{eB7ou(=Ima
zOOM+W=VHJlYv8g=a8|Dy@~^e+r?LL@0^km)Az(QzW2b|wTq0U$bBX9{z!dkBEYI!&
zzmYxtDO(y=Eeuk{(b7wF1*<o71l&6szEs1NbNnEBG8ABYJ0M=NMfR1=5;+%?#>tSe
z-R8V`FJPMZZG@3b?gv7pEG}`K9F?s0uq({s$SF}Sj#Lgbi5?W4Jw8fvbOjRqOGby|
zqtYlX|EQ^=bUN*-=yhOmWkd^lx5CRT$5|&9{QDQ8t}foJKLasT{cWckE%Oo@Wr-g@
zW2WYSD2*FWr5bB^BWd*lt{8Kvl+0A;yI65%4854l(SCF>E%~$u61>bQ%W0bUCZfO-
zT46Lbr$jxop5@}lsOlEZAUm26z1$(&stHzj>s2~hCgrL=B2LJC<a=c6jYb*oi&7b@
zZZgVvUzEz&1enUGVS6`VD%UD4x8uM9D&GT9QNEt%T#5zaf9TQ%LXPUyXxm=uteJ?$
zq+uTa)HdPIFpOVI@i*s2P*^2_W(3wEpk-fXh=@^uYh_$fI*Vdj*1KrEPoOyuUg9{9
zaQ=Xc*YkPpX3ENgf3B`w3+v{g%y3nMj;<2s)JNOn`!z45MV?rUxg*pcFj+KliDA*#
z>15G*z+{nz?dWZ0p#D~0U^@*k9ko5&Vzd_kX0Q29Us(J4b}XffMKW;19mY{IaB8Vx
z`CffN?jyi-)OK@QQ9DON{1w;h22?h|IkJxdk=ta1^!vGc^)uj4rGEwd(sj|HCDkn;
z#qFogei^gk>#x%^1|vlWb&g$*3`h9I-GKF$J@_({AXW^&X@UVnL|k_nXvIE+09U&4
zj@E<2u|2?SISd1m1F*hl>djr4xB*1q(#1rJEf(f9PsBz~${TE&lO`#k`Bt#bWLytG
z)n9NWCbHRg!hw^(R0QTr;1vXxNTAa))Di(v!ZrAtb0s3yBf!<0C9NtUrxZl1P!P_b
z)<97TZ_qrFsjRBMU(}^ZZyY=dA~ftx+&HjjtuTVSnfUlplXC~^DDInA@-B|aDPg<q
zaxhoeeQQj{;hwTku->GHep%}Fm?xy}G7AR15a5ErR0OzSunYlr!N5OXAq#d!BqJ9L
z795zx1%qLpM*nhdjYwNDP)svrIINc0=U9_n<Z3odr1_0_;g+-4+E#ek)+5FW&$&gH
zT7^HVez7<_r*e#qJoA)c%&8n^BOTV6smG}iaZn;x1LgshQzNo98u=0M`#>N+N4PVe
zHa+U^5$+d10GPh+X%Vje>;=plucve9wy%B$XPbS<Kau6@9&%k|o2g*D>{eaV2JpvG
z^D{|0USUvT6YMuZhduY~2&Y)%pEV08lOxiJDko+lQF}zP51kv)iySiyiQYnDxs&B$
zW<eA?!cdb&>$#r5&uSGXhF_K_A?CFvx`u`+k%wjt*T;I_1#Qj<h6jW#k!mPE2m0YW
zSs!^1FxfghAZ)dddCstX6fZ~E7Xc<4Pvo&+`%}PdiNTL}9+^ZZM+OFf!}fiExno|#
z%NdnT()>e+q+uD)O4&pHWi}4Ru@VD*oQ2sw5~?!;8KK93R9Bz_9zdWi0y#%DgCi1{
zhd_}8JTKq?wgk>YV1NX+BXB$d)__Ox-6zDR1loi$U&85rM1+n)fLFV>zG&&I-NO;!
z)$W@SkgMG}=OGQRcMmujU=r3#%?#j-U+w7tF*2PaiJn5DOC(UR0S_=BV5F6`SnG?C
zR<4{_+Gyf1{;ylog2om#(YsBY6<&3l#;#98ne}tU(2vr7{q|Q(w-}}U`r)q{`Hkwp
z8TdNDl<$}hRQo>xbAxBB_UoVAXykEH2fAZ-zGgOj4E#A@%J<|B>?Wz#&6sdX2aX97
z08`%MI*8`ljet3}k7xZVCxT1%?}%g{IHv;_5v$+8vPU~K;+ziLIQjr^R0bLY7j7~u
zrBgd_rSufQoc2%AmHY@WM?Vc$znVba>pM)iLvsmM=}N538J>yl<vFpm>#@ouBgnYh
zTX-!C*X$%QSruB^3ZwI2V2I^|+E7DVQo{qZ!qG-eq)co?eO(E@bNuwpd)#Y8GRM!c
z{u#j3ZiDZCpApd<zjP_=X^l&YTo?LfSsF&Yf}1M0_{E6Z&m;9ioq)cP)NT8IBhZ^T
zrrLi8OaV3eDWKN?bCtQtPu{g#1znUm`2r5w_FaIBr9&FH@&PzHd2aFcM}RxE0eq`2
zZ|#GoFW&5@LM?d62-wsoyxPnx7WrjnVJ`wq*%<nz4;zEg<mW{4?8l8PHNN`aMJTIX
zVB5`_oq85t92jTd%6%DRQ5`2tt9i57{u}B*Z^^*__@{9oANF(ha^f01Y$FnRggofE
z3iji|CSAZ-2v5E1&&JW*ClH<U4C?oS1Uf$g&6mJA2>cs?_&k$kFtX(ALAoyy3r!Ys
zSqoZ``>ciBGGr#XbkvFDMj}9Rag&AQ-a$G;j_$6(RY~o>^|!??WW{oEctcMhySTi=
zu=_$^cNZe)>*k`B^mQ#7$Ydt6whv^7u0lKw<bM#Lf$aIHF_4W2&_HHCW(?$w2+%-g
zK`u0qJ;k^UUZ|TV<Buu`q=8%7$W5k^TaCmtat9Hhk>gan!Z6I8iXS%PYOKJkNSK%I
zc2haimIZavtpqP_`8vak7AoA;BVIb`78lQsOP_L=iQ}5B-{_8*TA9+(y`x2)WiT+f
zb*6=qXhEGexP^;!tF8WnO$e(b=-nml@y*VQl&>{CJDY1Sk-Gr%d_Z;{C!oP6OwSJH
zv9AmQyc>hO3gyXtGW!O=Q_BFi*YJyg6Ip=6dDL6~lV$@wCy&N>5#T>#z(?}9US`1u
zq8&8(j|0rUreS?PL5Jh3ObdoXg7zd3;;5U)io$%=F4aw4D)Z<13EB9*SU~fY{ibQ;
ziv=`aQvttJOgyJ5F9Y5eZh@0;!F3h}y;wj;tPXJJ0>Cd7NF%Tf*QDCz0^U?$R)A`F
zSVe>O=SWV6<E;Yn?E1HjJ$t=?_U!e|<}k^o0x8~Zcn6p4gxs4t{V#w&OagwjfIL3=
zU9-OM8k=KJd=DBUw!oA(Yzr6yv#T~2(7xXGfw5<===8sSh)Z9>4g<fi6+Ok@0{8g0
zv1c3ET>BfqYeK-A`se)z^f~~3ThrV5k&%(9&#&9j@kJ*L{N2a!Kx7Ot@M}Abj2--!
zMn~Q#ppLx$74Raom&xAf6cL3kTl=V|c3$_0mhAwU!Ze9~Z7awMtpTHDDszI8>B}(B
zf{n8{ZFvd}kZFt6Q<5LNQ|BFw2=!F~=G|vXrrt^>KYz{oDB8xX16~8RSxWMCN(+4m
z7QBmyP#*9fBakx%fo~ANd6>44Vbv#4F==z(PV6_A0p<Z71LvU4T)H>#Er8DxmC|re
zHQTZVF4q->XmBmG6Dm468__VF2ds_==tCai6*^U+q&lWk+t5{?;$5+$QKi=q;IR%G
z&n8q$4egW}s{0H97{JgA2+(-8LxA38-si@6zK8(5%byUS@w^H`qw%yVcSr-j`2_d0
z%0Q_@CwAn#9mY@?_+r59j}gs)w*em#`)%;0s9X<Gx^O3U{C=Q+Ncy0Lt>MCfq-g2l
zP6d@U2t;>CaZ5<9at<Qc?|2IA&Q4VHtDrcyfe-4=PSUTV9Ysm+>?CKSA(zegW9RHL
z2Re#7OA>nsV4hjgus*X=(wS#gmaf*E-H6=wOeCa$s`xAj9=tIsSS#4~f&BvX)XAOM
z#r<ESi<S@;m4>L~GD@?_0xiNTgq?92WwPE(8P9EE&Z;*Ws|BMis|7e&u>|{rdREN@
zS<7^-Oai@t#bo-9K=LjJubn<Q9<lOnC+;MUSLV>D8M}DGf-4AeykgzGPFj7G!X3dT
zN;Oa$ed6MPo9u9s9LRJsSzGLVzeCMgnwkq;lR6Dv<zU99&BqWXM>b@nx`D%)EG(i?
z7)P17$xVC`$2(1IjIVJk&br9(2dY*WFPjOkE%_-VReyXNd>iAm`28Rct~oTuMeLEU
z0dv@DjEhN)lz)S6E-q*j*Q+Cs0H*t8;EHb@7cb5c;4#27QB84b|8cv~AQ>SRa$Vb2
zdyL6n9H%~10e+V1tKnII@0H%LD9&BOd3%isy;;-S4)`Q7d$+KDcISP@MBW;wi98wb
z1)YJvEiT*Y)&CaVI}~5PMl+zgp#bo^@ht|9*BZ{u19$BAQTVseN_8KZWBb1|dsg?y
zr7K1`-fNr{4;vB<lCvLD@~qr*%&9MsKF=^MvDFS#Uyf&o<{}{%mGaOKE-F2V7_rJZ
zUn4-PJPIh9R=u1w))XW<AoF@IQd<32KBk-G#UC|&gBRb0c{rC(X)dIbf@{QdF&1hU
z<9+akTSm8V%P79aP*@}_n6n>+iXfKJf2kaZ8ryzE@}%K?c|3XeIAESc)G+e(U-h`I
z#smOr`g78?UvaDPic^h^GHSiTV!Nu*Je~H6_M39PH<j9`_pyRrGk04l1nXt`9~!#>
zK{3oPAwa{N^|CR{M<YP5_8|mlnC(}LVV;YC7-o8Z6Ae|XDg^=iSBvuN%{G~pTHz+M
zCe@H8r9LVee_=j*$a{C09&%wmd&s!EO^>)RpH9g>z*LOOnBMMrkJ0dp^QqyDfGLGb
z@~NS_08cLjeUrW$8ag+x1%3uF9lOi(>C~j%YaGFu`BXw~l3toG+e+H$)9IpgE=`y{
zScl`@8?}H2qM7!!AkIzuCHc}_^`Wx3Ng)c>h(pg}>;}7WW92Xf_A15P;oeP`TvYXA
zXCv}s3RvIq`8ZEj8T#^Y<Hvb2Q1qp?eXIprwJ;rwKbMT>A#t$}R(Rhvx_X20N7cVC
z1Kp*1YvJ}=4C61=TMIt}rYX8qZ!L_z)tDj;+m8U|^26nNYay`M%nWC>Y%MIhwuKpL
z>HlwQVI(MUy7dnPTDBGj8zSI|s?tm|6AjK`nqBn&*jjM$&KmXA5QH2n@tZva&1|7O
z4=gJ4uGN*Uf(=sjO^8x2@@Qvd2s#h@`-?n<87ce0Sl<`*sm%t!WXUV~DCoc+jc&fI
zk7nKmn7c0<cr>&66VbzDe9@D-Ks_Pv9N%H!_{t|V0)DY&`+hPW!}t0KXsJmx7RU~&
zmZSbbT~2Q#<*0wqIRff^N>hpprDZ_#2<TpY1T?<dkb*tpN;i)!+j@jJ2Z_0g73GLy
z#pFEa62qbv&b5r)a)xuIi`P2>mGGfzO=FDO$K>o%Lra{feVP?}_$r9rjpgB>ZrA?<
zHx5k|De?^lXqmRkK9U^p+~Q*NP&`<E4#0msclGtwemFT>vqIjWQ}umi@XOLWy+f`u
z;?2@Ky&nQ*56IFxy;H6?J;1=f1LjU|7I%8>8*eb;&gRao{Uu<EyPe+Y9ekrvk08sd
z&Xj?Au)V?T_Hi?=VUDidaEL;kVz&*QH6QnyE|o>kGi7Zev;?r;kXsPtBE`puV6O>*
zJbO(yQSLdWnR=dYsJ1X{0rubJNR;0c4vaYxh0ejvSQi2RPjAxAX^EnjCdD+lagKk6
z-er}q>W0@KZc^e?@HQpy02hi8EtJdYR{7KdBp9Ov&<Wg-Rn;5G!c{GKvrjjPtU!AN
z{ZV|ncrjoGBOOz}p$Kt3B5^BK4U;EjMDqMr*{pq<lQV^r_5XscRM+tAN@T=1Gw;2o
z-4pB3A07Z)2NJ5Goy>!I^>vBK4Q=%V58%~Jx%-;?2uj{yFtKL<Y<82?s1xx%;i7yr
z>-sdgbYK2D3eKLBCa)#w8>MAGn$&AqrFZ3fKvyYkys6RwRv~g4V4em$z~epf;C|hh
z8OURQ2qe!E9nxok20#v_&~s%4g%jEv`jdot^EqiUOXpXfU<Oo)H=kF6j(&!s*$1*2
zAoFb(B=HA@i5SV3O@yH^nPY1K%rSuD=~m4~vUbBc$VkzYFxJpbvSwga{YdacE!XXw
zfik#+x?Hz&6X0v53odUb`R!5|1^Tmh>tjr(0`3Z_s@Iv{ZUX#C67U-u-UFChNq4oA
z(LeX{NjUKA)c9rq2i+Q*>48470z)5L4|Mc<%~u&)AYVQ`VWO<^(?Bsh=4I>nq3Twx
z19RH-VRPL!YaRY;$~17Z-D!t&$EZS`DWy<YH2q;=d&i)pj3nXOkwqPYqK$AWpDH6(
zhIp%NzR3tCAmjOh>Z~(1IvG1V8Lvi7f#t|ww)(J)lVd=Y>5T6?8OsjKSQcC*UA1hJ
z$+(&ZbD>D<^7gE1E({2(dU<=PYUDz|D@utkj{<%ZFr|5Ud#OX@#?#DW5tp|=h>nNl
z`1oFEp1OkM<RHpTqAORne@41x7Wx-QQ;n`ZI}f-I+Ryk&i!8qMM;(wp(Y-<O3j9l?
zWFIxrbRPqs2bfzkFSZw_$%?f(3;U)&II?#geY0&|XE3w`vs#j=flz!Is4&_r1cg;D
zN>6d+&U|yLIDLdLh{aaHY;iHX^1#gvB6hVxz`@aom7rf{S}4P;-XoFe=oqlg8ARWh
zjMK$#s<AN3f^SJn4>KmTX1J;T7p+(7aLC?Gr3Y@Q_v)5783`n6^WjlaiwYx_!^=mF
zFfG=#=z9+QTsIZz^EBmH6BoOE8oY$V5=hnsFk9i7CVCEpr|S1)$yY1yN{E&^S0AL#
z$?t2{iVoIO?<2<prdHJlbDl<r{{rKNn$EnjQT1?DS_<Te0Zv~wI8{0mDYm&O_-KJu
zb$kJ)MbFCYKtH+`K44NzWDmJgy4La>_K@#Ty0&*Y>>+<Y!_;PZj?^Y{A7DP8V$$yh
z%r3D!hg<2Vo@x5PeWYhM*BZsXKZnOSkAh^mnx)}tc}hstwV(fs0;BK)0K95FwSDD2
zA3D_MNIYFS*v=d=TvlZgg9bWbbO0Kpy0yRMTtvo1n1w&<{7^<=iVTAI4RweXe@4S{
zf-4hRC7HVd%Og7xImeCET}msFoVi`(V%$RtR!pq*CKo~XJ0?ckZ>rx>wKCeHRi&td
z)@{s<VppQNgWZ%hXonSh4sm1MICG3l5L<w#{l5_30x`1%K`L3(;hMT}q|BkA$;1(8
zHb6`$L=QL&gTkUXp-||?kpiw2n}~g2v#NhjO!xg-i94Ka)a3r4ye<?uA25~nekyI`
zEx><5glbjr7f3kL1u~-AtO|-Dja&ox=4{{}2vTi615DHT5b4`p(6t{H$*<P%-vQGw
zuOXZ(YTj&W7t2T8x4Lx~Yk?o2>jbI%>b6ltp%3m0BH0Q-`-L22QJFzl;h`q9Aq|zN
z&n?H-A7T$_LRHv9{2}Qf_94J@Zn8o=C|wMz!K!A2xWY9J@EtbtXEMKiK8yzE?*=YJ
zQ`mG3SJsG*dlodz?j%JQgyy4lm2)H#!_9lb)51^_h7fxP2$N6|2@mgqglmvar9v45
zb_meb0Ks$s-9rIl<gGE)(_m%@&^MF;S9ByutPrp!<O!`o#l|5bbOi#n2w3s8ziEyp
z0oeP|5V~Kdh3J08&O@3REv%I`;1v~AwZV<VP9B7_4{@8_xY4Swwz$%H8*ze*_yhj~
zKhNL`O;yAZYMmd;1<XI;f8d3_{Lt7e7cYHYR{%?<6S0AH7{-bP&%<i$?~W?{HT9;$
zFgo?l!{Qv;(rW9VL+8J0ZS`MjkZX`e)jyqs?~eA7ufSF6+Yb6HUDFoKqQTvvJ%@py
zN-g+|aHahGrTr=*`BYbCSkB1nw*Y=L<n@h!KXgS1gj)mg)<9uvpsY1e)f(vU0P+;T
zU<ddUj2r6!%fQ)M2MC^zP50KoJO_{oOOpe1Lb9E$fqf1j)ck*%CJ42t0ch0+8$kNJ
zmhFOB7?ZOM1De1QRi7<g=_}o*KZk~s$6v8eM~;StB$K}i(L5DH2JE9>>pr{|F#G&B
zA$iJafV`czPx{R_q4uGxfaG-L4p7n4m81yeEr8cZ(SL@#N&Kaan&v9RUmldZ&>*aG
zd90`HVkNii_3&NwK|93U$npGA)V%OYe5?@yj}Vt4JoF;X87W0g-wJJ4r|ah+@111c
zkv#pd=O8s?mEV|)1N0&N64rY{d8<$kJd8F5wj)@iAMXj5na8BoNCEYChw;tP{=?@Z
z&7)X3+J6{bqckUTw14mdU^1aojxfQVJ<8l22s1x<a-sWF)n9lr%OIF)L#tH1^tuk_
zux)~9!BqXaR}&bH_h0c%uE3`++?=e!Qh!#G&q0^K!O!ZXpMw^|p4A!I%V09SGh4Fj
z$xr#mT@n4*e?=E{Lv&jmeFj=nm<G{XfpmQRQf&D$M0(F{$!AqHLzp@Lmhvb|(m&cd
z@j56-`%jg`tG@522#6@HLDvINPh^`L0#ESrO<(HX6a2{yt7;N5b?8o#{9MaQ$gt7n
z44`J((bRqnB}Fs9?v7S!1uD&Ou0J&d;R=b*3#PJ;FyZ`YYCQCS@rh(=1IDg?k|tT2
zYA!Y5f{N6~kovI_pX#0J0p5{jmw~B+P&bB;7@9iQ376HRUN6GBoTTqM&f>$g=Ve=#
zubB@>|APF!bqw|cCw%LZqmXi_1n(H>_uY{?5uNJ{MEUNpEV9!(63j`nJW>+FUaM+6
zdUSLYd2j=wtw0mLHQyt2jfz&JhM<t0h>2EOscD#+G2F8{B`3rf?(>h-ukhU&?)TED
zFHm8IkMgQf8JO@A7&HV=pbrI2mRfC9od-9i{i9qok$za139F~oX2fD>TzHH5&6AzT
zqw4PyE3r}ExcYO9=_?!c@3gEQYaWQ(NXgp%lgtmTyv`q5u`dMt2=qr8_<q1#?SEhY
zaLXRRv{G*n);HWX@%Lsp39_=F2KXlf5)Xi??iMc}jdKys{-(YdFxR+6wFXZgX^{bV
z0d$3%lb*9x{w9j>c4&D^&nmwHEzUlhs%?6c)WMt6(rv6E!;Qfn4h+sbL+<K?aHK6b
zNvnK9n4Z=Yz&w~fBFwcDxq&*<vHLPvYjEwp-sWVT_(I?kgR#o$F4DG9?<Zu7kNKQF
zF8NQ8=bZaF9*2x%Vp!p3#d95GB_lE!FjrTf*Vm$&0duQU!*b%9`x!5EkQ3Jcy}Zrz
zqQ1=(yTGi~HuEAB4`A;!by+3NezQYb=&=i7Ik3VM+JyiQVCP;0>m@NKBH$jtuDVz^
zqCztMuLIaTOFhq|6gTOwXRYNOg_SPeyrUpLE#sWHu6WmsBjSnH-y~w$5SC4<$f~2v
zm9Y(BZhF~An=4}*!aN9c4Pf3O+7Olj6wC<nw$B@3UfIbVXns@Yl`wte4*^qiH*%P=
zr&lX$i!3p13d@xqdm~^T1bU5<x3iDIZ;)gG|2nH<KM9x@hYY=gfMs}4uWEY73{ut*
zba?|0Rkhnp)5Jy4%8rw@h+p)cZt`LASll(2I%Wc^>bFYO{-d?#hejjU|L8-uGn+8e
z5wU2zXa#Hju|9J<aDnk8wrRDv4KR1(w)2wPfEO->yy1$golu9iK)#L$i?5c{NVLaJ
z3mrl<UoF{$0ADTP0{BK#NA30K^KwbJ%kobaIh-92j+KyQu=z@joQMRfUXB`u(i`;R
zeW(TjF5lmVz+ubxpCE$E_c_<;<$EsJA2hU_g76>&hOe@!%XJa+JyOIW5y57?d-u{6
zhHsno?%ls<o8Glq@7{fOmFZmuUJYZ!y^D9Ea+VaU0JGS=w&=~g`BxjhzDGFvUIB`F
zKiU~dt1m7@ctUK=EM1rQP*c}&Xt%xPTC=~L;-!k}sbUej#KxL5c-$ECSNl5nEEMBs
zQEu9P2AB%>Ig6`omPDl>#qE>txS@z?+dhdt*NL9SCzkM}%N4pJ(tGW@obm^;d@ENr
zIaV6B<$iYw=5!7q{dKDWxEFHJ0ARZ6W99x>4c#$~%$2>4r4AtXzLKU?CYx^nD$WK2
zn28E*unl&l$z5F@&0O!sjgehVz1<sLZ4_)UO~eBt=1F>Us{74Gz?1am)LnpSJ}2qT
zso+8*U<1zvOaV{Qn^WHbrcF3YUo-s2A|rw`^=8#Zz~pu<H><cA_2bo=vjat=AF%(|
z%`meORdtKe<jDwdBZ^PQ>~{N%UU+nF{XxTGB9Hl|5aD`%%?RNf))3eel4ir&=?U7t
zus@L716{l`NC{!NQ`XQ5qc0~3Mx?sL#W<T*D9!5gasiro4-JXAXL=8fP+#)p9$FNA
zgY+H_SyAqj-b+gq<u?C)Jn64DVD2X&YtXbXsCJ7Oirsjn#;RI|viuj(x#I3T@1j&y
zwMXp9V#D>0C1b-iTeKJ^u-DI)9(Aq0QqllJ%nj*l`D0$PmIu|uJCwZ4VgCX&hv4gZ
z<HQ~?*w}r8p9`2eaihKr(gV&I+c96?I9YkT(ytEPK=O9RF!Nh&8rJ*Op9Pk@uj{7|
zMZO*w{(*)oH={Xr8i?|hk>vrtGIAGSzB00$KZRk%cbMi?q2~4$V24Q)?$%96Kh_LQ
z_XK!=tuhIAVid6C=P}d+{PhgGFB0+6!vg_1UJ|b|6%zl)UI-))0REHLVDt&@i6WF|
z1OCt}!1An1)^T|007f)tECM`)csl|->k=D^UwIeQa0GY=aR3;h4<Yi7OOsH0C6E?6
z3Jl{Nm-7(d9hXc5`16Ick(YN|UPeIfxLENuhEHPwbWr2CgTGBT`$J^o4*oXXY+jjI
zVHkz(p?9&a#w`nZzi91W5wb|CyU3UUIKOGwA>B%M1dKU+BxzAAjLhs?cP@D+XtRsQ
zlaX|EF+B4*+8G~e8A~1vTvngGdEmit-m5TAw+`p6i70P8j3h!o*LosvJ4DYGrs?>8
zQ9ge^$}i8~gVwR)i+Fim($MnqZf0NJ?eOa7Ug^rV(NDti+Eh9-XgA%TE^BD|inj^3
z!CX}7ur=t;6oAwHhWhEOslHBrI`3XYsa})(a%Uzw8q+RyhJPu9rn~kTY=ITH3o)J9
zhxv{Gk2VcD&=IMR45+?*ee_7mvoBvNHDMmNJ(9{8m0yfdRRKA96n$OXAQRqP>V~Z<
zAK2lacet%66eD2;gPXM&$^hU8LrUOt+|f_*WuRVal>2%{p-BcpmU(?#ANU-_1E2Ki
zod*r9K1-!i-FceMSgr0nt=O0Au-)VG3piR7I+12v_qbfK(e|f`XGb)%dXSJcXqWJ%
zI;r~R>cB5og343yW)Ue)uU3vh{0$*1a1dDD%IVV=RMm{u_xfkFy4OF0=OneD&o_7Z
zlTT}=%mIsV!lMY^?Zv{r$lV9bAiBMne)gY$j}v>U@pkoZW{~`Z>Em^VQWhxLfBV(A
zHeVE<h5Fjrznclp=f$$AXy1I$EFFGXOfUTEKk!O3mU`6AVliFXI#!fSd`{P{r}(CG
zOabD%sJ+GVioNzw<&^gt`08qZu_tsrO5!Q+=Mdm2?~@VGr@VKFL;nLn`cpp?)1T^t
zs_=1_A6b>kpww^hpXMY_xI_-4RSuNM5F%-fqb0mlb_rlw>u8BsYgnnF&+7WpO3A}s
z9QA(H1$~S*@^sK|#XR6veTnqyqLRY(Iujl6CKRNKOMIaRr7*M_|2Uf(Yg!Lu)#_vy
zx8Z2;nxD~B#Bgzjo!%&K%5{d>lL5ZM)XeeF<&;r>H%@Ol$}N|=R&he+FyCETq;Ij!
zIV_nz1>-gCa82%9B$i9ljucV0TPdr5@27Nycj1q!m!EA{$L2-e`^iY>Sf2Ha9P_i8
zq#SGRssQHnYp6ar`aIx~xyXCGzT2`NFpn&rpwsvI#hl?c@KnHDvmUO`c&4D$T*xr^
z>415+Wf<?aM9&v_XxjQnqfS>j2dWh1dDGK*{xr(7s5*@K^9rN5`{<kIict*l;zeX1
z<VrUr#Ct6E@I$7-VSRDr4ZyEq%}?1HAF_-eVc<1@>4&r@J$tA!^Un_Y;)U#asR%Ef
z=!5am0$D=P{>KFc7dC6I$5%YB1A0KM<A8dkuEG^4f&=Q2yxW0O_@ezcp&)YpZ#tHb
z{_QmFglM%YegdH%G^8C}6aAa`FI}9(&4XUZ9ASnV=eU+KV#<N411`pl-pFEw*MFpG
zEP+kM<skWvPtsN$`#0m;ji-48tB^7Z{Ao#=pZRAf>lYv3ztd#ewPzY8PGElfmRi6a
zTJQyDDeDv1A$59^2VExvX4_9q@}TU)fG1%bQ96J0WJ#-OS2jh!tOF>JM&_cV7@5k=
z5*bG+6z#RTmLmc49)pIpxEhi?yHXiMHv9cLvsiH(>seVNkrSpEG7o7ojeto;!<x)$
zO$L`3#5#JnYtA);jq2T`+?x{{iCZbr<+PD|P!-z90YwjE(k-m`HR%r}&sJ7<M1-ay
za1;VLPk_@WOW@=Q7&;}e8i8{qum))^lfe6^&@~d6JXKjYOCWfTvX&uGDZea|^E#l1
zB>L?c%6bZc0oxxz#cUM%U49@`GYxe?L{1w7ewM)P2&DZJfj1GzMu3YF10}<ck*rW@
zJx+6Bf*Lv>0sWM!Rk;G#oVlkf>t$A8I@T*Ckhnlu+oech%RZstPk2I&Ky%P|9|1C?
z09Dfrk-AlgE(H?)(6IAN-O><X-EKvIb$bl~w{AQ#Ds?M7-_&ge0#4nUK`!TBRQ6k`
z(zgiwB7yvKvA!$qtwo?60`U!>Yq`~eJvk2|wp7sD5vW1{2mQa$_z8laf+`;)_@xM(
zD0r*_pd>tuu)_0qLEM8nOku|6uXM&jBqDyU;CBPxsPSTz@ei(*mGc?2{Z7H(0p>j*
z_{s_>Jo7yz@uLy{lEjY|W)&LR7~Nn<#>lI;hed%cpumMnx$VWvKt6rzZS7>GF9Z2#
z{PblYUjZ)zQDSSPqoo&kLw_J8C3YOT2qktS0+d*;j5+hS=>~9K9Q;@Vt%ox`W1jJU
zV&wIRT`opHz$9@$wu+O%Ef=a-`-wx_+3;(OTCBn*gVBprZZc<`+c|io$u#V6$T)L;
zkYUck&m4@&>1kZmM$D)rkV`om+yp1-k)IonIQfLLDDpU}K1sjDO{H`4*{Cla(ye_8
z5*A;;GJ<s224XYB(4&03g8CRXINSuIT31RQNL|^2(y!l|TtIDYL5XHMO_2%(joSUi
z$!RIj#T#a~P+jSwaH?ctOEslH7v<(!f%iV7nuEV~IDi(gE~ID$o0>J^fGBbORV!g#
zwqO9fNdjHdly$oVu0h~F1adw>;4ujt<x$r22=HW7{}(h3UP2yg0FjB_7{&^VRn}ml
z=dqlUY?PL(FLx{kDK1Fl=8MZ5>FzaSTrMwr<jPM995lJ{3wbZ<vbGAH>D$o5RGFr8
zxs$Jq`EW*ZVmD&XMqje)eCDOIZoC3w4cTc3iC>_m?-2iGbiQ+UXEaH~{V(alPy@@p
z0~B8Dgk-1Wv!8N;)Z3)6%A62t1bQ2gMNQHTdJ7rp2~8qZt8B2z<Y&@V@~z9~{)cK~
zlGd4|!%fmzOnO=&l3u3$t6@k=wp~^rY(sOok#ZTmAYAa_I^gBJw2NO#<R*%Sx(%O?
zr!Sm(hn)}xMkv5c55Dtt32&yG66Ujn$j2E<Z`RCb8IkjVXDK(blt=_H%Q5iVs3B*E
zH|m?nc&3w^H%$d*^Crkw>Tfppk{h$Q*t}4?dnv!+M5DHtC7DVuT`nl#I|u&&%zMl?
z>wC!`1E#yE^YfKnD}=@@DZnB>YR)~MK?rcq=VAo7=kovp?w-%^4O-s4h1-AK^C>lt
z?r@f}!laZA+<MPPZXj|E*~R0cVitR;pyYmo_hns(Okijmc_Gm%D>Ly+DTq>xDyo(X
z36a7qBZ%70>>&#QQ`ohgsWsaGQxIo$=FU*3wnh*Jt^-U#oYh$-p|W2>LDY2?LD-J~
zP5qqQnNH*z?F=iYuz3BBk*VBT;mn1d(|UR3IU@4(EF>pSmmnZKg}3Ej?()?Cif(Sj
z|HV`1AtUm1qDlEzo*sY=lLuXwx_GmB7F_bDrmg$jb+^lnh?-mZXVl&NGx`zy>2?DA
z?G+|%x6#<qS!n<(JWHYH<KJ3x{VGxacoBW=DecYHalDAfG`9lgc{z<2F0%jS7jdS4
zTv%C~lgOSZlAk8CHv*<YCP~gdwu91-Z+0q@QzZ6sz{B#8zMx2!rR+>wS?y)iFV*lR
zfH`3+DdH{6KvY@xiuuv$^~vW;i>9UN`d2nV*<}s%7g;enjWn#-s?O3fodRs-F=f#^
z*{8xN>pqFaUuN9mCX}g*%x<eJ{?_8oRtRjR#N-FK_O*(GP3P~QS*9*B(n-4CZ-e1?
z<D8X#z1ld}?0XM4coL{}6KevcaLX=i6(<GB4>PWG<DA#YWEJ0rs5i92K<KQ3<#8C`
zEOk1CCk@65I|{KCNmc!89r3-5Tj`NMq19YgyseOGP#-jEpz%0Hxbezvu;l8_!sDKX
z2s{g#ucTfqD-^u|yza{LpkQiwq5NbX;5AqBWzQ9bvN~dK13l`=T`bS`=a?DQ(n2oV
z^aK2bj3##!@+a-?0?Y>zbpGm2Qg*m#{vq8J^omke(JTWW_q;51`HCtlw0@NGX2g1Z
z$cTp#Cjz0~FO<0wk0PFn0`yVD`8fR{{~GWgs#QuO@kOB+34l?WoG%OYs}ha+nNbbe
z?a)`+L3nDXen^$)VRxBM=O`e~v<I!&@ry9L{}to8rWwMMvuRnT9imf`{LWh}E9u6K
z*1t3-$VMyxJrCrCF4CyE2uKVt<Y4hA-aL~c*85iY&u;RXmO>Y`M6yunMw{HY!@H4o
zwZ@3pEjmCe4A)w`N$G9wA!SrkUSV0+lFHn%(r4nMPFseda{b*-W)==adDxbXC~Q2s
z*F-nPD0xW|trW}`z)Wkwpu1cA1*n;B92Y07@|&@U;vMJZGV(+SqVQ~R&>C?Tf`O^{
zBrn3}RV2!)DXqvlA=MQfV;Q2dMp!)H)dmWZb)r7tbvm+Ujl_wlO_*&~WS*9K0E(54
z$jpgW%7aA-h9~(`!=jcoM&i#1rbe{IuX<uk$~-fg`ZdRdYvZZo!zRsH$y5q-nC9%#
z)QE%$PcE~PIUsU9kg<YNe=L?-f&9Y}70b0!vWwD9!bxkSKNe5<QBk20%ePX4V09Tz
zAj0<)8l3L;NQ4))hgf{jJ<I1GaSrkaX5iz$2%qE}eAYzJ#;!QumTEcQc0{Z5ZRn@v
z*P*EP|4AcHpGF>i!;Qyx19HT^Y9!VMyss1gvEX;fr!&M|Sc#7{;&Z?Ou@xisNa%Zf
z{J-FnOapoVY)aNqW984ltlq3eM-QU<>RQMdsjPm;Rf@Eo-TO$^2nm+&09U+!*Wwl#
zTj5}~?&4!1A65ULtl#~ioesIgN4xe%XZu;W<%a-sRrin1@~~Cp+<zFSLZ`=j7jqO1
z#36bSfDh=EA*JnD+FWDjJlf9PHqVTQX@wjQ+gy#G+!Tl1z{3G^0n^KE4f}{|j011z
zod=kYVH<icT#Ho!R7_cgT)LXr0272pE1h23#hVL<w$}}=oQTC#yAGMSCSJ%wDw`1*
zWh?7wovS+uU#1iuXs2^o@rgkl67Hdm&HB>ps6zRrCoDrCKV!Kb-c`4}D{4ZT-AL2o
zBLB7=O$SEOQa2QO@q-X^)N;KL&gt+RBbgR6!qskJvlWv$<RUjg>q#x~oRw`e_}Cjb
z)DkoekXf02a}7qF<*arw?z9^(xXA2R3X;70+!Ui^TaR(`3>(B+2_>;sn_9*3mXrSB
z6(JD~>DD^QW!62^jdKfbZYfxd+fFxySslGb>I_7gVV?LX@_MB_3CC*9auM8tWa6-q
z_+g3VT-$ILQNtfdL3gM%Q8Ps<^(SIIS?$u@VH1SN?yyUDhtlhm^=c;<pIei}#*N7x
z`{fCUr-iy_ZZqolC?Z$6ky!n}h5j0iS^+|9T@*$X^zN#6W9Y0O(M*UjC=^>_mFIw)
z*_ZuamuRi<HbY`CYyU$R)UJoVOEM3&rSEFsHv#i1X^)`Hj>T{61PQ65gN09`ssVfs
zxb-n-D7fy;<B3*SOVc`$yHT_0;F{C3v*|4NWnmhjcL-+}iG{VwDvZk|fSP_sKE4gi
zkEu7^tOgRmbe1GEuBW*6hvmG!C~&x|-`f&T-#S)Y{VLbtYkgA*g*yoN=MZn$kMB*|
z+3yeUn#JFwo&ARZuRz}fz8u3<WItd|p>AS3z_1|i;w&iQwZw@rEI5j`+^n7bTL9Ck
zYa-06g|%+2Fql*JxIU$?R;_SRV?4npxl$w!xSl$K{dka46n3pi7W1Q#o7_CwtJSM5
zdeb2Y$7!pJXZN7scA7Y=Y_|!41rWolm_Vt!4->=Pju^;=yUB%Pd*6YzL6@%fN&doO
z2i>29PZp(GrCIzDctRGha!5a?v7#7Qu<*8V(?U(WTE#G+qJFuB_^#Dta4t%dS?iGb
z4gLwR`eNz?lMz!CWL%fT_j#T1GAHBnPR1w2xIbScL!(tT(_{oIknvhsF@Ke)$k$HB
zSDDc&n`e@umm=xO@Icg?x{P?Psoa}R8Kqr`&4ChGWs6M4Bs0DsqwQ9m@hm6fRwpA{
zwY4bc8OgZzu#CM#T%YNT4>=h>J1pa8MYd$@Q&Enj-!rM{px-lHUoPB#Uo-=4@5`dT
zFPg9nIRcaL&8){~0wB+3l`nrwJsVZxdE<L|Uc)BQI#gZ+=XpbU6I~%6ad14Fu*+~O
z0tDVv!Ng0jTm;@y(ZoF<K;Uhaw92-aHVp@THNCeC{fBg$_B(AlbXc1Xv4-}YadU)Q
z6}uNhc8Cnx6bC|6f#k)IUI_4F$bc?rOAxN1@&msa(Sr~XYLlm|kqCgfNuSoW8LY_j
zu!ky39}Vb(L{!<VVwwBFD3MiJ#U)^_y$e|063Avnc&)z7&=PU0_9*ZlNW=;~fdDIH
z4Z0l8ttu`y2Th83Qb51iQd}$xI?-jqjM8HM3`5yQv+SXNg<zeuw1=)<ZoXL;>Om5b
zw1l#r6{FRom`3X=z%*JtxZ@uwOPY0~9>q;)08WPKXFYoro0kE{arw@Go&}p{(V^?Z
zqYZFt=6kq8*N>&!OF)fBQu^zo4W9t!9!K9|{_JH%XS0BDRIv!%z8Ekay54N0{T$$D
z#R3?5c9F4}22Lx+?yN9kKrtP}wSZSk>vehYhFA5BHwjipQ=;d`YmN>0*K#<=BJmoW
zlQ_PUvNj?j)QG?q1adw^U<U#g6V8x?Cn4dY0+VnL0+P_uKlLT}3yaf2#}=AJ#90V%
z!Rwz0a1rry1Z2Sr&(9&X{We;{UDTO8<bj`5fKctLQ2(_l5WAK9!dVN%%E(Km-Kfux
ze1$}OCGJKZM$sEXHx_fjnOBnsZ`7@Jyq>S`#?qD>CqHiEV3rKP&NI5I{QK*YS~Hf^
zWSO$T#p|Q#B4cq87mSk`E8hi$kBh`|vwf?ZSUX(adtfA9cM8y_GbP<pH%_OMwY#i0
zoOI^re*dck8Q==tRLp5r)na^VyPQ6dXtci1BidvIYfRdC0Mv95IUE8JG|o7Q^x9Lz
zWlg3-u9IZ-(R6$t*1e}|iRnEL>)vx6V6Lh@O#O_!4Vc~i;bO6j@gEH(vHDoWIiNeo
zle%*_OR7&5%aW?qQ;bejX2<x)q3GFSI4tAD^kAKZhKGv<UX#XIAaEAt<e_$J$QIMa
zaiF56UnG@(zBm#oHCE|)$11Vf&+Be=9<Y5RWiz`CcPUCYY3^f@*@U#wJ<tj1-qP$?
ziF{nQdW-CE_7mPBRSeHGBySaSls&PXEL{G|lO@KA{o3l~sbBTWQ#^q8Yo6$Cl+NbC
zJQ1D#_4nWTY88fEr)pve>IcX`-?u~r9_f%W73y2URqyG5+0ecvT=m`$_>7kH_T@*I
zW$gYXa*oS>0Wf{A0i<UiQ)Z46XuMuPtt%P&mgda>+54I!KHSif^w6*_W)G|h0oen~
z`2YcKef0oc+4|CZUt{0Y*(uFw29Peq6;yObD<(&fR=5~hFS25?2eaFa8!LMVdKToI
z;zXLkH{fokshxCc$tN$D&2Zz`=fFb~F_>zy0&`HjnM)pCgf>&C_2i)=)OvCdLgfXJ
z`V#)8OWFFv$c!uknTs`<uN*QLA4cZl!^m80$XIV{j_BH)+!<tMYck`zn%c}hjLd9@
z%%>0=(iTY%D;s<mnV&#YHE1$#IAj_QBh%oJp<CBbqTRZorh{om_X}~kZq{T5bTi%P
z<`Nm)t+E=Ev_{IRuaH4{iB5WrlXMA_Mm7PaW4EN_77V13KIO_{sY_U@%nrDev9v_i
zX6#i!QxoqbIs2#z3_vh<%D~S7{+BqMx0i@ZW$y#bky69@RO}rkau7DY+f-7xYfm~-
zSx1U9xT-|nF2~~utFTs-uFa093@_Y_j=M3=p8GsZzt!l9|B6TYBh}~`CLT%V9hL<1
z&lD=yafYHvb}z;rZI!Js2`f+yHGRH#Azy0dEkY&fM18557wfL9yTm|!St9qAj{OXE
z-rTAf%x$c&6S0J{Xh1r(Uz58U*-37{Cif%Y=L%ZzXI2{W`$^t@7ciOoqh{_=Rao+o
zG5v=U?$gWzOyT^Zg;Uo9N-9cg;H`ikNdW%2<Vo@RPU)#E9#j5_0<rG|Oko-NnZ1<0
z7yfgJ+zYoy0p_F88qcMfxGYEFUu@=sSg<yL3<3JNY)B{8?jelME@reoX|3=>l6p+7
zNy4VMXuVq^S=PF7|CL1+84kK=o#k!B1p|)0IGZWgpnMsQt6Yp;E)FNn#2*rakcUZU
zdO=I2&5g?Xr*P>7atVfpcjI5sJQxWq4;yaKGWZ<uWs>`44cFcTS5H*p6)l4;fVnL9
zD)I3OQ*If`wJ&dkKz&I3I+18VgE18iQmy)Rs7B~HaQ$To#CpREmB2*^Y)2rz#-x@Z
zFz0#1euLPYo_%o62?2d&e3MBdGLb_JGS$`3S8OpDt2_oB_nzWmPdFoqoZ;0ULR;}q
z+%Z-Eo6P(c>0eJdZ<raI7U^G4c@r?VPZmYEW83Eh<EiWPFd+Iy+pYS?P!<d~I=YzT
zDmTM6+4mw3z05lzT=4u8FcooWM9%V6e_4X^H$}4ktt(Y&VJZf~`o`p164K|(Du7V0
zMcRfAp%|Vo8#2N<!^Pj|D&49{2sgBUX?TJiZCT0N>f-enrnf}EGd~W|UWO6hRKW~l
zR{tF)g2tjAi?)`!D-@|7X*`#^LSnn^I{`l`L&7~FF@1b!?SRQ?m2bc>mwk1sg)qs}
z>NUAO<HSdKi)Ta3`SQ1Ts6wAFH(?%b)QR+d);sw!7m9KsWWp8-SMTM^wwFG=zJ)}i
z-^yfUGmn!*zmQquyL`}7|A^lE`SJ_&{q(!g-{y;5kFG**Q@i!~6I^eQak@={#qsrM
zZ=xlYFCj8T{u_k>M<!$|FuG21m@v;*mM3^fo`)h$m>yC^LOi5?(Jv(P2|6<mx}M;W
zC1z49%p{FLCQe6YCfHm~MP}+!_+a(S1g9eXqN`;lbEU35e@kR`LbML~iMg{CW|@N_
z<;ATiFK$J7v8IemBjCUKhWcr48hpb}6XiM6-Ru!jD*hfSzLv>%TA{-mzSg>`f1ldZ
z5wspp&=-nas4QMHc$}q1<^kqa0}W#~Ttlfp#j4vs0L?CH;A=0z=~GduC&)Fs%}moL
zpC);`8Sp642!l_*)SOpdN3q(c0OmOG4B27-3Ygv1z?WTyW0I2pNlKz}2jp+3UyRm>
z`h7&M*{fzLi(0geiFoGqz&E<Z&C-pwCw%xpoWsw&HiL4jBc8&N9f^!k|I5u0&mV#3
z5zlK7!y}$gBj6tKoFN(Hi05f2oaW&O1k4f70qSv#-jX6anI0;*0{IY;^AS=MOJFi$
zx=Y|u1dc)=K6sC=ZXK$dvlFo=NNkOXmBpqU`%175v4~%7;^E|2Il~Y?nemlDbOrkg
z!0GK#b}UK1=_$baNVz^R{0(6C4V$nzCe8!HaqnJTjd37s=gr0*yY!VKc#7Gs0nGk#
z1dl<Z9urLRT1h?^X!h80mK&W?h^!S!S+3#UPMt|i^LAtsPpRt*9NHRMMqaRnSW?Fd
zu$*n&;zqVMv8~TGilN>0t**2)Suh6`d5}@IgerDB_|{uO?g7eX7p<Sra(<3p?@zb3
z><cF9!<1gbezE-eZnO9%a(`@si{a0E@czTvR&fp3=az$qn_I={DUr~Y)AK6~mz+@{
zIM#IC8Q`&+F6Wjpqo*pXQ9Swj)&)k9`}`o*=ah8m*TzPi!XNh2w~kKHm%cdhIW=7-
zk5T?k_;_Z}w=(~hE~hX0MR`T=^mMtV)i25`fwk$POajs^oW)ES-Pf6S7{-Cesvhec
zc>SL{tdZxS4_qnGu(<yRlR)3ox#|h1OAH%n+^M{STS@jLz$9(pcL4Jwkb!ONv~mW2
zduJ|u4Fk-RKr5I(%5A9IxDBQECm-)Tw5|5x;!8{b4uTB!S)DL$sOOmvd*7(dj#jTp
zz}t^aM%->UZj>4z;t<3YKpb=tX04w}zzqo=49YU4QH01NTU=Fc++kZ>au%qr6-snr
zblUaCt7<Tq*qflRvQ;vkonw7uPi?1*X|-{-uO(7%oV|r%HuqKfW#!0Z1w;zTqwzTh
z_BAg(ISj!m2*&**=fr({_~cYX#o>W^<Ov|}NaPAyRpro}+&5i9+_$!>79uvEHlGoN
zOOUnjetfJEcj6nk8y~-vHe$7a5-QI_9&f$gc;`8bjfk~Ih}&3oH&ie85KH+Sv4!6g
zwF}?C9(?>#`w=ozDi2^J@J`ZHxP4!B4r-ftmwEX~VB^jT$R1voi3rU}mZb*6Y2Jf~
zWH&37giClp!sY(d2T&2uQwUcCQ_GPyTf#?%Q$K()F$s5%ruJYBpish<@zhrs`$(rM
znW{uQ!#zq<HHeotP?J3?QZGUa%O!oU-l;OAkvb)N_fN$N<XRuXeFml~eOTC%aP`pC
z$uOJ@A2Tj>M!pFTs!KH>UY?>!j+|-n#hU*>q`n0V{wsjsA{ySM*x~fu%HTU51Q#<n
z9Dcd)W(K{W<6FopB~6m{pL`VOT-40Bwo6y|=fQ%^)R(B-*{D!K&`SLR)Oiw)`1J!i
z1HmQV3TC@hvb`K`HfE~^JX6zui{QIbKm3%s9%G#hg)0wx_(?-{1F(<Cyz{>BQW@I6
z0Q?jt91i^dNIMVsDy#ed-{j=Exmge(K-giZs3=3Uw6(2_Kz2eB6kFSCNCHH&nuMVp
zLI6ce-2<&w?6B6VrA`Q_I9hRIwQlPuwzS$-16F_5w*U9%ob%j-Tlu%Y|KGlv@AI5}
zzWe(<=egv6hfhahy#FN6-uL?&@6XB=^6f9-{RgVQ$<79D-*d|TBrT-nZ^QX}iCf6S
zG_?!4#4coL&Zd;eoAMpq`|y)_w+iJ7_tPL-c(+qu?xud0cRST(cDzyF+QwBRKU-vG
zH6!JmWZCUe$kO*K&Rpmz;Ago&Q%ZA+{kYudSDCFeofNVEK4I3c80sDfl=9`=v4XiN
zC+Cj)3Z&O~DW~K{#*I4Kzbwv88@H9gKBP;^skyO8hQ6IENZ(FuLr-&if!O!^&^4nl
zL#MD=(=+)8kHLfaPD;jPnpw3sNiOmvMOpSwBx4RWv6Fevs^KXryj(VMtl+kk?up|j
zjEF>(4@y}#F*0rwL8|OW%KC}1aX&!@&xRjTHcZSNw*yk>hE&SA6Hgj<453G~hnMpv
zwvXGw0QP0$#5LpA(oCG3a{k1N$9)blu`d@)+&u1HmL(IE@|}rW#@!rZVAI5##=Xhx
z79HQ6c+0r&!0z_t!iihQy%8{g9G*)j-Wf464i>qokql+WGe)z70yRD#zA`&ArtqFM
zi$CX4W?oJiD>&Ian=)=K`%=7Qo+E~w!-EpD<~N+)9f69lFVAy&mw|}bmlrs_iy$Ym
zjON9Zf^p}gRqV@4DU%`@iZ(K?(QG$r3G^~YMjiHT+TNz(GL#O<dV~fS9m^I@N?Rnj
zIpuSZ8RYkZoRrU}MaJF9BL76IlrN=4j^3PdV%oTT=$f^Ik}ps_izVnsAXC1Wrd<`m
z{a#;Z=>BD73R*lZvVc~xlqRHeOk^HRl(sPvIf7w!`%J=mTBROO^Y6pLsmG?C#N*K*
zC1tRA8{dKpVSg?_+|$fnKzdqQ*iZgxN}GO?!Az*&Ik@d2WDR7P3130^MN<~ewl8pH
zBt7@yl*maC(;TU$>1%mCLA6KO*VlP%5TTA<pxUlWQX<#FVP=YIV{i0Jd8Gf2I;A|!
zRMoMYN&5Gn`A@q~X?Y4JGs`u95WO@dvJRFp%k7}myxP^Bq1p^G=8=<p*GT3XL?!LU
z)X!6xB~(PRbDDi6m}Q%P*J3+@+rmLQG{}Hf+OG}=8JGsK)9y;m(kPLfZyvO+bB?9|
z>fmGgzcEpdx(<*&|1!U(v+bJhrQ=QEaGC!TWw>9sHT5kl?P1@bUF&MmzhYr7(guSj
z2D4*dq_Km$c(vQV$f9`C<$kJ55>w$7(U1Rf_lQl`X_S;fc8GNvVvy}_iw9pLa%@o7
z$PoQaUCN)I(=GLcAtG?vOh4Ef4bt-c@if2AE^7@F+cB@R%X*zx%NN&KzWCx5ep%OR
z)V#_3IUOr%evm%2i>jHt551X(FYz#J9}guwL^6b__Hg-WclxJW?A*U6U1xq~=N@~d
zpZjNa?r-sWvv}ucnk@ZQUM)x5nwWd5=H8k<bnsPv?jj!S+$}ux&CSntFc<%&o$jAb
zWJM`0`Y8gl-Ol|(I@o=0w{xd%_WRzheFtCT)w1|@OP!s(+NJCeUemL$PKjKCN;5mu
z*kUDuS~T~i4{fB%Vr32wc4gn=p>Jio!j<J*oA1{6O@>Hm(?9fJ9*w3{Wy{%lR69mO
zN83`1jb|9<3eEYrCCtccT#W8t&*$|OX*^f^Hm~_8cmEpu9zXmc330VY^I9ljx37_$
z{1I*?+k~Sw4R2m!C3eHFY4YKzmqeb|=x@mJOs}K=XpR1+Fq!@wuU8c$UJI`USLi2S
zdjqd_-LCNo*Wp`;#&6keT*|9mx2wI2*W=aK)qdvtev`H~lD}u9TWEtt*+mR9^hTOo
z%fpD2g*O3)#jYo(t%tLCcu@~8@UTk{&09Ft<{`Gv4>OHnhP^`R+mv!v@Iz_o5&DM^
zA}OQn?nk8Tr)rcHh!H7T@o38x6K$i>RwqtK5f(;U?OEW;t?C?apT~^0+VF7uf;j4D
zkaf*4^|~Pj;-(JZ&kJyM>Xl;!a#JrGr{C_-RH>I^LcsUuAxr8NczH8Nx$W=O0^5!h
z1x~b+kN+o|unRuXE_j01?I)&ax{25Rke^>u>o3|>OuV0WOA_}!Nr;>#{yixrI`rp1
za0nf`i3f|)+i!4q8#bO2i^*T}V39nPk%Z(}tzVi&=~<LIltv2jN4qu8v}<mY%kvet
z=C^2N*Zh@(*8CN_=Ez|}>fw{w{z;J|ZkWUr>5=0YDlPIgFc#X&?;Xy+2licOFU$N)
z5HXV4|3yES4#H+!PlcKNBR<5H&*WZL@p>LcC}qZt)TXWH&uM;~K+$C+u)iH%74Wa9
zDFYITzLv)Dr)aG7zCY?5iH!xvL0ZPoc+PzK2)@})o06rNrV9e59UI9ipzK^dPmN_M
zromK3(x&BRX&jIdNt>RZrI_Y6J<lk}QcSa5&&N&5QcPpVnK?O2F^zpbep;4dnupcq
zgjrdNX`a{fXHLpeOrvqrW))?P7$1qesq)WOWhth4SI@H-XDOz!&vTY%DW<W{b6006
zrkN;QS8j}CpF`u9CxE$2V$R*LB?@iK<=Mz~M4^qjGPbt>jHKC0ML6avTd4@gTxuT`
z;h4*^pQg(zYOpzW6(ES&62&~`=k`%CkGV6`#ymk*mSP@-%|UJ?OEHhMW<bni+bZTU
zTkNA^9`j56!}gH@Q)!bL8R*%js+cMHZ?T7`dAQm`TiNeVUWsd8<>9_k_uf$M;6@Lx
z^{`)8`}m%3KkdJ4zq!JVyS386y&fL$FnRp4g|1zdho^a%R_)4@+voc7%^n``a8J#r
zx6kwC1s=}yu<8))57fGGrk(8I=2IM;_2o|=|G*+w{*i}izF)3~c^-!2CGY1AKmI-s
zKk=}6@u$ysi!a~f;d36odWiOGzT(E&=;0<0f8^m!9`5omd3{}R*MEzLtLxnRE)Tah
zx%a&uzUSd59wv{s>Ho9;t9~6*{5TCu-27Dy4z5}5;3f}~=Re^4Z$90%%k$$Tk9WBr
zH@W|A-~M!8zthiilHad>JVXC&I>i2;IL+1Pe$~NQ9^UC;@_cz;bM0z9T;t(K9wxV+
zd5HGc9-@8PQaAn{4?pp6^da!K^APQ~Epy`}uczP)S3cRpX&#>F;Yl8*o%!kgPx9rp
z9(H+nOY^6<59`<XcH2DM>ESL9U-d9~y?gz*cPiZCzil4A>S1#GJsqyys~#TkFt_v5
z*EjEdS6=2}m4~N!m^}Wwe{=0~KXfq9!+Z~u+ZXuq@LwH?edPLu|K3G%`-cB<_3a-!
z_}<?g41Z8Qx&4~|W&2&e{caDR@G$&05|YO+^XsVfaIuHszj=_{exD!jJr56f82%dz
z$?fy}c%wZm@Nklc$?ZdYeB|-+iHG68c97iuG+%$Zhs!-|_Hez2H+guAhj)6IJl^O}
z96bs=ob2H|50l#`x2yH-HXWk<rhmBc!+&vL)<4~Q__Ni?<9Drc^?O%4n0A(fc^+;%
z+r5Xsj+@;7J>P$d?_cHN6aSCn&GYka@^G_<TRlvkf3#oUG!K`1xW>ce_EWy;_H((1
z?cZ|mt3Ay7wtJuE;T8{fdYC+3L(+Kvsr^3R{#_3bc$n|!PaglYb#6WF9<KKAn;s^&
zpSj+(pXK3+9xnFqbPrd1nB4!ljjn&e`3@F&Smt4J`z~L8i-$YIb{Dw*$?bPv<j23%
z!EGMy@-Vsm6klHE;c^eRc$j~=8)v46$^B2d($z2b@FoxM^f0;ol&f6(#U8HlF#M-{
zliOeH>)-Y8)y=Md<Z2I-JNWvThuI#Mh5eG+Z}jC#^60<a9zNmW9uJ@MFsXZF(>1PN
z{`VXl?P0^UpT54EeEFRoKJ4Me*L`~XEx!Cm9&YvU6Au@E-}QUd!{qf%x!%<mc^Ljn
z_a~Ax(0}thT<&4^4X%8#hc-4<yC3>-JgoAt*2Bdfp6+4Zk6n8^Nxwg{{5=2L`Sbj^
z{f4rS?S5am|6w0*g!@SvV7c$#?BQg;?kR^@|B1f*2@kVxbo&hdjrOGBBVqfKeEZWq
zT<&4BhwUD&@o<-i$>VLk$<24Chof)t@3(zAzNc+<<tKVr=HclcwtIN3hspCjal7lk
z$HNyrJm6vW9j-pt!{q)Ox4HUF9$xO@W)G9wZ{6<N-|68_4{Li|d2;)UeR=*)S0Da(
zXW6}<-hS5(SH9cBCp_HeVe<G7C$-<>-=FjFRS)0raIc4l8ZTVmNq)U$9@ctzqF;B>
zA=bb6ez*Sh9!}cj-WxnjUjN>QT>SwL(;jy3;SU2Px6l2TtDolKi5{NhVRHKezWfsp
zbIHBvzmq&nZhwpa;ghW%-s#~s4|jUF+rt+<e8a=!@%H+!^A33Uk%wviE12Z=hiW(a
z5bbYz#N*GywB7D~w1>&#PxI~C57Do{_nUc${*xYc<DcYVk%!?IQpxje_VqvV@FoxU
zc$nONuP^U<%*|8uxP#$mO3CfF`gYqq-09&H9zN$`o*yT<|E?$8_z!!y&%=*AEO^q@
zZ}KqmlzUI}FnPRf&$;@Y9`5q+VGnnE_=JahJbcx|<nbo`#*Mee!<#$|e?7e61y{et
z!{q*9`<=eue`+6&`=W3Es)uiQxYxre&%1e(=gWQ3l}~xe!Fe8*d6?Wj-?uOFaEpgq
zJxp%@sxN=T!@VBv^YC2{4|w>IhvD_@|FoW}SKYe9UqIdZx_j?>!|&%!2Ost@d3~4r
z{+m7A;^9^gw|N+jpWOe>q;|Xhm-8q0Ki#kUzg_<uzjgcj$ir}-;ibal^&aqeD0<8F
zJMgy0)9)SJx6i@sKRS4*{%O8{%){jIM*H!S`%m`mr+7Hi!&x4l=wb4BANh60{J8mt
z8h@`_ce97{e7o=$O85T3)z9+#%=7y!I>de_`*CJ^IO`DO?>@wOo;bw(;V)q(<0s9p
zFXmyMhxs0k_Aq%r`+WIF9%lRfC66EeOlY{T5KrwMzsc>xp8&1(<DTZ>at~K~c#DVs
z*59wA*2B|0T<+m&4{z}>xqq&gr#ue}Je=g=G!L6SOzt0+-{R{p_VSf?2z?OVDqsAr
z<CD`oZ1=Fs!_^+{{j+QLiHFJaZ+pkp@APn&hvAjw|J46o-~K%hKl1Ps5A8V{lV<z%
zjP`KKf4RPVzwXf<PWEt{hvB{o{^ItLyuYw~lCPiX;XDtEJS_9D*2C~(dGdHw{zrFW
z{zrAPJ<RoRw1;W_XIf$&PV;cFhv6^UB#*!TKa8K;{(zrvm;X(k7d<@D|Kd(^`>OXG
zp1zp`!+#b#gyBy(hA{kIJA~o)n;~58zex*W_|Ig9FubK5!tj%|5QZ1IVnuF!;lJY<
z!tmd&3t{-{3n2_Y$qr%S+q0+Lc;P?3k$^Azau37nqah6Ol#IVEt{Zm}UCmApcX{}*
zhr2xt)rM#H<l*>tGhNX<56e8P^03y!#U5Vn;bsq$2YkbqXLH=F|MqzJoQJNo?{6~~
z4D?^Shg}{%?4hge``g~NyrZ$MA>Oj0t8sO_p|P{8qwTCnOT&_QW9!Pesv0|Nu`O$9
zYG{skwsmwxR<w3DEo*ITDCk_S*Osn$dtFCkD^G1J8{-{K%a(UV%ID3AcXriL=7+0q
zYd?$m^lxXjG{oy$04rKs>e?gCZS`lyn_8E)*{1a?I+%l5n<JfF@z&<1)-w+(U((b!
zeREsuvI6~ybe`2&-`2V`F<ED0SDdjso6c^Gv^2)sI^*tnMOSBQ9p4pbQC+KB*=GaG
zUqahuP4$u1##Qmo6-y#5AY(}+UNbjdxNuSN$?>^mvukSN<+B&tvhs!Ts_Np(#CvsZ
zP4R-n+w7WCE9MqeS5{Oms)-j@+8*-?PcEKY7{1M(cXDw}W%a4?;)?mMzPzwp?^V^6
zwS{wQiz_QE_7)V@#^+Sl7TK4=ih1$5mF4BdwY7!w?4V_ZCl{7YkI$Psdu~x-oCQ|S
zjj-(*k$8M%UGs{@<7Pxc`huE<gUBoNbTl^Ccdd@J)UT#TbK5HZwl=PI^zuY#uIucI
zEbVA)tcSMYU}rX-74Lg<tkXs36-}*O(@&r(B)BG7+FZA+lalz7j=I+R<?zX}M!myf
z9UZV+q@{gEygkz1*4eZ=-qP4o*9>FXdbOnciq7Ts)vu_lZACo=_0UH{i$#_+pJ~b5
ze|>OIW0#|{?^xg5*4Y?Y8t*!*y^&wuv}6{6E6U;(Az>F+Ruxvn=T@IuRckR^GyCMi
zdGX?THTG?Oaam!!=G2<n!gBlWT2~j&E~_mrFN{>x7V$h!M4Vd)x6~BPuJ)8#Jg4UP
zcyU?PaWmqT^XEes?Vlx1bBI9HBpXW`rbU_?TO&;f1RSk476&k8e+;yDG_C~O;ch{C
zV@GRUbG*3;T0uey3`B^>+m^Ch@JrJUP!2L7WV~JE0Ou>(+Z#J*)raubwuZ)d=kktF
z;Oyj`jddL$ytAF+uBDOsx@M#`($WI0y6P-r*1)Bug{SsI$)bv4Cn(@{cJ%^bSIVHO
zy6|NCP#LeDcS^N=tSDSu8=tqRs$cKLa~H)=F08JR6o^1G;#G5M;<M+@tz1-5TU@cg
z7FHD2o>Ey|s#oD@wI^~@Yg5<s2#BbwKa;&JU2PRmXM1x~7Ye2UW^asZn=N%bc1g+6
zYT0z@DXB4WCB*1ljxs|c>d)+q)Ge!PYK?TYb%EiIwzd{ATwPaFi%=lx0G|xu)J&`1
zG-D$gN=l}EMOT8)ENg{~276Q&R+S}m#{7Bl@&)CN>8x1Kj610=E3PQ4DgJU{q^`X^
zQpXBIscqL5+M8CkvF!S`6%x;7t!>a71*fffxvQ6$wRON(E77NotLvL1h_AFhVzp{{
z6Qpfxg;9hUw+V1y_5A9V#*SqO3}ZLM+nO5^;%^1MuB)pfj(oRUT%khgX8EVCp}`WU
zwt6-SZ&6KQbsRNSQJdK6qPfUL;%zo+)aufCg=Mv~ZLwHI%5L_Y%4#o$wFp+Z6GAU!
zHC2_>v*#7hjWYqv;u&S`L5y>-ezaH=KUEc16-F>^mXVuUI~zN?;^0IWXkW%gF@knG
zmUV>5gw$Y9LcAhU*t+&eQ`^e8WOiv?Q!{*k-nDEkD3o}%Y`03R5hJr2c2PyclBT%R
zNP25q>69Ha*;-40*2cz$NCPI=7Kty#-A?Ybj~a`W1SaR$5(FZFM46Adi>j-^em{~p
zYM{$%J=&Z`i_e=~JA2OTn!?0vQb{w=l&y{Et7(yj6)i1iMH-qK;#Qm_U7bstnlTJk
z*(~j(rpp@8*0!!@r*Ew8N6EKZW3T;V^VMN>Yh<=l^!4#o!e3oiTa%sHDIuqHsE9W-
zi8;ZM5a4xqTSq;3sz+(ccsKEXbezYNMV+JV($2G5ovO07-P()@1a7E9bG0zEpfI_p
zrl`7)L8Zju+Ec2F!BD)ca&D>PyoxUuRy%9mUpraVURE^+2LRO$up?U5JI>2+g7fCf
zGqCl}bS$n~FeB2sq9w9q1$(T=`mRbynYGv=xZS)wmHM`p7GCR{8|zw8_Ii%P5|a7Q
z7T8YoXcUGaL4BwgEq_WCwBlpc$Ionv)O9#UWVEGD@;e&4I?jr(>S&VPY_SMkf@>&u
zXzKE|md2?KjVq@vg9BH!b(}f1t!sH>$JAyhb4K0DI{PrSxd|iR(bU+fCso<K!iEc~
z<JEDYA;GO!hVmL~87u*uGgVx9vh6W9UN##(u31!tl=tV|;)<d|$YL8=YdpKQwz_!E
zqT0e5D|W^6W|Y}VsT3NX%HTzX^A@2+z1i@_xw5(jXR2bpZET4(BU#~!=e+n@OD*jP
zs+&3@O<i(b`>GR8Q#&Hy6pBoO@8J9*EI*Ev*B;VvZfKDTp+IS(PU@{(XkhVrTRUR0
zT+X>QJ7IDCs=8+U;ZEEKsGg9FWw=`HbrkSN{*hLPR3sb;ji@$gAatG8^sJ`iV3m)J
z!5xm{sG<0^NC{)4IlgLnW2+>t!@A6pH@`-WxYWH`1%~$~@4#xOP^2`@{Nm~wM>UN0
zy!aeX!s^+l#Bo|n3u~Q()l?N%^b@$6!t&WwMU~YMS0k3=QP);hp!4TSC?ohm?c&aP
za}w*3%CZY*yAB5~mT(4At6nO*Y!xZ>p)$9MxnT(cgLJfkH83BFlyh(83y46gB&lIl
zXJfOqn_-w?J&87gpFT_4(YU0p8NavDQL-QE+M9@ZtPd3;(@I{SdY9!-h>L8di$N-8
zmmgdlFE4g}609!6>fdGvk+aJR=M_38xAxfL@zdSZ(0eUMm=<GOW|z@7a^{RkN4;}b
zy(|#rp{49vS6XckcXmY@`Y<fEtH)Qg_;)U(+^@(|Yfoi0&>u1t(820+A7+C6_D%*?
zbkGS2P)q9F8EIdl-~?Y)oa91M^ph-!H0EmgTxhk`A{tJx{;q6}EM3to3oLIbvbsY~
z8ZU{!&k<EN8xxBOZ*)BCv~pSDg4uJOJG-d3pW{;d<%4iPBVKb#oVd;|i}29#cU5t5
zyt1Yk<>Gl-1&mTyjmPRuwxfdekIE{YUP{p9)72Kr38AT&XK`u`p$!*^^pJ~_PdF&F
zXrGRY+EI@nNP6YiU?MtKEM3}!%Zmg!l2`+4@rt(-GIXD3XAMtSY^}<wI%r7HkE+7$
z!++}QW_`iFS18*Omqu&s>~vILYKiEmx!Tfg3I6#CDbaX?Tmw;-ZP^q+I4g6t)OEVh
zAEQ2l%!Bg^T5wQ_J*>_2dZ-?@@X?;#o?Ny_%gR0rPZW}nr38t}Jc;I(mBwpPC_?6p
z_#(VR_oT3+oJel=0!rd5T32*7O20RCH4!tN&GYogk~(5a>nO*OZB$`<gZCaqCB?sW
zopLZ`51N+g9qbSjv^O<3D^`#j;yiT%v97k3CR9ulQJ57cSRURF<Fr+sjbD#+v_~4c
za63gvxscXKKyI;pRZ~O#@<!>Y*7)+KNSD*?7?rkV%bFV_ogMX7ofERGuxrKpu?~_p
zI~$=d?sI|gCFKexQ0CdQx^m8<np)?t_cz5=MW@!pt3Z=e)Cb4Kao5>Z3HOU@i~o&p
zL%+%ANouMJ=N8W|##eHgj1y)Ox{%F46Is`0TAv^&s-LFK#ak58Es1wnF18I^erIK*
z%jF8BVP+)Iji!Mw&$8?&ly;uk)Gmc)wMn0#h*EYi>zFDjr8?_ndVaJO2}5e7llUq`
zdmLvAFO`91D6uqR5}$R$e0H`s);BFB^JJ;eFQ)_v<`tJ)3Vf<+j#s#t+1f&)pfaB~
z(l{0UyqwC4GG`t<4bkj#OA}Utypy%1Eo6;I?tyQorkn8eZA|1;tlcxgtc5-+=+g~^
z!g7nSed2KP5S@`W@G2z1moE5hfsq~0hVf9y!i`JoRy23HTwoWzen;0?KFUUgJEQAG
zT%oHC$%Vu)t=Co8XKEYzBp()Uk>`SkLsVkdB39rLG9<kIqDpxAAeD|&iX7A?f^>^i
zOBox-E~u_tROR>>g)C!>S}(WCOS!-rr$IcP<(bNi5<Mt<ug42mR<N=WkE^Y<V8*m#
zryn~j(sG<#TmR$*oZZn+Ps1U$i8EMzI#w##t6hvG2CM^Yt?~vFt(sf{ZgFp<X8mM#
zRGDg0Zmk`C3DtU1AIMr=eHS@7iG}rb39oEtu;_F&8M=Cs0%)C9!ZsyKrNt7A?e+1}
zu8tM0_0r5JJ4c9P9jCkO0Fh^(iosb=5aVEu_iD#8ym#$EDw#PKkA(@>{$(y}q<I`!
zu#%r1rA?0)C#6~>LY|6qs}|YZo-h|?W8>8XCxsRtN>j|AU0fEQQ@Eg*q;GMV%gh#6
zoqU4Rai2NJHha~9Epx7R#5>F?m*S8=jg{$8S{7ENNG8{sUNs?qT8Cmm*kp^y>2);l
z2QJ5t>7+E&E7o8;a(jW3ytTwV`yE94$WkKs=03_PQS1acQRbL$MXQrX%$m)qvmT$)
zweL;=DA{hqd#Ej(`4Eu6E<tGTruL=M4@!(JDy#Gv3{imyAb#@fvPFHC$l}<JrQwBt
z!h=HRd%1)wCfnxHE9aD;5}mjvnU#2$FPcwy8LwXCvhB!lVeRb5su_{hF5efiUMv|j
zA51te#0PjGuKRqZu873LdbVUx39_uYak<xi^d$mw8q_ICksZHag<>`38xh`qzOSSV
zs!8WHH|b=>p2$RyNBO)V+qk0>YZ((nJEM)XCCLs#eT*aiFNqYZI(>pti7V&5ur{kY
zUA_<U)h}-%-B(Yy#0<_+aQ>7KuM94h#d*p7o#eTdWo7YG3X2yM)%MBujJQR#oMlnf
zi6(*h+|sH_I@>}oaPtaDYb}~vTUi}f`enAxLi$_>JZsBV62<aGq}{8^3U%Z$J+V-i
zM|bbi`8HfZsj^8g3N}X6yWMo+%|3L<<}J}5$Goc}#FsKiP7C`H4$8{l<)WjNTShQD
z5wpe?d9+JG?n>nZW%BD*+Z^I_sDM<*-D!oEpkmq4cxT;8vc=vlVE%YNk5*nIxgQ;{
zMeu#KY&Z+Erf?iNBMw&XtI@lf@ulcoc|sK7C8Hz4G#7_dHMONRU$*#`XjSm1k4hl5
z>XhU>P0c}Bn}4%yv**oovg9&oKK2YfY<Em@P(C}63p@EU=;IS+DrtsyCuDfP!uqh&
z@J6sPVrfwWF>qcT=Tx98Qt!NMM;QVekYZ0CQGr$f`&6ORU7Zme5ld5e!cNv-6^c)m
zG%iD4`mu@itP^a)d8c&*U5>1?vGGjLAx)^=<s5fLR#`15Qij^m`h_|VCHXG$>fJ`5
z;w?+Xc8M4+rB6fFoQgA6S(VU~%IGSDPZT)xyHwY~rpK;E2QhuNiCmb*wyABF)j{^o
z?r$l)s(gN!=Jre-dK!Y({#$2yX<J7NC%Aq1wA_j`G@{y96V|!l1u5x_G{F3jQ3}mQ
z=Oiid516`M$0bV}$xG?<q@$}1bK}sNz^^;iv&oqVEAY;O9m`3ySU?UmNr7cbiaDKu
z1JGw!Jac*^C6GplO;#!4S~vxSbB!|kG&jQzTwS=JaIy2R4?aXl9LH!FpZZNO@u$X!
zGa@<*=sa6?aYcUyv+lIEW6xNH37PTbb*&A}a;TRkjv6{aLzl9u9QQQfU87yvrz-)h
zJc;v!$#OI*5*25;fYWIKt&)S4*{8~h={t1!w-cDM;u;if0%iEY@KWdo_s?Kh?6~;O
z9X~kT>`DqNisHr7XSr~LUbe9hpa~CAB|ZyleX%~Y36<6fARm4lf<Gg22Du^v*-#<&
z+1TV83et_C!$b@dU**&UTGpQSwRfPo6L%HDq?G4)>23J9zde?l+(ew+DYjkW405Yu
zaaxk8w@E_!pjk21^1%6f2Ip(=b%RZ45SL5;$6c~rMxE2bHj+|SX)JMiBRnM()ionQ
zK3W>Ju6HY9E`!0VJI}C*SzGP3q$H$63nYQ1URK#SLtyp4I6>~ced&^mQE$0JYNN2c
z3TNBhC9s8+{gSS;Pfm*FlTX?-vQBd26_w$+ZB5neQykT;;2d-aXZ3v2>Bzyy;bH85
zP#WIa2~AZzFS6>mNGEwn9Z%T3I%HYJhGNobcwNI8D=-WAt&J`1U1y21aT4S!kt6vt
zHVF*9q_jLW9pb|T@aixf&!PFMR{2}hOGS6au|JI{HZGzhQjJS(B2mf>rG!oA>WS6s
z%AMP|Q@zERh-HEpJUe12aC65_5{ZP&S(ywI<JJidUk*ME@xCi)P249q2!Y|jvAYh^
zgi^-S!(p_C6mgeW0y#@Nxit}<-7RxoE6EdB+%Z_6bE=rcBds&^_$_KIk{UV)Et)|P
z+P)379_suSdqgfQ+l+}nt!VSEkF|;|ZE|P`=3!-`2ab&D!5DGPN_e`f0|fw#bAh0G
zHs?4xJgPmlsxTgRs^8tU;NC$W3Z-Al3Smxr|H3w#L+@hl64;ldgHDgh`NjSYj&);0
z4+b~Z_DLwFnJk5K8d9zT&cW2?r|AH)nXtB{!>M->9#vqkNx?SFZ6v4?Xzzz~U0C9{
zB;Khr8Zj!!vf7Khl;ztd?-4-?xX<gJR(r$@-=Q`lnDQo$@oVI9aENC;#AbKF#pR~r
zI=w|h;n4%pX;2!bji3-X_pXnuw!A2xlocoV64O^5=h{JEKJZ}k;ez*rEULG?_9VZ5
zW>6g~7ZHU?l<i%QKCR&`tB<}Dj$s&bPhHW;`C`+Osb@DW6Re+VS!8Nc+f<vQI%dYP
z$ISrmtUh$uJ611gYj8Tk>-eQj+%a;f)!j9Jz-4_%GP3Q&azbuGD<o_#&W1m`)(NY)
z)Zg{cNrMt)U8Fr=U7LjFE=+jQtkpaB963lMy9m&qOiO6EZG+OboW(&+!XX!SD$&SQ
zE}$x@oTJmp+UiQjg!WiIfx$%JBaZ2xJDLH7an?E;+e3tOIfO{0L5tEfF1M73j4W#O
zR<}g=_+)kbWfC8YIRBZ1LMMK=F8G01>uPgn#2Qd>Ejxu{b<pXq0O(AntuwOP;Sh%~
zRJsXIMoX8YsFlU#&v~8eln)W8&0~XL9ciku*WvyKfN)_|F1Zh9DT#%oM_iIV;W)6u
zM1mD#*uKQ_p*?kzYg9fbUdDZ|(9wY$3l|mkOE%yK=^#3+=QOg4q>~Pw9Yb3)7#cyR
zDf(Xx=<hhi=Pjt7-7g*r?*=3s$`B(8F0FroVqxEwX>4AUivrEfA}k7{OUZtV{!qc_
zEWzC(>4Xrix}IW@q<AOc03}X??Wk5Wp&S}k;_`6MqlJr37OA8l>}?7g^lOwb!J-Yh
z^IFTn{e>Q-tDB3q{9wU$hN#1)?h~$>^p|5rFQ{B2YOpsD{bfGOPoA-?gc59oD3XT7
zYqP!>(uuVut?!NqEvw*uS?JDwJGqL`r0aADdl;IL7FMPT{4Q0T=Ts&kyW=H<U7-d-
zAz{@Cp}QoMP>@amx{EXkH5kgL6K*9Z4zfhyH9;)df{NK?&LY`Ni0#lX!HiwfSUOTn
z+>D!XkWXcgT9j1|0~l}ebTV@?M>%#xmu1l*Fa;XWa%)0)i2p62LQZsaN)(6pAzZQg
zi)nO9&?y~&c~f>tId#m6jV<x6Z2sPASL~X-Qn$3Dt);nfDHnrQw7|UoM#O}-VcqL~
zZ=oZ;N}5EJaz~g%K_oIo`nIL*IutsH*5dXARpp&^GA$h<P!h3_zZ^LOS3IP?b*>Xc
z*KIyVkcn*Z588K2=Q8g`bJQVqV$oY&DB>h^hnI!^CuIFaLY@m({Qf;N>HF2po?jTB
zzo^3A{p}x9)f73UQBzciN228v&vQn>AKmzfzXkd7X)wE~WgSS<zsFCAPDk4k`N~3*
zRRi8rut_cz9DI_mnCYNl!n+ere_Mlt;0Uu&1{Tl|oe}8~#Y1+mc4;fM;JA`3hztG8
z`<?B=Ebi8+MYliORTflfG)t^@e=P|Y)l-PutS$*q;f`hcD4|f-JA7W$G_1XXV&zG1
ziNtZdw%o<}_BxTy!W5)-ao8vX$wWy(%!n+dz+Z&Wp82i7G9`ICK37myHZMHS`P4(6
z$VPsRF7jJ0@~5Pv{Cz-<fW9W+|0)0O<21F_H?L@DoVtu_79CCX$2gy7NfVbkkB$77
z%@1zpM?ARD`ct1i7k=sgrEQ&V1D`PS7*y(t)yFJrT`|?J?Y~@^Z9G*susb6{Fzy@w
z;a%9w&#}ve6x|!+34D3J<AtvsY$w;Ev#SBNJVw{eTU`mhTvtN_ezTY*-bEq5bZGr@
zJ5bm+h$v29QIGl1_YSVFb99bz_gIe!o3ao;eZLYqV@c@7dRE|icQv?YZlh=+3~z7P
zxk7uc!XsZ^gpYKi54d+NRy4J_UVc&bA_^t^aHM!_X=hmLpIMXtdcjqE%7p<cXe9(`
zXw7HOWZiS$9R%JriNBGMcyp-W)s9goJoceXOQL}7_~q*4SL)Dp=SPt<BN?gThc;$s
zR!Wc;EeWF0(x`c`t0c%X_htFl2kh(pyrxD=Q?ro>dWN4cnRCabFxCe<g0U4rR%tL~
zO%REi-qX8-?5MePTuCr?fr<w#<lPPsr1Nh^7DdfInxsUt%(b-PS70MOL00D9m|q<$
zg7j#K`B%KetSu-Ba-(MLIVHhJs-~6%6H9`OZt6{UN=Y!NG#FhT9LLC`=`>}2kW(6%
z4M9d(Fr+xhU@N_haUo;SF%~V=(%z4E2U$^bIfaAQ29!-K4F)j)Ybj$P=bzIPjLtj|
zHNQQ*L|fQ1t~+YBo?gO3NiZy07EGXRdP#6>iMfpy1yS=GDq^KUZgDX9Kro;v7+e-)
zR|aFs14GN<Q8S477DUZur}vmY({y0eoXL)(<|ewQMa{G0x`R1}ilN29=htc7DHTz0
zofXYANA!Y_60<k1<(Vx7B~kMR&kXwgf^NTR7F`hx&RoZk?5M=NLW7}E^Aq-$V(YS~
z8@!&KP?2S}s+?^^%wx3A%uJm!BsgM&?R<m?VqT4OYkH9WlXGIX1nKL8*qR`{EQsz8
zvde=p6~QRz@C6~f6q58niQ*u?B5MA+m`>)BBP`Pd8Ro2#AipXYR1xIP*WWQ<xtPsE
zGdd28_QGzZ!C(jBhQ&R>V6&OtL!;}W<_`=uD{8Jjf*tF50K2EIU_lVQSIAC}eIYQF
zLHgRj@KPK^KL{q52eEawBD(^zbepH>2eR*=AKVl*8KS42&kK&I2#zlb^2;D-x7o3{
zJ2*CK9-<u^JQh;jOV43Z^DC8r{vKYBikjWvXGCRi9NXD2KNwOK%$gqzt_(gqKNwn6
z7Nk|eCNzXGAD~}`S*aa#2h17+b<le^wNUOwYQ-6;QD}1G;@%*G2`P*1P@@M~Of+g<
zpnxAXJ*zv&%Z&X#7+hQlLA*GA2RaUln!iCvjWZE6j%K2fCBfVhb3T<OYW{~x_{ksv
z=TRa#`&U6vYOa&r@H0bm{b4CVdZx*Ubp<B~HJZUL<M}W1Xl_0X@zpY)`*OFrg_mfw
zN=P2hbTMt!3e*#{W!HC7KM2-01A1uJ19>ain)rA}kh?w@!{hjp;DnN32;IPYFhoe+
zNY|3!ux@kfm%GJtFC5k#j4loGDI5kCqb8>$$U&52D}(5{LGA*P$e70>-9gR=!N4Mm
zft=`iJ4!5C9;ENIVv!!*863$NgGz!K_AhINFsEAN>^htUuQQY3iK|ZSmasfd$vD<L
z6yAV!pxDMB6E^%Q)riEqhsU~*33K_Wy);wnsJV-=5dJ;%Jkqp@BH>gf3LCBqVv>{|
zhFS-Coc0;zVF66FjsDR4W^j@t3Y-`<Pks%|nLEbEPUO*Y;9b<F(P>zBa0Fs@SgCy*
z&SP3>Fc$hU&=WKrg1VxqP&ppmD8y|DatwM>Q%(eEfhMy%I4s)3g2dI|VYXP*yrm9i
zM0b#imX4U5*ommW*a}2B-|<%t?F~3dV@PN}oUSi@wL8c}flcUPqF9%C@v9|iLqxsb
znUb`WV5Irg*lrb=o;tl}n@7gNNDoBK(_gjaVZ#yTY2WY{wqcgpGqwbFd;F`t2aorx
zZ+5F6?>WXBWLESrC&+qE(}!b@G>`elcl*YV(|E8Mf)?HtOo1X9@Lx)nc?KTJH$CUD
zVHC!o`2hxGB=!r0jfBmo0FRQu!Ui|6-#k?B1O_S#a?0p80Bl38b-`GZO{*%*f@oyU
zE(vDRa|UzF1{OjpgPJJ{a;qQ+rYBY%r0>8Qe6_^<nemX-B`C@T!O$Iy`q#6&;qJ=<
z?d~u3`BMA5@9bFDMnl2)>b1ehLNU%Gbc3WlV<35DFvO@K%g#5WWE>@`>w-~e$kHHh
zt^Udwo_jF*N17Krs($KG^&+T>m|IgoY^J&98|Y~BuQaLkwco%B{_}KDW4gy#YwFDK
zgsAxw4KyM82OJGWuFHc_m_v#_i%ka+W^ItQ9<;+_(X0w4c-~;wGGkwgnrl(}7~_4Y
zJ6V322J!S&i@VJqDI0+97|%dVQ6NmxM8a;YrcR|In-2dC9O~QUVfjXhpQV>XIn1lI
zWUizPgM?88bqIqb+CQq5)YhPC+chVO`8kZTDF{D}kB}a+4iC0`IG#>nFnOI7)p2y1
zOhYy>9PM;?iS<=bg2j+tYY1nQtmc-(mpl09HO_=5(|2H;Ma&c}GtaE1Ogqi@U5pgk
z&8NtYn3pD(>_9(R*DT1EUl)EjZq_^=NeME``In~6=5I4$X6z5aL^DK8&tTx76(pL$
z;@WO_82wH0jBc7gb@w?kE@tba5hgKj^B1@3FmoftIW+oGk9kN<ki7dJMV3+#qPzKv
zHB&LV@nQ8$$2p08R^Cx|nXn2gg0XaCM`ai|Xba6#&6_lyXs)x*ezIZIr?5}l5gC|s
zFjKkai>y6r=EC+Ba+Xr%h0wpm{QT~7#6jksG2Ouc^SvqE!9c|G0z~Q68d_JwyGW<x
zJ71)<uq+r~wk{Y{gaBPl2hkLhAuf@dHxQEH&<#Y_mIfm#Z~}xf>u|7>&q_ne6pAFq
zv>+i@-z{~5BHX9#8I%(Z+*~LO6D^LK%^=5B55=Gz&WI!FenL?&8QoJJ<jfByfw6U{
zqNuqr9PaNLZaCHr`fLvhimh~|(=Wf&YWRGd<-6ED?#_9S(G;Y>KdJli5>$-3xK72G
z`oXciIDu`wP=Jk!(aWt24AdU9d;BXIFZ-8%58VYp(xT=*`lAUS&?~b%q~Y+j^V!k8
zDnpMwBCDLfKN!q9@x>qwJ|G%O)fn<eRh`BdcdGy&=Xs5R`<81kP*D>X6JW$r)_Z#2
zEBAA>!S)8(3xb?-d4HLxUl4PHhJYouYs?V_UBps<<O^T7Yda4lM9ue9#@hbWx3)~b
zwiT?+R<pKu!?j(e_JgD5FB${+!v~2N*l&DhY&OmA1exjP^2eDK+hFbNI#!)gq9tQY
zC8Q>Ht2WQZGIq-Aje*s4DU5trB}3+9FT>#6|LAe%h@6K^ve4%>G_J-kD8x?Q$udCE
zEt+Xi=}v9$nSL$g^2@CsumQBI?QpaGaUv*IB;P)oi8H!O<!t3ajge9oH9ILlC^c(F
zW+hB6sbOT=-mbPOtm!vu+;8w7sv_OIrcO3$=$rRySM`TPl^M=_nH!+zzp9aigRBL9
zZ!gMnqPY-JlqDDwH3ujdRvZj34aSuP1PKUOikQ-dGvy4^Ta8!CDicB9NFvH((AUHb
z#X(-FusfnmuR|9Eqmi1TU}&kv!vdS%-vL5#?XG#kZa+2VT;K2)G|a6}q8L$!w}RQ*
z5y_uF$rcA9->_R=v^;8_y8WD9b33JaDnZQ5U20-baF0-h=$aiWuo^(>-E2p}j=|U`
z?J3JVoKljS$NWL6baVKl9p<v9S%PJN)JgeK^X68TasAUQH(NAh<1!hkQ0`^b-1u|^
zCy~|VpgyV0!62qadsNvY3H|BQEM_FC0W(AOplA`La%I`ea||Gl?KZW^#{GCk1u*{Y
zDuB73(jYYW0h8eB%7ZsU5kEq$l&lY6D058g7L*s=5GHlXAf|`K!Sv-C3)cNJ#W*&$
ziJnmoL1ZIZZ0k8Foso>OpUp+hceg?r(DgrRV|DV-^MesAnNW%JgO;;FL$aKIsEIJJ
zmICvyr(yAd(pjiS+9PvAqid{HjG?wB;M--=KZBSuQ@j57=X5%E4@1bWI2>eT;~_<3
zs|i+reonW!L{)<sPm>Qo8$-DP_<=Ocj4s4d5qr{3LbP#@B}<R_NMrI=VxNSjzuRrw
z6{ixHt06;z9%POcvYVxBAG4a8=2$TNkrs379_XKu89Pae&j#J2@dgzbE2>_H1Uyk8
z^UyEtF$pf4E{{d@FOzOD53wTY!n-x|km_L24x9TpUs%d4Mcr)El6PybX;DylH(Lsq
z68=7nxpb14)8r})dF?CK+r4oT)O?v|cJ;$a7*0INvS4Hx6d<y7s7_r=Jo}X%qRVZQ
zdbHKuUqJ)n2L6H$-U<AicLHGs^XTf{U`VDJnmRKDXBm|#Djx`9L?)<3Jlb?~?HKYM
zOG*T(Gg%U1Wg|8cES3cLgt_wi)&)}yp|fa;<^PzT7~RV-{27D~@6i1Uh5<?g{A3Ip
zc`0lHTb9AoX0&{qe8g!W>(RD<KnuwE#+Yv8<9c3DQNNcfLDm9QLk5ANH!oqVcUYQ`
z0LVeg5Q8zW$`y10RexqSVv@_2AUzECChN$d&!yC2ApSb0msXX|$XT6$LI{7A$6WOY
z3;`LkV|$6wcA&?4*%uB@g_zv@W*d~o_}=;mn!sA?G*vDL(uj$RgRJ|+b$R7B8-R1E
z%GiE98~jH+H$0XMw5DkXuN#8w^+EK0?D;n29^<>~5y|c@O@IgW6mPQOnd{|X5NZy`
zIj9ISvBEsySeS)Y)ufskCDuEG@&)WS$7YkFv3XEVl67t{p$yiP(|%8ojZcDFbAN3@
z<gfQI9XPshw<hn^8*1bVd>skSh^Sd3#W9tka0{@vxKPM9`bRB6_0_v0y@;sZCZOnd
zqaEbJ3?yjCDGG++hVYgeU0^aP#8LUJT0(>$?~bIx@9FDU&H}`IJ?8U^2o)aph8^p+
zgC}$we9l8zFkpcm0!pkSIKtLWKi8U1hW{)(u#DPOf{D*F!r(~rJormBH%nQ*b`Kha
zWYSOVCSPC)_7SA-53=?L19qSam1Qv!x2;+sxvuAE9OUf?COP+EG^&1zdz92?70dO)
zS%io~w%J_{m4h+M2KLrN9pE;fM@Jm)0nCsNCr3>cd71w>EIlBW8yR}>oCVf@$=Y!C
zw6bxKG}3Jz(rU4b535Xp(+H*`n<}&)<7OT~LX*Y?45O6J1i|9qDCf22LMT+P*(MYr
zzc=qjgTZP+5utJ(+ImMY6oqxarhywC(lp|RqoTWlc|hUfxHVQ8&O#%|J0Go5yJYpe
zT|H5a|JW^oA#Z8cX{v|{q#CN^K}fwE$!bZih<nB}(m)jOScVa04!2Af3<r^Db@F^x
zjM8FXuvW(0Sf_lQh(^wOhjc+IDuAS(c|}a!eGl>l%l%6ek{ugb797ov|8ci7w^zcm
zef)eGVH65P(G#S)@KN|#&LhJ0%D3@^GWWyGk|nTLs-#%zI-bY}5Pjm5Txwa5(ImX6
zm|P-VdZR9*;3>CAt_f^I2yTabkjNX8oCRVscd&B}Yz+!Bm{o2wg{VffQ}`QU=2vo8
zWQ^~Tbw*7*E?)(kiA*3OiU}3Z!j}V4F6{DFwL?xHwHA_I>`u=CVF<YSvHSpV^IHu=
z#G;4+((TaL>Q{{UA~^Jeylw}%L2vjiZ`!x(H3BN*cf45#j~%h%@K?;tAF`<2%;^P=
z<2!6Sb0;3=ICRE=PUhc~jh&wlO^K2^t?E(9s7&*AiU?r+5%OkuCGPK$(ab8#Y)9$<
zVZAlX%Ci-m!=qO9K`=Jcyg#x#IFVO$&Scv;wTGBLQwgKP!M*}BH@fJUiqvLhns?4n
z%qhFZS}tq0ds>&r68~`~e|QRpnlr6^y|mfp1^<WKX{-{x-PRKnKs6NEd=Z?7+%@_O
z&s@~pBiyXZBjaUOL7Pl-9cz){$|C&3wM<!vDEt-H8kQM*JD7;a^eziQ(k>lJ{9c7I
zegI<O0_N`wj&K<rkVxWznjO#~uQC|B4n-!Vit2GfJ%N3bNhmR|pV4h@U?2qhO>lUS
z8v{LlyAnO3&?;Ap8)$I7bIsSW&dP+0D-EVsqBZPh&w>Eu!RJXYD5s8oAhAut4Obto
zQ-=E@R?RF*OeN29H9crJ814Tytq`jZSd#K6{Cl_*q}un<QL-ZWmBHbKL26Y%D3Vvi
z10&KR8{r*_AeORgdt@-K*vgf12=Yh{$ApOd5Ghs4<~(bD<-W;DlR${FgF&}43ZqKQ
zhfUU{x^Nhh-^(*Jx_FrN{%}Grl*NO7SbXh|PQ)~%zoE^GEGCD=Ku_~6tu~K?2b+zY
zuIc6Q{__k4Oy-uMy}<<KIx=+TF<?E`3!6@NJeoU5&`qNKFvJVWQH;|_XaiQVD9*%Y
zXUSd;5UvNF9}GepO8?_VbcpR`UPU#P7wh<q+EHav<FdgxIiqxxMIjawQW2yPj7fmd
z=Mi%^i-1y(Gn)+goxIZPM%ENHxv=_UXYl79YT@5UsU%9+!<+Ph#6@Qa0Sh0#Uf6*p
ziTL1pR%LFX^>N^D7|dwO@B_^v9Fhs*EsF&PeC7=0i!;s7$fo1Tl2<g(Hd(npm&la{
zA1`-4+ty)N$ub1G$IhCC5B)?Fjw`-5!w*=9qeMTl3J*Xxb3f0}<&I%Ch2O*m9va3t
zjCU_J!+E0~3okFALRp?85hbv<AeiQoe*@qV3H}{4hkDP@emdG3lo!k0mfak~=Fzf4
zb_T<#DGmy%B_abC2IC4V(G8HA409elgM(MbIb?Z|w;(vdM#Lw$ypB>@D0y=&lZ;0g
zm_&y&BW!fd_LW{0qvAJai-*Y>+axG>mI2q<X;x8iY&l1n!Dq`Y>s-cAsN!CRN(V*X
zg_j9Ke>1Eb%HGTid-)rvR>Cc&Ew0xwASVce5XSB%8?zn|0ypstZvW0WqT~iQ&L_jb
z<a#F`=MKkDkC^Un!9AI=+a<rI_e{E8m?ygqnMy@Y=})FAF@Hr_5>WpLnbhp$6p&VB
zI@5TwAtHOTO7f3q!qny}8V;xLs47J{gLQNX?uRYpFIX0O$1N28$I*RMl<?rUbYtsR
zNJqbOrg$jJ+{_>mbFqQ;ggAA`@i0?B{V$hG;h5`(BLJwv<vl1Jy^JGdm79DdtFwPO
zsNx}FeoF^J&g-Fy?7dWp!yyW%+@5NYMG6jw?;Uf<>%vVRVgD+>^gIJ(Ma|C{Kpl}*
z1-VhBD|1W^2{RFBxkffG(k9ou@l8!tVs;Cs+mO@&CLbkb7zfD(xj07V5%vsypJJQF
zsNo}QoOSM?K!S;)B+$s)FSQM~;0~C3=z^c{D3jn5ntK?J<Fm(j#i-=1xA|Fm@~@Ut
zL&ImO;Y>b@qd7t}LI?9T&^XfkaV1GstR=aX`J^JT5`=ZP43I~weq~4*dy`fl!$#9h
ztMUto98{H@p2txxeOTb510cvfJhSfKQb$s8FcAR9+SngxeI(~wE^)7HKip!z%gSKn
zw`eTp(V;izY9NghU{v!0v<+`ku$O^R{QM8>lpL=uXQ~f*A;F4~f(UZAE|z}BNld}r
zAqR*4<cU1vpE0y(hm>=JRNS7-jbU1r6!I6yMlQ1^<MMngx;++HgP3NePR_Tkr(`po
z1^li-uAccJX9h6ZYYj>yn4dsEj_?(rKHmWA5rU3pVVBff!}I=VoIrCQd8=8~Hft0U
zrQkECG{$j+i>qnMgZytxmGdwKjDZJq{0X3zvszlCh*3Nf&=AxV5TsM4M_d8kM)4;8
zxx2wS`A@K*@z&WRZ^selRF}U$0y8Rim5t$mWS};Rl-pC1V5Y);b1S>UeE){-l#4V!
zZBP`4IeC>Gk1e$H83g^MFo^>q<|ewpRWH#+PKq`b*kcIL^J9<!6WmTigwQ-y-))~$
zi3tYngiCvL&m=4QvBCp$AJ{_O@1}9?dpgfU`D#n|P!2;s3Kox+j<L(vd8yoXX4OgK
z$k<l=*kJH>`&T}#qKNd30nLVz-lL_?54am4=eG*u>`o}P1oa=cmNa#}RUz+)a#w_u
zi|xhpp#r45IjTgmsRgeKNDqoaxjafdbeTrhnYE87F`GdN82bQ>4KrQc_G}9Em?lJ7
z7Y^Tp=$FGtZyiXJfC$WlRUwQczefR&g16{)yJ_BV3bK0$k;RGHqJk>%<yc@g`ibD`
zNEL}JYaLnEj_#F{KsbmLC^yalW;R9w;(Wrkvd#L@CH4uWvxa39==gdB?FQgW$?fZ<
z6})mGbyCceELXykWK8fqkY-_o+awf}M0u66wMXYr?me)Wg`+Dz*(OCgL{T655?0}0
zmXX2ImDCD_gV~5eLq)N8xhPsTnd{>5Oj+)|jD|V5j`n1q^LJQw6W@#NNW(<U>x_uH
zy;>Cf1J9_GAL#kFJfk#zLeELGMGKJZHky_bC?^@y*lr$E;%2gp4Gi{crUOfN<dGf9
zjGfhAbwh*y2h}Y;BP)i#HjFt@&G2iX!c{iOa{(7jAS~<4)>@J^yo}$kF#;sgE<FN6
z%_R*SS2+_pbwzJ;rZo^pwb+J+6*8xci|Wm`F$;ml;PY^REYB#o7-KFVI_AV}u=y(p
z8HUnCWo!t>R0jF;gOQckhj%F-#Z@ivT@g%Jh@V-6gJJ$eu{bY<WkyWTD!7`!D|Iqg
z5H{EaW$Un`r%dj$dE_{h3`Eq<y3IWl7I1ENJmfa}a5QvxgVSHkXj!*;<~Yd~UMGW(
zj@}0z?5zs4dtQ(EDek6laQ|n(f%(BV(eT+jxe_HqXs)Ib!vBQ<$em>n2IBmbfhC-<
zH8XixQ&z%*%lYRh`zuR%EromOl1mzT;5K`xdKn9pw{;wSE-dTO152_=_)LTX=P6V4
zfjz#%l<e<A_9vDn<T$^q*Ug93W<H9|hM96#|6WST`6$>SmL|~+QM134l`;iO!ub?a
zqQ<#a_Fkz?AYHCCzsoag*~}QhfOA<f3D3Rs!(G3g!7|NHR!VBb@=hJo_^k}Kh8F?>
zo}nqm_;#kiKQT`+8uIY?QA$C`gdx7<H1ZX3nP;)C3Z#Zb*CE2(k<zf)=pK1CNR5)5
z#3H#nf}^E@$j&G^g+4nvx;7YaK4fMxv{TQ_9<_s;(?HQf6dr9?fJ4JG6nbE0Hz_!C
z8r!?Sw3m&Whv<UuBbsN5_Gpk|1}g0(Nz5*X#%{GPy7!P3P)|JHuJuUPr0WkE6v-0k
z7?~STSoM7Fa6lktL~DP@AY&|-k+{`vqSf;HUAVZGrJ@K+#E$EaFTq#L*$|vyPrV30
zkEOX{f}vGx18vf6-YZec%3OXt#}!r5t3wR_5o|w%D{~wK5a6SL&2KOiS!gy!G=E}n
zwA^*Dyu2mYN4aJ$Q00OJDVX)8qOTJQwI~pxkZhY4kYxt{F@gmcd%y;3WZ=RAP$jh&
zF}sT`nV)cEmOVsXU^E>y58p|$6Eu)L+yfc{Xr{@r99$F_j>%IcF8q7!XFQ45@?gBx
zDrsvKTOLRA@i+_vDueNb!4Ug5my?fm9N@cHMQZyn?9R9iRtDrS<8Ec0qmi)FW(|9X
zD{ejkJUq`ju_NC-zE@Uw2sHjcXvaDnkDQ9^CKpa!tJMh&0~l<KVqnHPY=IaN6RQw)
z7HW#vt;9SDmKpsnFgq6Av=FrlgE@3>V@JcvEQfRKnYTuVpWynJ)Iz_9kB2{Y@;sV@
zTe{;{<-%0v?4DpmIkW3p9o$}KccpleOa&(C2pcI5TtoCnR84ni{50LiIA6fsw3OCE
zsj^T9yLmgwqJx1;gD-N6lDf}$O?(uR$Qyrk0H!+(1nHbYvNa6WD-2$+-44c@j*Q-A
zMHdnuSrSl1!=JH=Oe95|wuNUBeQ#-V-*@G|JOSPsv^Iz^vUQ5m%~fQlFbv%0%-DfJ
zFnhn%jZf-M{9@+@lfSJib(0AIwnH!^_E9|07<_aWuPB(kypAzvi2l;t`#FT70x~{N
z#V`y9H;>p+TDQ5Ga!~%fmVl37-`Ud(v}1mPXL%W%G+~NQ=+^x~9^}<YNDsG0n!oag
zg7wkVNrQD*XR`1`kt;?9_3zPbaO`IRmwCugz$RJS#kP{#ESU0GxZxsNvd05rz)i(g
zwSJ)I?-ch6RUa_|e%NGs$iv1f!yZbTXJ}*HZeweq&f(%7yR0GDilcah2$(^<n7<WS
zH2vuW8Nir1jM3jO>ebFKprfd(AV(Rq$yP3P*J%K9LIr|q&sjAbp%>A1kv#^zn2s@4
z|JS0}UUSK3O1gQH6ONaCB~=+*mst}`<P;SrcRijCD?oo-Llv1SBpb({zi6jnu`j|8
z3_96-pIU60Gz+#^u4+2!ogELV400gvbF>1dx6zEFZ3zSmc$$$XqrfSgMvq~Z*KWgX
zrz<P^bSis&f+qAs4B!N`V<x)$Gce$<itOq3y`OPGBAm1P+r4ZT-c>Spt(ABd|2L3~
zmAVK@fU@^_V=J5Bk?~v-rggS>pi1a6?@(F5KB<(KdlV{g61qpcOsa)S!m{f{-8Z2w
zNx0i-sH_Seuktbz>BA!{X`{_+a07ezfj9v7<2AZt&3{A}iKnh;2}aDzRG_|pp*;y5
z%9YLJ@ZPFU#(GYc`W8$XoA?bnHg^LzHf6ki@fj-ULG(Yf#Jq&mMa(;=GfSq~J<+Bu
z?mMj;a+!N4vP%?18FF<mCLzb%Ke5E7oj6|OK!GGIn7Mo&n>X)%o{IoHq0m3!#Fr>~
z7_syY4(jm$IOF1w9j&=juM=2)9vlI?O~4}a2ASl#@g!p_A27?@eVXpROPW!3@cgsO
zhyjW6vvp2SD@7K9$HDfainzvQH4rP1E4Gsi{!p{6OTjj6lp@G9S7(Z=g?ZDdS)B7Q
zjGM(7+(I_JD?qrpkVeCKb`uO&yYrMjur#?ZA6!4U%re{ktVKqios7lRkji^-S&zAo
zV#r0dAK!8W<iC^VX>cRu$FLomkLaP$UZ8za<K3~W+dPSg-LVXc@L)^CYfqDd5q1c^
z<nWL)l%uC3Jr2mYcn<DwWpGj<FEKcQ$FK^VAFkv6fKqJdpYlmXX`A-a(G|;jbwBkl
zG(}8@pJP#thXRL(%`H;Qm8=bI_#v~)sF9afcAtw^+53as4`pz2xiU8pHxg$GlbH9u
zH3OMY4UI)e%SzCy^kKzPuLqV|^>+0Lc!&L%-!JXaO0MC~F&?sn2s1$&%6>S4?Z39P
zR~+$UJ-<RZX7L6+zfM2U@>B3J92M~VQkzZs8LtBlz#qIGiJH(WqjEM64RjTo4Ns^F
zxGEmwU}}NYr4x#!YA~0md-?y2_9)%aVms(gL`u$PoVkJU0vrpQEa%=4I0FMPuMg0Y
z_g~TyK{Pvf#b17m-5kffWO`?51*k7(px_87OB3YcX_`3xE=H-dI7#vC)R9_vhS9Qh
zX$%Y^Erdrz*_ASQW<Tc+V1{;t3~!DoDOLg*o0(e~e11Nis)DiWK_W88q>y&dUrE<n
zTIkgFQu@J<uaD5#IBxn4AQWx%GV?`rZ*I6eL)|r8>l$7>QdX1<S)NX0*#3KsHutb)
zr0)N`(TGH4;t`INqS;IpYya!WUfsuHYP@gKX<0`1r4%l5W&ZWBJDjv$S3re<tmrwx
zU~ZD}{e=BH5ZA1bMbZ{-{^dxdVn<_-ed5rkfu|R!!lSx{)v<MMCmzNyV@u4h!!Gd0
zj>ca4I(B8@JyhY=J;`~TeAOK2(AXno_zZ2Zb3@m#6Rz;$Sw+v6@-RQ89tL}v9s_sC
zt)i7NcM*&Z1WA7F=*mW$)x1W-nAJjoScjXzdKrAKQrw`!%n#U>`4%Ea`&888NY=RC
zt@nJ4v<{7iN-`ihSt(t#g1ZhhfMMGjB&=`jRyQGKYbU}S>N0lsYe+<~YL!A7fawC`
z-0nfOeM;^#oxqPdH9#5xsXEOM2H-xr%K@oT(66<D<5xz4?;rErw+hP${~Tj)g%1?v
z_t!y0^Ia0Gx>1G9<D=uZ$rELUfw~k^q2Ob<VN!XH<8W0$%82s9U?lg`I6N%^OFM{{
zF{2};j|b{Y5BsEZOu5&ilqrZ*!HK|ho#fbWc+xp3($z|xBrqAFS=9WDQ+N__-{X*l
zSq3UoG*TVLalR@%kI?mq!+GGMb1o|;f0Jc&BMJ$|9_i$=+kD3!<(mWS>M*D-{Fbm2
zj=8u^F`b4P(FLf>7uY)<+RZe}0EY-E#sx$DYr11vUSkdE=F5JuBMi-A<P^1sJU*U*
z&8}qtRLwqWxQCS6lbWxqf%*1o;0iwF<3IBTE}I-1tP$aN2E^zI?`(zt2A8?-7=3sb
zTNPxH7(xE?Vz-#>)iQwQ>0|5_n!IT2Gq6N;uX&7XlhF1WbfQ%7wb)6N)?1&a6iaXK
z_28i9qBpWpHop38RpW#e1qJ8I&f8m?=YF2pt1uV^A^FH{f&5ag08AhYt~5M2&m$cJ
zgMP>qFz9~9P_k~*yl!&<A7Rrxr8Uh{$KceF_D+G@70GAfNYnbkDxC!0H&r*g2x0HV
z33-{z0VL=%_KVGwRfc&p;HIHaRL<g1sS_4ihCfJ%Pq#D<Xr8XLc=%u%PJ-F<ZSg5|
zD4|x@kz~;Dd(HML=_&IV{=IWUDgs?l{spU0LV{wPnDOwnB^(O#=hWnxXQ+s2&85oy
zk65ouJQ@1_&fLI&!_4bbmC2|e?go|IxKRwEE-YcB0O<HB4cY07w9Gc2!{(R@Q~@6y
z(I#T9VVYs)_w<4O<a8FI$LRpY&Yy+=<5hfADc&^~@XDnw%fP)@?c!j}T5EGZs<aO8
zChA8aAH6hZN0(2t?*F^IVd3wXCUxkyg6es^Qr?C6qo$>p;9fR;py6@_#%SjS_<y+|
z290qq;vkn9dvjhe92IvXBeJ?znQk;x$k5T24v>*!<~R>g=Ca;!J`n}^q?_%h6uKO5
zxYmcg8)wtaW;=_<PTo5W-msVE?q)?W%M;U3Y<Kd^6wfh5w!w=MHYc+_aDPm+*IY?8
zp7kCf1P0$)*{cn|$E$%IE@EWF;)7`@(R}kU{2(V3VL-S*ae;WqW}Yvq5-r{b1p^^q
z3<6#N0U4>6qTG!ZUlFqr`sACBC_;NlfphIL+nfz@%?l~8SLOj(LoS+2t=w3_9bJ+F
zH&$4c`r339`wuI+&1=(pfH)N>lRYy^D$!!)?DIFoo7sGN2@Wctl2%q71QkKX`xNsL
zQw~a-Qluajt-x57Gcw<6h*a4y){EucWWsKmQNokGdGs;krJJ|8<v|KnmSKogAaqqK
z4a=r+xLbK{5bU5b14k2|E_(wK%X(Sbi!)g7P34jh^V$q(rn5fqp9OxjyrDpU?!%hE
zBxYhL29@|=C?EZ}vk;y3i=80FB@D%|AG78>b0u0f=RUik91=+iguYN>{!rdSs@&oM
zH!iVZ^DDZ-w{KE2%B+`<VP1-`x(C@aY;wO=`T+R2pWOqQ&pbE-l-@@f50DX43yyZu
zp1NOZ1|o|ds(;0D3ZlBYAYbSjI-?i%YryZi#v6_UZLq_~KG}Od@A>8}B1h#LZ9)af
zLy9hQX#0@C2kMiR6Co)>pxkbu2;2@`E7y=SprH%a7unBl#$ddMoTD#>bpoc0W`UW*
zx-Vp?Y|}g4BJ6j%!WJ=4pH0Q9)yg?!nx7tHE%OW2vNk_GrdKALZxPH>6yWIGLG?6f
zJXnnKD18(f^&CSyYo6t98JFMBk|S#Vvd~q%cC5zPrq66LvsfsRkyp4w5Oq!g4x;nX
z*2&IAZn#b=ON?#<tFVR?y1xFD7MaA5_AlyWJSekgdsyJX>t!|ulkMj(;e|Pc^e`%2
zSAliigp3y1liUkf5KNzOKG(Ka207<R$=<w>F|}XeR(ogHw`1@=W!q~0Xf>(_kvkR_
z0seb+A;dR7;`8lS7fKu8>#*%i9iHR+EG*$w*FGTi%e>r3o&9w5C2)lL*}?l{bYEy^
z9%3y9+fVV>{qQw0Dh)xybH}ovTc~Amukb9j{$r+wfA2pQwt9f)m>#ti(QKQWKofFA
zMr@GD#c+5ByMShxu2dLuxzl<v(DiUJ1@YH@nc;yf{V^J%r|yDV6gCf}l8*r}>imV-
zlu);tS$9o@mPa%&>tJMu)}D$4S~>d1u;I;3W2<nFL!&*&=$THS;m-A}7RS*o!w(=~
z!xl;0AYF{ZrXQcKO~Y|J*@?OAn{Y3wN3*5c9z1Vkn*+>k-;8w?*^gTuTcr29j}mX{
znU(EhmopgRC;$aLW;0!J=nqgHHC>==Gqk7RZxpbh3wVP<@50|1cvZo4-E=1Rru*9j
zqNMNSYi0v6==@!)RcC{f&q^V3;Em=pzxt*O_`RTiuz84QPAqh+%X04Jo5hjlk#EWh
zSzhNL6tigV;lz<M@<9xQuREgK{2iiWYc?J$bMUf!OymrGwy@j$0oD@L_(+PwHAP4S
zr$f0nm{o@V%<Ev*aTHKT)&4Y`L65?&a}}HGr7@G;Cmp!-aOfJW5bWKBv&#lFq%wpT
zFx%h2F-kiRW+)<l2T>R|s^}mOeY7=rDnr$6o+@rAG5e}GBc579E-r&FC3bq&cu^gl
z#2tz?!2G7E@bv-AB|Lr+lf+;{9fA%s*>DlrA1m*<e6r6uhhrFP5ng6=80J={74JWb
zah0O_IYZ=_B9u|Oj7J`pN#D_%HL0O&bYt_m^oF}|DA~wxvhg9jj)B;SY~b#KV-S*o
zXOI7aSe)x6qSr~pm9%ma@%Dd~2rSt}eG)N9$^dZ~+fN++;KX4|pEwN3G*5pGamY-a
z#61f*_xyGn5PUEY7n;+1Wwrt#oZ~kP1#eSWKH9chcP^-rg&;$L_iNU+cbk6=6tqmY
zJ69H?2h+%~|7_DsH$@CFj5HY+7Y2~8wgIdB1w@v=VrRS`Qk=Ahlh)<RTIn1Tt@24*
ziCLe^IXrb>@FI<0A%_bVQi4FSXI8W@7`RJ0U-Y(olZbhxO$VChW}35*=johoU*M7f
z;<q05R-o%e>OYka({&rnxl-D%7MJHT(aeDfIf6@zVu5w^>d-9~8(Uy-^rS;+-I_>8
zQ4RS3S>`$!BF*nMunHt`cP>0c*nR{}Gh<t^2n%}5J!EO<n@S(F1BX0vYxK>OayEyF
zMSvm!>wjQ@HfbK11$~Gdm9*0BhxBjRPDV4kyVlX@{e*Nndw%3>5jgV$T9AI=K5RGV
zLP|<u8gk$->$9VlxdcT*Tm}<0!m3d`5*gxj^9r5@LU#j>h7Er6%o8!9rF^bURVXGS
zY9qy%Q^vU%$sq7q1+`bB78Sjb7=Dw;D+d)-V9iS+H_IyQVS@67q)oZ{be_H_Cq)M7
z+<q0hF|$H9m#^YCQp`_Q>0m;{gSqX+Me|mf^BZpBq&Z@q<bZd${UrnRC|k+WH7qu2
zU+kT%jAHJr8O}>Mt%YWIL3v<jkiHK(H$XvW;X#RsqPmpMH`ZSw;Uqt3%NO{=lPv8G
zdVYOQj~;+Foqod?u%+%h3d5C@yt332Ve-^#Q*wh*=h-dj424|ZX!}_v4`eg(Pu*XF
zJJDV{MM;4Hf6@XexJRIiTTH7jvIq6@q~OsV1Bx5DtXG4(o5{~6aNQ4`T}r&jK*vkP
zR&xLX3XaF;MKKJlw%#}VtUMiU@dNprzJc&q*zf}Va;v(UI|ijrfpwp3wdwo22cZDm
zQ4NUI7x0o6MX}02XTrnKA72XWWxR(Ms-)(i^>FBeV80!NJ;<nN`KMS1AGV~Ep1~Y!
zr4aq~42AqU2r-e^P=}^$kneU#Ynj{H*!KzeHwd!(M8Ns;@-B1?^D`t2ZU3zHSB|{1
zT}FI~<znLatrXcK#YbH2A3*ahZpJt5jDP+Anelgi#%q{SF)K_Y=9J<<V6OyiY&Xe0
zwpqA?{hD;Mt)Uxnt0JJ4&jeOBvc~Z!Lnau3CLzvee0pKD2AkE~1FJ@=xS8ML>4eRD
zvQ@{j=HkKf9sc$W{L5+{&Sp9GfTZ{97Wo$qz-=hENJhBMO@l1^TI`j$pU{z5^&6bc
z{E@aO&ds_evX5sJrgAp!RLm-)y&BD2OQ8;J#RupjQaKbe>}G}<O-2sdy~W@l;pIW{
ztmJZj#FBBB&ZmhS`9WMor-@(qWcNuWE_xJ8L0V8>dRdI}bqUu;29kf_vm+9skdj#S
z4F*Fe?!{Q-KfpY~eG$K>B2^zX?@-JQYTVHj7$_wR+haO(VeRb}r4PS17-XkT8^ZP^
zQ`>RPKK=$V-#Z8Icu<tY$Ln9G;(U}w#GE@BCx?$!hC(YvTuOrD6IV-o_(Gh&8M?a8
zag)R%N(;0#!3nD~&lOt4Ui~@n#+N!fb-OB)#1_#D2U+$)A-zgV$x%9~N{>E><tl^@
zx6vnc134vz09(J{c#H3DF^7sKEd?|+7qj8KCkn0m)AKp4kk!&gh6I-d<|-}be_%tu
zvvOU#^oG7Z{-JYs-#Ur}&U{@09c)M;ib6*q=%ReY{Ik~5@`9r=3HHchkU0z6mSr;F
znci9#$NYm4@NH2iIdXj^4;iQ$Znnv$!Y~sF8|-zy0mRy>*10~PgQ*%vl#^aXXksX$
zpN)&UaXiiYxZgUgpfB5dbr~qgjO`1CEg<HC1&%;}3}y{K=eYny0B^}8>#{yrXLjyn
zh&k}Q8GDkQA%}2R&MhZ<oNK~@XplGbLC_YSVg7gYd_{}1E&tNX+7{I7D0rFS@#u$@
zn;ZYLl$pOck+_PTD>IT1Cq)tB(u2jxNU+kl4r3*YN8v%J+|5&g`$m{<thHPxc~(iF
z<_k?JxUJNX=8={Xvz;aC)3L+dl|hU*c0|{Q_|b+h(Tlf{a0|G60F>F?;;x)$GxM05
zk?3@VZ=+aUmU;hM*vb#}`Hd4W`#W67)gZG8jv}{`XZCaE?OyZDfy8r$xmG{el8`62
zW#kD7c_>YR$qnCNFFIHKm~Cg0Yhc^|SDhuNQ+b4B4TV>D#en{ENy&&?A@1I<+Yh~k
zQWTZ>-PhR;H$ZrWNr`|`vhHOmw~g(!qJRY>WUjG{^qVOx2VX$$qQqUoCi65YYNk5Y
zmLCElm3^^6W`-$448ZF(j4;Oho&jX3DY%+~T=R!1T*j**2BQLh8eEg|;Vus8<ss5s
z-@}k&yWXV^+lBTM%EM3MGE11v-Gt$=a-#<1`*lX*m@c=NAKj=?SZF?`L`pM<!!}`c
z2LY5_LN`6|B2+)r<Y1iml^0~}Ln2y~=mF;B+9rM^KAF1$fj5ZPC@~tw@V(Wx`^Cqg
z3g4?vU7VuHE;)umT{1xz+2764SD~E7g>6}YE*$bxA47m^bn61`z;h0#)$qRAHH_6{
znt{lcv<;k1_C6O43Ke#ee?*Tz`w;Q#Se0i}Zhl9UnQ6XHPIo+-`A0j6GvMHRX1Un$
zQQYKIQY3iRN(T+>1!vZ=?hX#)RT>$dNI26n1otmsvWMtk-D(*_xz&7Mv!DkW?wZxZ
zQ#X*ET9!gC>><mwEJ1NgCb?0~MHc6GMC*KhYZ&lf`Z$e9=2yES7<XKw;q!xB{QL#r
z_FS@ZXP4NU_xhCaj{Er@_et96sasEWOMha=QEZb955VtG#8FP7+lQ{I=#8_&n^}k)
zr7L%y(_{W5Y=Hs06mnU*YBd&r3Tw(mcl<M%1oT6A4QnjnhQ9FNnC5LX4Tt*tr6D9z
z1qYU_4(>D?AJ)M3gDp4$&lN7gere}8g9P^4Fyy-IVWmU=yaVDv%}dlvr(aeUDV0Q+
z2ULnw+`mI#rn*;%*rSBX1}F&LzGH{^Kn<wbqz>t3Uza{y`5tm(KPX3f!7AZHY<@6^
zLxB0(;-E^t!yzo;yo=k)+$ZM}ab=KwS1?Gii87bJ*D5&t+M+>o4+MNa$XZ@gDT?GL
zl-g)z&klZjV=K!rJXv9TO-w>2YyWwusUKmR=qA<0a?cw8Z}96r<xx~V%G6wH^$qca
zxq^Th7eSF;R`h+6*`UVU#JCi#3qDH}KusWu6bDDUE9!(96pR4R>NPmJADQ|!s31YX
z>PpvQ@geOn^HMR}`G^%Dir26Luk^I8y{v+D{hQk3n*wtg*Lp-ZsQa`KjQHQK_3(9(
zTcy1oHO<{dCthSNSn1O3ns~^5@xOUg^hKLkb{i7AmGO{qIdt%f;|jyiVo-xO!(|3(
zBq<1@MP@daOKe?t1ddR0AwqvP%7%|yzh&>yU||dOFnxm+vM*}fGUs*_5hxS>$d4gl
zBbGqF4cKlKPq%aiBJmGN0mXc+GsxUf0+wF?I!+*-=aUcf<03)YMo7ecMi6y}h)cy&
z;s%yS(Jxd4%iAK}Z`b=sPDq3#S%5TRGIOgh{o}(C2y+#PG(5`R`XI>rkUWLzG3L)c
z93gAR7Z{3d=j%>3A5H34QFL<}-6X61GodpR-eCaF+4MF;FTJ|<H@!q9kb!WR)st}k
zE)DDpiULN^2PO8K3pB)J3|3iic#-mfN3zr$ah;B3g25Z)2Ab~w)7qK9S5;m6|0Fv%
zGh>(s4T>lQ!BYO!`lw=MjG}0*Py70BxFk1_nyI;ohE@>)6`aRPTVA!Twp4Kh6%Z_S
zKx@%rrH<{Ztys0rQ7I13{=dJq_qn+V+_vxidq0qK&N^#PYp=c5+H0@94_V<;p`a7A
zhq0IYrgjxtCo_7P!&IPP_iTbKh<RE0FfEqE7>~Ho+VyBzVx}RWOQ)PX82r~gOtZ_~
zt~4ZO>R&DzRJqr9>t8v1?Zn@gqiz1YiKg{uj_|M!N;pv!geIKppwpGkQ#Bo=eMw3G
zlUz4dbuN|AMZWw|u<Na)LWkFdrT6l8HOVAo<%{M=LQtSyHZ$bv)J;maRn#RO)IFne
z>B5_p0lpt-gH99F{fsv1j@XNbqfWb1x7`95*Y_rb0Jj>R97rf>s_h#{Q#Rx8Elmd_
zP1UuAj7x;cJg5bB9xMJny((r=f~^!(d<@-Belltj1QntY8RoyDA{x$HRc3GIc_blp
zj1_b{C2**Fj2C(^%6C2tH<Rj8Ju{v@P=A%W)2aDgYB5awj4~RbS)(dnf)&UPL-qiG
z@_nJu)Mr6qeNB0cVdks^qrr_;gqEzB`768z-N3x-dT|HB{r6xpq+#fD5+x_o7?pvZ
zM<5rsW0EODnEFj+SRs46(_Nt=(Etw$#*t^m%r2H_SmWFlIxP4Qukhf97Hu;`ykqV~
z4YTJqf`o74+HEux>MC-SHAqF658J|AL27te;xii)38FT4ZKQiwZ-ZXknc{if^0ta0
z^!_U95!{4wgSczm9^TsR6uXrufZuWZ(=;FKuWgPRve+=b^ALI3V4?vul)jgFHn1@N
z5Z<C8_1CN&?j>whAN7*TNep~XEX2f!zuFW_6*|M4LgcC58IwtJa<azDT0;QhU|Uel
z-1tcO;1!WyeR+U=EEp?%6wF^bj8!Ec;g-2|xKo7<8JBEh7@{OGg>~#Cjuo5(kn;SV
zr2MN$xe`()_?P$>5d=v+SN__*T643mgALwNNmr>POhdHv5Sl+zf#(qzRQ+kX(%r01
z<&L;t-AfaD8%S><m%Bw7u<(ROtG7S*bubK|$spXRCF2AWz`=}YF|C{!1IYlCfqJuq
zH!mMI+qxPTr5qU#D_?}$Mio}#SDh8aW78G*<UzfMpbx2BXwL{o=Tia2UK6%Ru#skK
zEZmtFc@&OeF#{6mNm4L(RjYNIAS8H(1tXuT(dw6eP{5~3>PTE;0_p5Bro_WpiXf&{
zGiU8R8?g+zteIPtTd&$MK%XE(k{JSfiE;IE3t3qo9R#<6s<FsM$HcP2&ZSjV#Zxx9
zn~kax>%UW52f7^?WO2|J4m)osYeCAUJdwKtrwT5S;=eF2n*jygbu4CK2ap5Gr@!Jg
zw2NJCF@}yTW|r4L<o&&0py|Jy!6rtMV0&T7u;tRP6qev)wm4`Q1ks67({6K8GZkjH
zT><?+LxR?=C9MWY-@+{zD6?Uq9WyMt`ra>~0*=>yaSZ^hFjxsY0tb#xa^eKe{<ah5
zL9)Tb#2GKIylJN`s@H?mYYSQMPQe<Q5z7=Wb(iKLJ2%h*`ujc(p(4Z}+b%yT<D4&Z
zm*+t{M{q520-sKyW3os5gZpGUsuBsble%MlyR|cxa<8k7lBH0sH1)R<-(?G}X&x2N
zj-29lA2_13Ni<o#g^J|+oQTxK;DOzW7bi+^ps^&vpgs{x*AwJV>KLpidcw`wfN@At
zdf^qyi~Y@-MKLeKeF;@~_ZO0s;ZQC(*+jM9bblf5;F~u|#~hWRDXTGZmysO`=dWL2
zPbC0sDrPW9M0XX%^Wq)y!d(Ram6y6J6?HX)_zaxJR2A>xAE(L8bU(o3KTM%_4mre;
z)5I{2EM6l=?yy;N<<K-o9@mjGv~8vT$&3TWH3l;2v3PIQih(u@GPH;mV^($tkU?&t
ze5=O&=Kg@B{S+4`Mm|_Bfmw-zaR$suOrB}+gNh8#V+WlbngU6N%~^(9ZdPK<3aKq>
z4W(i4LFYpy%T=RM#)jYb_ZqGZ7S9*aB3qNSU3~Yl^8uRvO0n;E&swS*I$Hh%kQv1E
zhW#DEK43N+5K8nU(qIh0k)7`LS*9I#l13xR&Q{`v(%nyIRk`O5x2p!F`-xcj`I+c8
zN_&9>j3`bx8}3+VN3pwi7}1y*FOoS2xO@gRK@kWPWYefZcDV5LIXXd}HCwtrIP32q
zH%9p}-<xThL@w6Eo9=>D$dxL;s`9*fHU|@uA~aC6yOsiQ{)k+?;BL+c8%JGM&@Afm
z0jW4dzt_yfIA&wZ6XRx?^=iy$GkXYS5t7>6gZR=WW7f>%Gr*_EDg;UwhwdSS@D0_<
z=^@h-gR~2SSy)M#?UQngpa)X|go>mEZVf!aR2eIGH8M@B1QQF-^DxMEBkdXt@BWTv
zqJ`c*9FfA@#SZJYrF~f*3EC04ZSsSae#m6!i*k1$!O*;{CULG08&Bz9R(DinW#PLh
zS_0LkSGnhpB(7t+HT~%$;q?myCPoXtt{tO=LE&x!?**K=t`He85DP#yEf0x-`J*ee
zlC4ZfQ!7~?BM}EYTc(JEKOD(4QQM9BOxF=PW4-8PGC^I-sFJ4qeW;_(`pth+1OB_z
zCf~h6Wk#6OLFO|XD9E~kYvew_{awUz@j&Lkj8cVH<9}NBgtXV=ccROXlW*!QN-Z60
z%As1pLvlWpx(B}|Q6ohXA5lf9gZ5mzD+k#;`d+yisJQ$f<`UWD9U&RB`~TmGf#uct
zI4W&a{^Sayr6#0`;FUFw$3aa(q+dys2#L~>bg=oGG|gRYt*oJ?7u`imLAp#xA;uZ6
z5}by7;p9T@eCr9@)@zh7uZiG5-4N&K{whk9k&n_>IDC^#c`7zSYx#Vb$AWf(?M7!>
zQ?~qgCSGPRMDCM2F}f*-y0A5&_$V<}-|5ne+;A)khQ0oBa@q7mFQhdYYVYT;^DqJn
z-JkBHameiJRc>$hWi5G#=^fi_dUOnDo*sxKHXlH5cNra*03yE_3}5A*B`3FrY;@PD
zJF)C$_9kMalcy}=tiM=OOfbM?f}yep@+E-^{0NC9iGlCygcEj>ie~a|iDP7a^>bHH
zD|TKVXfyQZRQJzgBPqR?DDFwY&=z++L5KFapM&Ey5?@H8R9OEl#S1$Sn*qgu!)qo&
zX$$BY=?{=a5h^gBu}pBR8J2@*CL-2OX0ovzp(sp-!wnCRv1lZ(@4;|`cjO|@bgT<A
zY+hmH41(+-eidaBZ_wLc?crR!+43#XLz<W9qXuJGqNnNX*psj-LRbxw52(l;?G+J>
zVJgCg7D7}qlL~XX<R(>%@pk_M5p64Whjb<mWXjKbZObV=L1Hm-U-e-Ls;V|E%5`h|
zmT9xN(jSpzQx=$ov_Nt1=p;+A3xbq3>@P+lYa}#&P@KmK>=v)HqE-BDQ*jf>7l*@y
z<KRxLQ5!YrLa2867MN5j=&vGl<d!X>wq>O_JYk-){PF$WQnWOKV)+y*G!vmt=*Y1a
zA+c(TJR7eb8^6X!!3!vI;S_H(eR%99?h&J^@fJ*HjZ(kDfph}bxr=$NQKZpi`$cVu
z9k*6LhQPa^FulBX3d8ty?y<cu0zcBh<E2RK-c+#^9WjbgGnRX7^cSfOE8uHD8!(;u
z?y;Tm<2W|NQ}^eORdYc=hFzHGN3<<VeHsO&WFkM=V;<qxD)i1{`NJKql5g0cbC3A^
z1uJunUP4xolDH?_Q!tSa^uQRR(R3Dn3BXafV+kvY%n}i)ZWCYJ*fzzks*5r!QsM*8
zmpMbHP%cN#30}gX%<{jf&p^fII6(VF)Y{Kl9I^;1BPMb`BN4=ZmQ+fhL-1Kf6Vnh~
zL^#<=(xrLW^W>=2Hp;n*3+G7tzGe&9GVv_MtdujZ%);_v7wz!O`v@~Jxc8UoEiqC>
z(`k*S3dC2kRjSlI-2v}t!h!(Rh@*t>!91v$t4V@nmJbn8yo=2MtSBH0we;`<Py&z%
zm_k(WCxvvoFa%`*gzW^0QSMr#v5!6Jv5R21wu20i;V@XMoCCD_P6hT6m4f0fLLg%h
zzK@tyotVh{&}#SxJ;8E6wkBd73>3+63o*;)h&*l(_m~Je*G)4B<|mwtNK4&1o#0dk
zX^EF~*KTA`4REh-L-1?#bL2)DQ%{}HD`Gm_Dwk=(2dO{O46={=OPgj85*W5&y%z$H
znSdswc*4aSy^f;>vpiw2zFvhemAL)>*V`-bKtXpDEZZxx_gTdIEoA4q57Yq80qXOP
z2`;{B!IBH^Vb1l?oM=T?8;YmIM`b^{Eo?@)dpid|GH=i!y<2sxHm$u`=EeZGN)FBY
z*Kr(nfU#zN*SXqoj2*XayD=YjpeQ`rDsl={Wl~uDO<jg#l%0sBy$-c@yO1Nhr;6@T
z9otRV2pzwX*8zkX>o?z4Fb>&bE2oU(J0?ZN|0X}ma9z4(C<k8=ro<DfHtx1NR7%nD
z8yTyr^axh>1##L6SLEhlfW6IZMg^j<pW_va66^3TbE`QZO#Tyca?dM~&YT`|u5~t+
zU8P7$Gbi9<#EzC;ouJ4DJ26xd6RXt9SC!8pywm2M-o#p}UX1lOwxi0WFAkFY@{D!0
zs^Q71&<W^jYDjTioc`wzRe`TCRv3cC?qXCTF?fC5+fCv_28~7_W{F$@l8gS}#`F4N
z4qUuWLEa3O-D=1H3&CAMJL%Cqg7lWdRW=mnH?esvvbz6P@yzkQBQtJ7$PU$o$m9!O
zPO-K7DGGH=;Zo|)A_1bG)dhU52Xai=ObS!&w`d+m9AX*b#@Xb-%<|tWb4Kfp;woIb
z!w3gQQHj)_P#@jd`%gtamYcNd>zL5=-C+Iw9?8)tB%T8^XP&TQ2x2)dfZV0Lms4A^
z{z9BxDwAPzHDDx~j7x0bYwYQbP#?;}@wrr``=+yDf>Ull6%(Ipf8RC^s1$b-gh%W4
z!PlM*W3FR78rP}6^9oP2ja{t7a&qa;UxgvJRj1RBrj^)p2f*vHHV#n5Eok??Q1wUD
z7YFf5o221?9G9&3;5Ku}c~-CyVugh`S8o?Sob+33+%0;-o_Xr=nCB4vdN1ksXF6aA
zMuWET43W|B3t4-?YGA1MuR0%nvawOSL1j<Smh+@wWl1pPAHXC9OKB+Y^(VAxVUYW7
zBN(4}t@f`mDfsBa7Bl0}pqLh7RB0*MYc!3Oq>ZK-HHXDOJ1CCFl`{uf`xDvo!3HUI
zJ265=!=oE?TDC;D=5_tHCPvIsjDl33ngegVhQZ5<i>46_oo8hJ5^;w^8j35vVU6(M
zsOMxX7um-njQm#ya=Z^539To1y;Ih^iW}}}UqnR>eMLb3Z$n=e&_9mRNAy7dn~ubV
z*caH5xF6|>+?VUD{C(xVJD^`~=<f#fOJj7bP#7WJYq;XqfgfKPpdE^Cuq3;9(G{Mf
z)s=mmKZ-D0!ug~6z!%2o1OB@QMPly0J3?mbd*_*Op{&6YP3|l$9Qr=YliR@Qb2ZyB
zw{YWp+ibb_h|Z90`vegb<!&0nOR^Ss77LCHJ&89R{#dk<HZvsP%PRM<56aj)9-=?=
zWsIWD<Ck(%l{k{SD!U`~&z0j`yotO(?`#_n|8Dv+W*x{}(F)r@*4>e;jDTF?P9wuN
zzRYw7+4>#!4<97w12y1mjzsxM8il2}u@Q1GUuYIw^j~B#%>9TQJ}2{zz%#bLo|G8v
zy(QBV`}1izur<U>i*HlkxgE?E;k0Yif;UKx{k5LT&}<zDyUs%%8xK?7!#!m@%wWJB
z{3<k31mVw4)sl$&<yhz;y7qIes24Ufa%_c6k>afhj7fP@`q-DNh7t3xP`!Sny@a&T
z<AbrxG6*Qt3Nh^&bRUyC+v`p2SrtOZ5o$TiEre({o~p{bm&Q_^|2&mHSA7P>>^R(M
zFis6P`%6*@*r*69EsWSA3DY!(dj1}1DeM)hkHTbUHUSRmNKF9C=BSts^uhP266Cm)
zT_UVq71%Lsc&H08{@(gZC{RH|B-Dlu=<)hjsFS;v1lV`*&q<i9U!miu=T)B}MMx&Y
zV>eC&NcXaMNqT;FgK58&6|ewgp=Y$%H0mN_|4FbWPm{1;PD<cwViA=ONAMRC!Mse}
z#vu}D39`YKG78=+tdhzi;}^&nyJHO*OJFgab*>zmn~iQ_YFn!J0*lcxjD2Zgn3xyC
zJVGUI9&)t^>p}*s8u})gBBU?qO$;^`kD?)LN{<zDTLK!KqtzI~wg<WQ7yIxv+=W-+
zA)oHv0&tMs_jd1buQ>=a)1jKQ|HC*o&C(-6*^Gl8rAhv4337hTz$Tf4kHz85Q@CGW
zoKYAm1aY9FxN#?AMN(}T^yvy)L88mm80=@U`f{|I&5CW^)D}P?pUvKpv1yi{m|pqx
zzpkJ!b<cR-K_&3(Nc6>%Yvjyug*4vUU^2<Q49Xz)<8Q$Ty)*;u7P_Gkujtyy0s_(c
zA&i6iYpo7nIV&aj*A<pq>@I=0vXkh7w+9;o-6{r35CN@C%A9b=XR!*k!?#E$EwSQ_
z0Spg+ZyX({xf@(xt{GY%MjJ~?Ok!~f`}ISxw}DNY){J97K6?tGE8~=!wI<fmhyr43
zm1e1wOWkNR{v0hd?=Kq?e$sZv63ut{qC}^b3raWWtcYHyb}Ceg=0;cav+t<(cb}^3
zv+mheHp+d9BJ1Urf~F}y%e%^Ti56A}K%!hba)LJ~U?fPdrShk|#-2#Xv5^=ZN$fw4
zW4*f6Jypl-=}=Iot3?(snc*_T=NNye7kep68M$$+BvZg)M06OFAz4^%?Ol4m$SAX@
zKdXqu(#GGT?fZPtE|>Jl!<b^XAeDHRI9M#5@AWZf)}MKTb-v$6$MciJ821e#Jg5`i
z7a7L`H9}=f(aXD9<YIO=^ntTpBps&<+(0hg#fbmgJJlJQ+6K^jGlyHC_en!<-9%sZ
zp@YZ@@?lxURFa13M`Kw-bUVRC3a#%$&u-@)JL(?lrPVSiKrx2*3}GGU$jt-vf-8q;
z=&K;2l2j%Vf(VNT*#)$PsXE?bOfVvgnaa8c0q_aY&!Q{Yf%ZCVhIwv(m)hS>G2S!{
zC|bQNF%70$DfZ#M=(r2W3n|MW9K%}eOwE)r=@0kI74mTr*TuPO{ibV%F_=?gz4e8U
za`*kR#c$Ke@sXXTCjf5Div-bXFW;x(94EQuCRHV-R%!7=@v$031L#s*_=DLu3kheV
zl;xRb3_hZ`y!;hRYZk$!Z0fp4VSRK0ZtUzZK4k%cH3<GmpY^TgsOS-RN8{bcl*qmg
z8``(13G~*})+)r7o@GJnnKPM7_1P-9vQgdVC5B3PqxxtoC)KLMhZ6X04P?yG*Zacc
zgnN7v!`a2cUv!$nL5FIGl&!*lsSr~<F`W+un-TCQqMtSV<ZnBGZ6xj!7^aAT33l3Z
zgaJdG!^K%RWW-z76)Z2Ts&XIW6LRO{9Nbj3lt~a|-MV-w?hnp)LRb&Q@iSeq@f=L<
zX`3$_<L69%6&2}Y5z$+#Xfs|5C}6jo7k9onWZ`r11uaG?4c*8Cs>n;L;^PPwv@WqJ
z3hSLTlE2K}<=@glhBBXDxSw8U9Q=e5pqDyP3PD$G%+gM(0`a&O&55?}V!7X_I}oZ%
z<Tvi?N>C<pt>wGz$g~0fGk(}-Ag217Bc=En4s}7OvGnO~(@D;-AI|#B-w68(_kpUD
zup!{@q4e$I6!19pv~-zgc9wWB&4kPQ4Qg|ObBRPJM3WDT5EuK6p)lW1&&I3#QKIa9
z9iLL+ma+4teD(=!J3&X_UVr_Iu!cLo2@2Uqa^-U2Kup$sVY;UwL|?w^iPUsYaTLIi
z%sqTVceqs*uq9&e1{jRS{)rt`%<8EyOLlw`p+DbtV>(Z#%rSFg326P@lB0yoej)ZB
z*{-2+bkT$=orTN{<N*4F`4*#9dTw~(MUo>#fDjfy2)pLKkc3czUmjy)?B1g~jSKY1
z!tn;>O&HxAJS9sLM@!7X4U8{~vWVRzit6B>HZ6^WDC{Zsy9NbQ!~JfofH8?6d~Wyi
z2A4lSjFARtf3eSImILBQ40Xvzd6*c-ld-%1963~2YMhQ2{{jsY1Q=7pAbB#YWo{W{
z?rPW_zF|9#vdxW7k2LH_-!RTq<FN6rwrNwBG{z`tQt#}=U%4Ne@^klC@CtR*rzEvr
zE#{D=Sg9u7pWyKQ&ZUHpkbC~<Vb&ntP!vhjy2>iIXR39{>Z7aN33#WWsK#oaErcC0
z1`)JZQaSo;C4`ROqCR&|1<_puP)C@?xSeFi<oQ<!?n?KwJZQ&qy!-89O{q;;p(PAn
z>^|(r9D%R8la$P1ntWSj{MU?1FOrxOy#vDyT&#_${T558$RmcnV(}L-+;aekBK;BF
zdyfKJ@xgAvGQ(5&KK%p<E;$CN!^2XToKHdF!sd{ND(PZ-z})p9x8fMcd{mIFQk+F|
z;NZ>Tcn<kQ+94L1oQUlp9w+VRARa+QMm#<<*&pJS1me9#2T`l5kG2)tH|dxHJ^Z6u
zy*8CN(4+r}S}A~;gK}`^V^Nyh^)k8(Ci?J;IzU1q7+I&Ft6qk~5;)X(k6IzIuQ>`n
zA=>L)5d&SSCEeF}H6CLKGO{XoL;fZd4LWXytOfl=Ngy_e&^it|qu?1+HkREJTO+W&
z66doP(goh2_i;ChgwNAwgkNH~4KFQz1MW1nh+g1JH=1&wjMUGvKR<{-a+gb5Gno1~
zb}Z^30D_KSW308ukLG?I^hCry0jF1Joj_`dc(*lx4TZ=cWGQ>#R4ME#^dR#F=`SP0
zHDpCwJC%I)Z0qXrs6S~f#s*W=3YXHr!hH<}S<7<f%>PXp?dypm%Vx%2mQ6;!{LeJm
zt^2fWaOhrthFaOFd6Lujgev$p+us{8d#MZ@B+RS-84=)KuYiZkb|=`)Ez(J!b5;(V
zb2%h~2D>1ch6L2Kcd|*l-u_wy#e~9IK+7^^6!jshTn4wt-A8|Nd>jjMSdROhkT`IL
z`PXUP7-B3G-|uwPnL8BsF4Jt(nXUV1;h2Aw;sL^E-BZZL5_daGaeU`Zon{ceqO!ja
zzTRIP=EbgpusPmLv(xMibj)&XdmEkx4y#VcOQyL2>xg`STYt?FaDaW-3~OgO(@0qE
zN?EqW3PwQFGM8s7Dywm5KEmsZ+ymdx7?eB1t>b$RsAOh-yyW;sZtyN3Q7YVzs5L};
zIT*{UwzAeU9OKOZk^4Tw$=^HO>zfTMKfNMsQUS4mgiP|)su89&4g(gNrOs?R?q?%d
zbP8P&D}P=}GZQ2Ec~r2@`?-hKGScsZ1~LdQRCps(4C#ja(SsE^GfLL&5*h{#{TI`G
zI7+emi0>>7@&SF=-TjcEjC*>}f7)w;e281$4zs+Q$Fcy*E@h09v0C0_PkjD`QqBCu
zMi8?xU6c)us9-{!r#PC^nC_Ks)%Ww*Jwp=@IZ;yCKJZd<A~T7?vZXeiT$hNVf@lQ?
zvE}9EecZd3E-IJ*c@x{ytrHvS=TH1r{ep@0O*IYewW(-A)D6t*n)uzs1*xV~Ykke3
z3j~d#>gse`ZEdQqI$i&*RCU{gh03+DzP5q8{BQ?a6oEzxppJ(E$HD{ce{=vi{M<PI
zDYlalUK}a{8(^!+b7LMe!a3M*z#t*OtI!=$r7N0u0yA>vy@Y#f3xgI$BR59knS(uH
zvO<W369FbHJr9|VF-{sz;MW%T!ot#@OOR;<@<nb1ZS*A>cQUDDXjQVhaXu_n%E1$2
zX*<u50+=)l6FQSOOoGRPl~-}cfm+&t{M;5*xz`cqu=#bIpCzZMO~PMAACceHdDQt$
z-b<c;AA=*}V7O9+EiUH84@n_mPj~mKa(^Jn7y=gnYJjRujOJp;Cpt=8t%e#7w<5$b
zu1#{pKlT$cq(*l7;xiaA49XQML-FU-T&9AU-rWvRtK>MwP=WYh@t~dNU0Y+w$kUIq
zdOO^Wnyxb=!L7-o3jB8{<FH}J@?seGbcmNIGWuv2KFnX@ILQ>w+?a1W+{&qw^b~DE
z<J?CDn3?Gi*xph>j7T@zudU)F=vD{DRf#*CGDy97@g{wMm}~wtmT_?slTUu}Eo@(D
z*XW{`F#y3b@;)M3Z(J;=fv3a%rN$|^Zrt4vf<|p8{gHgGgwQ7vuJcs<4I90g_VZBg
zexm{;bj{bxf*`_>ZXk!-c~9@`009SpyMsq(PbJu~4CqLjyS#J-(LxXd-n}wkQ$k5p
zOp3R#!%@etibed2L7ALRT7*GG@Rvg%q`6Vh3hgQ0tSF%bL1wrT)rAIT*=jM~>g8ly
zfsUp;-U+<|W0Bi3ocN?Ez>-vDl&TlD9&<j_JyBkGb~vX3;i1hX#Iv)r<al>FJwvp>
zb+iW~?KLWh952Ad4nqTr0QsTGCQPK0PQ)BUKrwl7ly9FE8Xaf|#1u=Tgy}LeD)HIj
z$D#jTIEP$r;*{ndgPi$}ALLI$7TA+WCEYP*Z=!8}pl>^efxZb&BfEOElN$+wF@MOF
zg_`c7Bjif&XJx02f_&E2CPH{!pVRT$Kcy^Y43Chx=B)UsM{&mn=yT-v>%zg--Y)$0
z890-LMf5x73GL<YeL7+h!;zB(6h*R@jPcSvrSSnZ?zb=(DCU0TbJ(TaR)Yj9{}CiY
zrSg{Bg4N+j(t>E1r1akx+a{k)9#5=q-iPQ8ue@-dm|m35iPO@YuJ4#QzrJl>C_y_+
zOeR}v7Jh#6p$+v-?Hz|MXll=uz?a)r-<UFtiEWEoQt2qFOSdK44xKdNbCV|2NL%R9
zYYRj0Dk9z1+FsL!a<O*>!ZLtzOShzIz(T7<=#b+_1RXLdFHu^$%!hjn;ML#w6-0a}
z{p|h9_ZKcd!S#z1_4SWA|582r;N8FVL?|*qc{KMOVRZdU?Y2CMzu6hT>BUW6R1&ov
z<RNpzixFJ&qw;9|ET2zhfFBazI|KZP0RKM$zG1e<e?!`o-!%R!pYbPo_;yc|NaY9~
zf28{%A@fV}U+_cbdi(-^iRd1FCD9R~p7zL}Gx;z4sbBSoFNPN~Dg>|m4-a1(;Hv^W
z`i6&pVx1L5HwXA9%^qGG>c26-=cPUTRey=L2l$k**!q5e{|>n7Ik!hW{}Axkp6L-+
zz&ZN8#edcF+4DU7YayRc1AOud511V2){95sFTBXZH!Bl<8jXUFzSzSX{3RL};7hLc
zfXM-VM1ZgVjt9&Q`K$Ys&zkRg_~rmVJ-~-t?&0GD-4+J;v}-(kioZlUU|0FnuJ(Y{
z{e3-`2Y7V5hu;|Jd}V;&c$bIA{r=+sU$f4`zvi=v?hf#RP|q6!{NVt<;u4R)BGi9p
zfWLErhfnjD=;Z*fJl6v@1pE&Ie9gNazBS~Z$9uJ_LkRqq*xxAX8{o6laDJ8cH;P6E
z_@012FXaE(06%Sy$A2f_|682ThaUb=z@Hu9t3UDZJNzX&Ex^kI{ECoILx8{doJTw?
zz?TGg{6+dZ0{klAc~S3Z>nPtLl>vTz!2ew-H~jVl___e!S?1xp0{r0sKkPTY+)DpC
z`fY$uUgqH)q5iK1_}0Z9FfZh@JHXe9Vfal8`4n39N}_o^##ae&^-H`wwKn8GG{EPI
z0r-8*H!nIQ#t-9nyuFR0!vnl>qsLzo#_2Hue#E^V9?OA~0{n(89{x_KXEMMyzu@7k
zBxw0H2l%58dU&nBL>&Qswit}x`T$=M;5UBi0ndi~R|R<dP5aXV{+a;q+uI|a62|F0
z0bX0-;T={=6g?K;zYFkb0lqWN=N+H%)ByiufX5TWxdHxmfX@w)Rm%hXZvnoe$d|h+
z)UzLSRe!}_y<QXWD+4@^h>;xEZ(@M2ea2_-Xvk+;fVTxcZ}8~R$pQY*YaTI{^T_}|
zCBRz({x^Y3Zh!Kb00@^hgLjRK`0ZH+uZSNr*KZj-*5(;-bdJFXb^*ej=dVF~!Iv5S
z;HbVwk_!wzB$6J^{;f24S+rzgHZ+PZG5FB#K%OoKzAyXXJBD8##S`E-;dc$bw_aOq
z@QUcRpci8N>kU32nrYV<8bv>{=Yi44`?_GdyUE~#qIn~`!`B#mZ#vv!@V)79o5A;{
z!<_~n8WqG06^dC8d|!0<h2fWH?6J634;j27I_Ac}fZ@d>1|JZ8y)ee~*T)P#Fq-o~
zclhH5-@9Eq3_hegGEYw#eAr&_rwu+dy6@8NukJ2meBos2X-__t1O5W=D8EniVvzrF
zZqJc_f5vHSPsVcc<p7WE$yp&mr@`aYUDuD}d}evN$-dOjA)l0gLx9Kmlm~cuuqWeg
z8)|T$Hv8{^IpAY+z>mxUpK9>(=$cUO=uilLaO%1DFPQ`0o&$b%4*1F(@XK?+Z_EMT
zVDR$j#yOtO%e~l*w&lQoJO_Md$Y=CGpF!L&FXh00HQ+Y{{Jw!yy94~}9{Ch9PSo#v
zzU=E+9`O4Ic)=;%;UfdQZ-B=mWL$tB65vxqK3@p%g#rF7_0VrtfUh6q+qKq%qyHP=
z+rxZea&P~lA;5PG^Z2y^|C|6HGStI2`07R%2l(XS9=<E!uMY5s0v%$#b8~<ftoIpA
zMqlc;(cu0*`|s9(zj}zz|LpK`M-KdFa=?F|1HLQde|FIOv7PW<4*ZXD!1I}is(;@P
z`K%B19Axn97Ww;;Ip7E9fRE1spKNgEN1dLY@%Wt?;Fkn=WvIf}1AJ`{czb|v5Ad~~
z+|g2l?_K|uIpA01fM1sbesd1^FLJ>DD+m0e9PnPn`<7z|=YWsT0iT=$eq;{#F*)F;
z<bZ!Q2fW4L=(S)EA0N76ae&8PZHec17X<j^Z+m{YB#f_XV|b7QOF}+31$b=#WagU&
z-@D(p1pFbv*)utyJQ3jY27AVd=f%4M{EDr<K6?WG`vJb<7aqPmz!N2Y9F;%d;m-#6
zpa9<$;HL!m!2y0mm|w(l_45HfEx;+xe$xZ|_yCXP$(#TmuL(83FpZDC65y)>{p0*o
z1~=4hf6mGQzaR(v+8pqkbHMM-0pDWq^5`(<>0c0PwLQQm2l$2ne?Gw92=JIbuLSt}
z0X`+*e;DUq;PW3J;AJ@4B=^1+;3EQj{{Zg@@R)9&3-ILu9_!5+0e($@SB8B4J;2xZ
zfY$~1&Hz6?;HLw;GU4kP>zyS59&bL2{ZW@1JS5J#TpRGO2>HZx`$2%mJ8Dh~Y1Rh#
z`0bv5;`(d~@Qwgy5@^2%WB3yue_F`rsQ};H1O8HgN5Afl|6YJk>jBTlzE!`>D)a@$
z{W~<k=LYy(pItQ8;Gq&(m(K?L8^V0{u<-6nIq?4@2RxYr-k1Y^Ru1@uIpE*T0smnR
z_<cFx59EM9mIEG5s9n^QUep*(!2dqs%v5W-zPYK}Lv^cvT$oHRj3)TMO4A0sHPw(*
z2H~!yp^dxd+GJZYnvhypUDujyOjR$e1v7q%CbXqGz%o=JDi6|FJ(7*}H5As&d;WMF
zUbi+^w<K$8>zfvUm73qapt_+MJb#;<Kfg6~X8cs&RHv*AsWsWOfMtU4Wc96SZfs07
zk$uRfzKJzze{Xe-CP0d|<b19RN#O7NHEOJ#&oaa44*lc4I@Q_=imGpqHH|IR^<=GA
zy03{J+B%x5TUqNq>o9w#$5d0T-8Z&FjOw~%eM8CvYT8@V&8^kxg~{6Hv!c=2z;ty@
zLvuRi^Y>`=P4&LKy4F;xp+3zjNAgUM(UM${s;+Bjr^~FaO=ni0)mq<{s%}itHv$<(
zI;AC;?gdq+Q=t{Ul!j#5Kl>Cd^$otk_DHj`Yt+`<PIj5>7lfP)wY@2wN!xs;fmH7<
z>|}$wRf(ILYg5&=fv}<2hR{}f2R9gEM<AFe@!7o~le+S5?8>~o1-467pOIQ*uR{)X
z_4H;oph;{R)2=buV)u1TV(1Lr)z1yhuw{$~>DmRVIV0`yn_E&%nYViIbxP46)}5Xw
z^hlq#rm~U>)|yJzrdpvysG4A@j+zETvuxAtb#?U}aCuw<C8=I$=`t|Yx2xlgfT81+
zD(1QR`K-hFrWlHHvMd5Zi-uWXN%cv(y5o#g%G1UAsH^j9yZ3HwYjcZls4shAYkkuh
z*;&)o{(Wm|ezGCiRO7iK12%Fsw=Alw?V?wWJ^N0N-?uGn%{02^tYm{P#NP6%x~+M^
zf(D;;ouW*973jmpRHN@Db*LVEHbkQ&+Z)<6oDDT}N6o@i%^AKTE%mi<Lps&!StTF<
zHGI#xHpHr1n~`cFw*gi8uBXOS>w-`jKjiE+r2aeqEHcK6quhAi7Dy$z_JyiS#d2Tw
z2sK1obE_6g{f%)+ph0a+3{f?`sHrBZlN7hRM*CYW$=K8^9!<7Mnbi50WStR(Q49Sc
zPW2K{111APXlPxwz7AbLU(`UU7(1P6sEg`qn%WvNAfG{dQ@1P_hFw{Na_6TO)Hg*n
zK@N0@0}-;?KW4;{!MZ=CyO`EX@H4IdbRT-#H!c>QdP>f34ve8E>7F3Ne3>nXgW77z
zZObYiX6^nFoJkGHViVBn0ZW8-$bOy0d-l31)m@R83{5r0l`@<T&u%TI52A*2Ds@I=
z_r66oTIid$R76jRm09PnX>O{sN?Na{kS56%KZ4quBpd5kQ*WZX;bIe&$=WmPgRbgI
z(NR0UOHNTGGU@OmrVC7w`vRL7g&%9%Tf~+P2vsiGtbsVMuJP55xy4u`+1A$T1@_)x
z>d<0hx3)VwSsGrpHqURTbGjwWm6v36YxAPWYHH)IE*-T?U8tsQ&0QR;n$j;Rh~+hU
z_x$6G)aBL}8Lb~{)4(Y4qjhT1n8~`x^GV>FRAXavFbROeP(2a-bG6w@*=(3mT%k0x
zV6qWvn%iS*CkU-fMMDypK086}{Caydo}_UtfzhpzCd?;gNDaS9urgdMkVG;$*-*cr
zsSBZdR~vpzxtN~cXlB5BF3%9t%CTz1#bznwSSZIVTi1|W(495AL&U@F2>+V4U=bn`
z#lSsb!b_$zT0+?ittHvkWt|C7=hcQ4Pq<2^nr76h36QWl9tusdAXa3HCoFHfY((L9
zRaYw5kW?2WQ47XK=9y8Ikt=$SNn6Ko&b;TjXA>E^@Nq_o`eE#4S-J)F-sZ(cfSbn5
z^qm*kbXgkFCu<zb0#hShzaZ7v(zb{i=pGYKcX4L|X-uZOw1oBeSxGpAH+GFN?G3=D
zWP^_oGA)Aoq7<_*tE=lejA-2W>$KBPIA+f5W3#4>|La>#N11BH)8ww3FmIj}90|B#
zS-+2nD)PS};fk9=@kY%7J(?B#+VQn8%y+{jQ%;PpmB~-D($DSVGmfuQ{bQu^l_vJH
z1aNc^H@maaUlG#B*LWR0E<dh+oL<YBa^1)E>FDR*#MjDDV4OZKKfWq1NiM%Q{i?8@
z8efOuC(ZuF`NXg<a-+QB^c#XhC%#@05aV=l{bTyi4C%iV@MeYe&G`CaC|~K-w4Uit
z0;YG9_^;n#B52n2wXm+?p~RuYH{p6ZSEY~ZKVqDJ5npR#LIwODkI{l2>Erd~__`u)
zXh<K|KRia?4C%!m`o-&o#k2hLDLef&{@b(svv{HU$LZ$<KkK{^f=1E2f6#vUGld!4
zzM1%zt)qPUO5SDvde(m>FI9G&K3*SvF{Gd8v&qyiP9OKfRiw=>f9iogr>O_}gfU)R
zhd6!wd|i+9b3^*MA$=UL6yx_ye*-TBi|b!J#@`i>@#XK4fXMoV=42qZbJr85mvQ=A
zd#r=^#NCu5{oRjwjy&iejK4>7q<{WNpMLp6s!i9gXZd2Uo-kp5{X3ox^Y-gXtGk}K
ze+sa}x}!z+ulMPXlz__m#p&bgo4nI~&-8m<^6AHBrPXbmF23&0f@PzQ+U3*lzAPKs
zl|F{%lTn;k4AXT;+K;rJ_3Ft#eMlV3j_mZaLi#&G=!(Qz3;*Nvu~-;PdSBD*)Wnhb
efR$)$kIMCUj5N&lm44L4zW%$U9J78s)Bitjz1G$M

diff --git a/src/main/resources/org/lmdbjava/aarch64-macos-none.so b/src/main/resources/org/lmdbjava/aarch64-macos-none.so
deleted file mode 100755
index 99858e49fc1eb11b561128aee6efbe7a944796b1..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 135224
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
GLFzw?Mkv4l

diff --git a/src/main/resources/org/lmdbjava/x86_64-linux-gnu.so b/src/main/resources/org/lmdbjava/x86_64-linux-gnu.so
deleted file mode 100755
index ee2e17bf647c7f90c7c7d4f9f7d79f8fcb8da64c..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 308688
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
G|9=4X8?l)H

diff --git a/src/main/resources/org/lmdbjava/x86_64-macos-none.so b/src/main/resources/org/lmdbjava/x86_64-macos-none.so
deleted file mode 100755
index dfceffe6966fe34917667e541759522100fce1ab..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 100150
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
KZG*E#P5d7NyZXTZ

diff --git a/src/main/resources/org/lmdbjava/x86_64-windows-gnu.dll b/src/main/resources/org/lmdbjava/x86_64-windows-gnu.dll
deleted file mode 100755
index 05e7b2c1149d829f2c5d94ba1124ef83428020a1..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 260096
zcmeFadwf*oo%lbK3}L{?8IWkIsH4R;saA<~TSlzT2{YjwI1@kt(E?i0DcxG7VFpkU
z6DNb59tYX2_Ojo)wYRO^ZY%B95~!C+Kqg?-fL6Iw8_?Pr$F@<sA)qq9_vbk?;iBE`
z@AlvF(wuXi`}27|&*%O;6T5b$$LsNUeEfgxzwogif8%{6>0{2`JjV0OQO}&y<+YwU
zXU>u@E(<PgyY&lgpZ{`j@#k;3<<>;-hMR(I$y<V7yd@Z!c~$Vsx88Wug%drVSy7MY
z#x)~7U;M?pODfF|c+L%;R5gaoYLDj!ZtA2OMi)@;?J`dFUgh!BxY@%`&n#w8o<x=B
z`r%6Dy5)*TA5vYK?f*fw=O0IUJl20ydwwa2m45-Br}ym22hXt2vs6C&t34BrNv^zp
z^9$9UhRVk=&$W+Kd)6}EzxD6J#7!#`WUiUXoMk{V_wqa{b%Gwx^%u6?`1!==J)WUE
zNWGpit9Z`gdCb2sqrC8j<QH$g@ryU|uEy$-zWY9;oZFlyERz`^U&`(JK)LLNOWlGB
z7Qn<4q}&T1C>Opkaq}{ATyRgKoV54X50uMZ*ml#+w=VX$umq;6+~5bwHA`Fn`|tmM
z2+TF?KN#uliJF|+T}FBruT`VyIF`;PM(R0_Yyu-QVljxhaLf9+^SX@j9#8(Y?kbPb
zxYfw~$HaCD(84*o-K%HXXF?THL#M3xsGT)3Cx4z=#$sQG;q5Jsq?JqMyJM>~v1s8I
zJvB68#e}Yjlk`AD`+j!W*ofUdoLd+>quR4Anx*q}mO&VHWa1<vlgt`+Vq!2Cnb;uv
zWRqu{$J4Yc+O)k?xBELZZVwdyHGZLXb|<6qc-E`=Ir=Pnr;({Ojqd$E!-@C<mfdaH
zI~E$H{-b5Jvm+kQhnKHsD(BLi5$a8jGgFiOOyy$v)*`)z-FvjPN`HRGV>r|OQ@q+Y
zvJ*Vo6WN7Z;>Wh{H{1fou_d&#!=AbGuD;4hz1d)7Zk`x)zEa<HGTj{9Ci^70BE3u3
z?$7G>TY7gPpr`hGo3hc)-sE+X@Ao9f8_uXwUC+N(d(zo1s(F&pqGdRG*mCrhhW(sj
zciYcfc2BA9-;S0^d?LM1yT7OV&*M|Cd&8Y?C&wC&R;pV?3A?)~%fgN_Qd=87cOC0h
zc`-`oeVcqW-ZK7-bM#dQ`+n?|an>v>)X{s_sr+Hy!;7KH>sRaZ^tt++W9Mnu&l=8c
zLCd+-&>xejMn3xaRmqED=|3fIH=O&1XlHXt{?+}L8n~7QjXb6kZLqt6g5fN9ZdP#x
z#kJ1;lpUOQdQeMOLxG(89_G7Lw~lIty~SXvokJkHGsEB2eNU-0W#%PXdOHb*bCQud
zRMOIq@zJ!a@D!B|XWA^oX>X?m!<jk1X_qmjLq4>B?xDw*$V;ibRMu<QE%ipO#ZRt>
z=OlUNS|+Q<nsy$gl9xvA+083u4I?L6lG5j<G*nV@En$^ouUKL@t=AjQHy+|U;!K-l
zcK281fBIULr}(MAcVzCU3~6xl2>uvO%X}>`b%{1MJd5Xio?)K#T3|+l7PxA%7WkZ@
zjh#P98#^ngjWq(=SgK52X}B{CMC|w~XW9jJ%gWSHb=&8<fRSgDY=dZ1wzA<Y=e}=B
zing&<kJ>x*jsvB;;I7W1`SGYdenvc+-mY&tU6n9<Eoa`+=-S#U=^)~?(ouK473yu<
z%s`iJ3w!I;)8kLwRqt7ODwwdAicQ%kpJeHbDXoFFkwxvvN9DtQD}OgLw1>(lsxQzN
z>WlR2z*%RJA?u#@A1Rfb>n<tPb^o7gk8bBIXX60PrJl_5*OMHbyGLGFevf6pRYtcp
z-<G|krB5eWccPOZiIdID18NxC)qYN0>PeiO>h>C`o-o8=!0w(hb7Jyznt&eBQP*aM
zSBQhVP20&yysq23?Hxw<ftu-=37;@JwzSisp6jfWHsznmdpl1-_o)3?-Mzerx|1UT
zk#0vP+0z;#_Ef)We<kg27LNSUtLu}ey0~uGdrNgcBBN;+gPpNnHi=<Z8&0)3CEAc2
z;6)*;y~s%Q%g)KoO6?d?IPg9|biN@w&9D#Yb~fMqC{&%P{{*lV{^>p0d=LMNf=1`>
z_{vT7Q`S?smuzZS_S;hF<Z`9uQt4^_te^W~``x*wK5F;q2Y2b`>{SF#KiDJNJ~8$K
z%cpnrOHRkDLg6B#*uuLK=Qz!)Mr}E`<rL3oPonY1lE0}3Fe`$iMY@ZdqUo$<$2`gN
zOsJmom8FF(ETC!sRuc8c1VOvx&*l(+il>mFKPK?+l0Tc9_(Q#j^OZ@u_Q;Fg9%J$0
zO@bGOeK`N-RG}o>x@zS+J*ag~2QsGjuZH)a)p*c!?pv=4w$8Hb_<X}&z0_W`%Cc7n
z6>++lR%T>;%Z=`SpXuF7ktH$vO_u0-*5vw4vXuFss16_z0Kc=53Y&y><p27b^xx6|
zQE;;YWa&=l#CH0#6^${<EWAuYbS)5>$QEu1=<U|TRRI&W3Eq56cOny4vWIDDzUj=F
zIA2C%WqjfMto|x+e}8KAN>AcrvZdjNhBJGq_N(z#?FZhq*p&L(@gCW&&b*aIsIP55
zo!ryK2(+<l1a_wL4f&Eqni9)wly~P+`%wPVjNY_sm{X#Sy=ruHOX*0)_r70>J7Z&u
zvv8;Uv%gm(FzmPUDKgU8q)|N0bnbabN&zC-=bI0eN@RpbEm~zbQIaP$WeZ!u-=^*P
zMa{B0Z{_FlR7+I&2^sEUv8iil#?IyE13G)ioU&r6*69f1+i%(1^5;^=9w^*S!cmrW
zBK}SmzC6jWUo;laUfGmoqT0Hm49?M)7<SZCJo9K>7k;TbhrE`3KwI})idmT(=xy$h
z8o0BnZ^%fO62CK2cLhAZUI|O<TFcN7Dt6DzTyUe={Rdz1V<)!fv@DtK)b<;;Hr>9g
z-*hgQCcb6Zd-7k=nLH4_#<aKTZcB($;Oxp*1ga~LIa=mh-n;<~G3*tJxLRIXnl{;T
z?h3?c=ey7qSscNwt^xj9R1Z<zq<k^u0y4FAGSa|N3fq(|77=bbnIH1g@%!Bnc!jk_
z2#@`&<$OM9EWQRZ|8BKC_f75IuL($;<x8#19k9^dE+SqK)~+6W($mh)Y>cm$F*iGr
zh8IQ+na;fvW!J`=?Z|EKnW<dKOg+_Srb^YzV^aqsmml#Z-Wco&B!6SFEo2)`cdUlp
zBHTXTtc^`H^hvtgKrXWKJ;Bz_i4Re(ITh&|^5)M8S9_efZx(+@BZ*o)v|!=|%SPxn
z52t07qB2_g-zomES4;Qvl<ErG?Pxz$v~+<)Yw;~BWv{RM9Ut(XCC9Iz$IL`aM$Wf|
zT#uQ0-)q`WY3nxdG2K~J94ej^vyZR_`3J6$wJat2OdGm<Ma)^@kEI6_``vZ56v53u
z^g9;DnHi8N?l3c7Ke}xBG+D)80X!iViBBM12tUyWBNI;#CQj)%ETpFG6v@wpWebYb
zV#qVsvQi%Ht*g9)JxEa>1qn3a8>y|vajUM{@+Yq|oYjVNc6wi;m6Z(YPg34f{OB+~
zn9iDBQVg4!u9G)CmGkPM->*130<(tl7>+g4Kd6uPC0<C~R_jeXoB!73)t=&RBZpQF
zj53e8Ko&?V?hGA(b}3rIyxh^ZU%%=vT0oH?ZR|)WTSLCOU*O+r<flt>x{)DGQ)w*?
zrrkNQkLFCYh$TEd+SOU=<)UxOhnZS6(eNb32)+&RU8>XWXEmJGaQ<h%mqug#`5*EE
zt_X-aUsf#etq+4z;hE1?dyd_~u71IK)j%<V3%4|hVsMOrd|ZD0f0sX~udYf~E!?sh
zvf)`+=!7S``opmHAZYP%y73DNj1d_d3i~_I0D8CiTo6E*?V^PRld9|8cl5hs_ix9W
zy)0)%$CLIfC90b=xjk`m{y7>G8DRv3l|2II40_5N<<%<L+8=wkI`Ppi;mxu1Yd{JS
zO);aY!Y*DFzb?GMo65b0zRZj@5gs?MA^$ZXEN%aoY_*^lzalR!@G;mLz3Dtx$yBK3
z$^U?2rend)oO$ydFr>oN?$}es*j7qu(53}urphf{i|`{~VXstMx>onX_o~}2R#NTJ
zB~h6$KyUj2pJITc$9vX}N8E!4BCsN?zHGu!!=?k$2)+Sq!_I^ml-5}T5F*axXu70z
z9ww!{4I|E|h<zAISnGV6R2}hAPaUe(Ro78%YPYV$4Jl(EHXPMh5&goqTc#SZcbU|P
zg}SxQdr64dPn+GZ`dXa{ABlPQMbPk^OLpt2o>DCI&WeFVFR$L>Gi=kKg10ec#S$%j
zm5<TbZ#C`8e~CA>a6$}>)MO;#!Io9ETIV^mEg;eE{u#X*xpV^wljJoMdk7A#cgbi_
zyz}+I9uT7xXm{UDn*Jp7M$WpPzeZ-^LssTdsaqUJA;`AZ?lx0fCz+w=mR$|RmNpOi
zLf*vd^dIE&`evtg6KdB(RBoP9+oh$y2Zoag>*_b`^dwqhjb~Zj12DaqJ)m!r-tu2#
z5a9W@3&Ka4TK-~mP(h$2s``CGKk|RxM_x`zEPOIJh{9n>Q=r&@Elg^BTD5Qp;M_9c
zBKX8|o3EVZmKe|X=76+7N23r(5J755i)5O;(a?~#riU?=SI*vL*a5~L1~aryu`vpi
zwN7CrF1b_~Ts#l$hpnlVt7&JqQ$UeRsSG2wLX+E8vbcTv;5Kjab#v#RUBNrw+kdpP
zEk@|<wjC8_8oFd;@^QmEWH^RDuZM(+X+~(z^7}JWy{<jN0Cnsh1M>)`5iQ`;w6VUk
zDFuET_VY$)=ZcpLi`nLu^O*`oPF*$;x!{MBS%}0fQTt$|Iux-7Tv|SUB#MwX|7k{)
z%9av~qA;y%qW0SrSoEOzu#bFLdUhS$rJe1G+B;2p7JQ{*>lB~X_NEv)qS~+eqKz*}
zBSHP(UcGTwvZr{e{-g-Qk@KHu2Q(Oz+`Zv^L@D;)BQ0vbS3Ljd?v1ZEz0XAKem%9d
zqz0JUQbJ^nBCq;J!n4{;`(+WcraQjIi2b(d4yM)dX;vt^tjY8qir5F-$_E(ZHmU5T
z?rG>dY9^W5)0mBXQlV`Zf07v~Cz)`z)BO3TKO<0Ad$@2bfE2c83yU)H8_06j$W$!n
zQ30o37UZ3I;ii2eM1RW6tPUHgE0D)o>-=4N5nQ)`<s)<$bQO(+^Jnal#n<xRN8l);
z+nr|r-psU4s>owlrx34=%=94bCEub7(yQNTnXG$TCYu$Lg|lugqsTwEo3_B{(-@dN
zRQzmt+{Kf1&_VF}o{Nx<qjq<zQ`@T#c7ug1nq}Aa6<_Y!>gwT0(ks~zAVkMj;U32c
z4e>I6DO-Pn%F1Oe{t6<~pti1?G1xC!&TUJI=TydTW?D*S&Zq1pX6gu1#5Qf+Hz_#N
zx$z+Kl41W|AafIY7ABJDv+P%6&cum^a|b-Cl;{WlF4F=dwXvwc)9MX-YCX0b#NQck
znVFM$PBxqwN`mS#Y`wnti=)V+<oAjoy+;J;i=M~mSuSoHnQyF>HB)kOemq%)Hr5wL
z8g%EZ%nx(tVIWiDg*RgBLBpP1Z#h@akJwq$-Xe5+W@f_YW@Iio-LSvHklLVYukbp_
zsBT`$fF{Rt*iM-)7^{boa!>d9l0hS<3-R#`daB?7yfp1{nFrkbOaBHs*=E2jmoe$l
z%yh_5O<Ql^Rp>UalcJ1=&%FCN*$@h;Tn}W1b#1IFi2N|gaAwt;_CNJX!CXfl5BX;}
z;h<@E?B<g~lVvRF1OUKJcoc>w$`gJmUA7q`L$J|7OZIz@?(cEc_w+rqZ8@{+W6nPY
zn+ElR-J<y?Cg{#m<`h=*ww!Aky0YM#J~-7ENX*wU2>kdIF(8ar;)iPu5X-4p143r5
z$AgS!Rgdf1LM5}~u$RxabM#+B-l1%>8_d)eO&@Ib`JRNlcuXzwt{IxVd^{*D13nIg
zja<|((+B;-F#2|0(dd?1c63Sd1~YYgLn*N=7d50v#C}c<Ure_~CTfTUJ7{I1eflPi
z?EL!kWjpIOM5Z^J_lX_0JJ{WR2>s%I@}X0GD2iC?Jiq=q<1XCFSe)6BrhN)hgFTe{
zD&-1unMF<y^D5b?14r!HkzYScjp8jvX6_{EF(1LyA*3UDso|vCDarC-O`pr+#+H_5
z1=88oXOwfajYe}k)oB=X=l%6Bq@59J0F1QbUHP^cRl+YuHCM|~P@wC<9)F@Hb>JZV
zi=l62vt?&1Kwu5W*aN2a2;hp+Gygj-^qjd%O>9T!Hp`$?QW_igAuW9;tE6}AFWn_n
z^SO?9WlG7*tW2zLGwhX}#{fO~Ya=dCo+)Cu6YH~_2V{P_wy_z~ITUPbHl61Bl(DL+
zI5+=Hx$wCZX8g)rT&_T=25sXkxYM0WEho8zArx=2cNY#q@-nl$aoxT$%%A3F)3$ny
zI5xXxfsi2Ua0SCbn!FP7(%cYFHP`UbJh|O357o48_vxwr@p1effuyh9939l#r$<n<
ze2GZR8EHCWOmDB5%KD?ugRjwYEVO(1`7!6t>*;r<U(Zde4d7q{0}a^*as7#L^3foJ
zD9k{Pt9)RX$VG!HxgOE{C`7IV77KP6gHuNbWlS=1K(-`V&txl=qfM_>Y8NLte#YhQ
znozHnE}|*`*v>0u=Gr6O_*AM9TLPwYwZCwXw3rjwWl-XNRf3l}vjS%3vOv_C5U}ip
zhM8Fq@Jn)_#_%3SR`9cVW(|gYKCN?+s-L{xvXhhfA2A&=Rika3=6l$ur9}uuN)BtC
zpQc>Ij;&$_;7}OfOx>E-S^K6Q@X|0-1AcQ<pOqQ$Pb6AeGz*p+dZ|yOFGM}i@6P##
zvk+l@?kvMz=#OPqGqgjdy*oei88MXH8PIbrqpuW5gXfmxnVzw#11DgKJ@-bX^Ir-k
zrd~yU@AsPC-K^dC_~t7;g-?_Ga21=4&MX_2*$=E|$@r6>*4t-}24Xd)&5AeE_ew)g
zZTID(^JT@N_SQm-MI))EoK*NM-xVBEy^1oy2qMlo2q!1$sn?DaM$%)%iLHX-1fk;P
z;Z{~yOTRdZ6$6$Ldq-2xU=PIld(bhlWqg-jEyrt3i5gm3Af$+v*Q2FP>OdAFERMk|
zs6Y#h`&l!DnEWjSURijtJ=Oh2IOF5()YdkxXjYcdtEduBJ+?ya5-lC!(;kQ;(Z%g)
z&06P7$wtx9Huh2K>T)TaRJ5B)vE+Uv>x)PeKtcp8rzz^(Ie~?lWjOUvHvW%AEW}rP
zZ~ppOE+vQ_hRCP3X_iQ(`CwukFHO75g9nQ!kIxqN3#24PKX|ZAa75a5=GI$_+pzm=
zTV)J3kH((!C>Ds+oe@uRq&^ru-JfVO98>j~ubJ)kv=2!q7lo!UK<Z1ia*JAe1+~i`
z`CnZnAWklE30voNjG*ux>Ow_YMz?uzjkNe<-fVnx8&&RH3Kf8#Op@d=ycldrT#PY9
zZ5FurDV!@`kWDmmOk6*IW^FtY+OMVl4Kf8v=-sbX$u@}C`z<flzZf>`jaQGhoQ3nL
z_PH9%yN3;1Auvt*tk529O&{ae?HBcq*PkpQOzd+Mas%$o!XT4cE-EEF@m%x;G4AN8
zXM@tc-;VW3T7WeS`%?YE?tE3MHxRd@FOd8q9<N*!i4rj6qWxg3JoEBR<!QCvzMXkk
z!2pSqCP^l2itov$oo78=t^Ta23+H7+!UEooIyX&_$weEtLa=0q090_WhI&Jgj9?k-
z1%|QE5v^0$laLDC-f8#A&~&?Hv>G~ZtpdYowUSoL+tp*@5$^%M=8b{32b0USjXNyw
zTT*6>nHfLQY|Q2_+>XU9wGEPXbwE|#BmlyWEd)Rr?rJHapr*1(j6>^>8J4VI!f49I
zquz-vVnv|b%v$fxodvNa6pEiz&8KpKRCZuz9ukW+5ZzB0<j;GdPA+qk398Kw-LNvr
zNxHZ#J&GTu_hB+jPDFojd1=!w)-j))AuD{yWmSqlq7~WERY)G^)p+oSX&a|EL%eqw
z`e0a?11b%z#GJEC@AF7UAk5>!k)YUtSm<3-Yk8hmX#asDpw;{_@#y*UYkAvZg?g4>
zAF;Qm_SZmZIu7`-*`*Hov`9~8tw@(J-Dt0EO$?TY$F^CD5+8-8<hp@nDSs(@C5joE
zDVArO&I*&#I>i=QI0ZfzMX-X$Oc$DgOoj6l!HUsAymy-RPz)8u_eB?TUWQ1On?Xus
zV$)Fo%q527>lRB5ok-hJ#Es6aG(fXg3LJJBQKv0ZJbAtN>4kIrh)mPYp?doghzKiz
z!b^z*%=o%+JUZptaNCQqP~;^e`CKG3Vcaxr;}6c3!J%T-$EQvC!RhkRh8nfi%clN;
zB6hK|&HX`ra9YHh_&RO9Ca|p4Q(Fe~oyBPA)#V+ubmR2_{w@fjf4*9S=<qJgQ2dE8
z?^cR0m{=3@zA7sev#&D>F*00aNZq*#Bg066(8Bq$#{@ovEu4K(wMbx-nJJ=-gDAtB
zE6UKC9x%L53sQtxEB%RZI}~szEL$jXer3g=v@Kt9nN1n8te&2FJ*e;ev)=KnhdRI%
zeRF%lFAUDG4VY~dJ^?RAdHocN5P&KBA>Sw=Z{>Ht<62qHfGjdn*wXNt36e`=5&Nba
zX%K8#k~~@4I2CFG2b0(^dSFGvOLS*C+kaxOG9~_r7Gln|0RVJ+^9*OzVWVg^Ayn>$
zlCnJtGpLBC%d+=EPO|V8=<V<G8<>@8zY9|Iy8X_D`>V|&Dy3>z<nmbPg~Xo$8dkr!
zKBYN~7Yw^POSor7Xw`d0a@W+1?+Wto^~tJJ<lZWINvuoVIp34~rI-s*IJ1d=9}H9J
z2N5AcDA=qyCYs*mU$eJs8?Bi{#B7XcEPB5z`Vfo0g0(fUNN5{%$auGqaRF`NI?@HC
zmb2+$`eF5U=FbzSs6J|21;oj>AydGzvK0oqs}dJz8)wuYt_HNg-D|0+1-|-C_4sFL
zMjJclqy}xQbyB@HHgXaRIX&QfOSRvKC(zwC5$7gkkm!8Se3X)VQ_VpyzSqPk6pgEu
zY+Kgfw9XBTK#Xe-^8_0jlz~YPga)+KC+H63K>hU^UR|iN$f?Z@g`fQw&O6cb3T@OX
zkNvZv3vK!(e?++(Sx%LWoibNd6%0zkw7uH8@3B^<{ZiEVGV+315C6!ogAA(e`~-Qp
zabwye7||APp!cq$dJ*^p#%AVj$iMQ8$J6mg@jE0Zi7+VCAk{x)Wx^nEZH*FrVGW8Z
zHa-=z^ZD8>!2R)nYF-Gpqzz#WEJE;*S!~^3yj;CGvsu0F;stK=;!$*kO|Tt72LtoA
z0QL(w+fskA77d)zZ{>eRO9(_azEyT=7Os^yr5w)U4Yu-x*Hf&rpVc<@B2>*ZfUGBh
zZQ+p6+5CMdfpPDOW?6?I<%|F69S~ux_>*CO%?bAZdfAc{ecg@HF&5v`ucnt?FYA^|
zuar*sCsvNe=tH?^R=yBD0I4~jXD<d!rY_oS%Tk`Z<GHkw13Z-P*EX6ycKrsaG}w)(
z`E{wC^PML^lz)bO$$9niB&~s`;Hta}MH80CYmis@C&`m}=1Gq89+pJ))~w!0itys&
zf2?@tNo~N+xC~4~wdeJgTRzsrVc5R&cDv<vW8)x10rPjo-jaVGf?#ES)J20v>PdNc
z@VS&rV3GFZ_fdi!G4ivbI43VK#d@lx@1sThWs}72)p@sSo-h^6(ayZd`L3r_m1fKj
z0{`R956(TkG>c+n*&F4p;zr9ws{MRI_LdWDK&u^m0C0Ad-^k3ynv2eHs$tLR^$)hJ
z_9rnY?#Zv)Az}estp)$v5A@V(9B>bc|FQ0)IL&^5eU^9;*GMfC>ubs{an!ma`4UkV
z8h?`3xlC9O)_rkKhK82CUbsQ%RqBp<+Bhk3sleK!q`KqlhjzBrDO#XR!$xY=DSlSG
zC;2+I=VhnhTb`>bsp=%P{mJe*+CY3g_D9q1BR0x6J+%r5Bu7X+gsGivA3-4_J`B-b
z49pr*>R8`NjHUQAI*7!?93QBKdC*SFhJg?WW>e8lTk`!)+zylFB}0^#>w(Cn6D05-
ziORuoJ@5EJh=htZm7-05!azQsBx}keSqd$iRk3FRb&SOn%kR3-l~7Jqc8l~9DeW{^
z_D@&xMlswE-?_;x@(!|nxuv!z++Jj5ttpeWlqhVL>u|E{^epP)$WJz?2J|j8Cr^I<
zKP!A1uTW4+|B%*(_q)Q7Tv~=N=mU?Rq`J?@cp!JkJVwU%l*+Ty?J7@ZU}e;YzDb~v
zKlM$QxKEdXI`Ib6@l7;Cxi+NN{rOSbWM*z%C$p9&h=<6(`nX85E|45GZmVo1?*$;k
z<1?M{6EP7w8G(0Vgyo!DtQHH!VyxHRt+7!5oflbCGO}LUgIPwefR{Q{rG2d@*wcR4
zo4gPr&1$O*Kvz5q&6CpD9@kCdNv5sZF4v7U_Qo2wT2p?gn*2_dsKDX2%J5Bo#IpO1
zQN2pHJcD;40}sAs+FOhD$OwuCSXyg;@iIj0rd<c$((SEM!O18bD%Tq=N#8OK9x9&X
z7JF1s&8k-YnvE|&SBKXmqev{6Cu=f2<NL$^uo`RMa9888cLi-!i)vJ+HgoGih2ku>
zmz86MwJ1s=Tkr4{#yLIkG>KC27}aW-j7H2T?%IQl-%|_bVwkr-hV<mFUZI{vC(>aO
zPM8Fm*0$!%_#^`bdmfi9Am;hkvo0ckf)R-e%F%};GAnagx7q!AHGxxIZiQ1MU}ZcZ
zTb~QczD@5-7R4h*3tP7c+8h!qys2IfpRj#n&c~I6hL@NwUo^x?nR!59SVq<S=g)Ts
z@k7i5t(i++CzhBZk4q6F^I*F?90g+G^0sn!TFy@;-R%BTHL)foBcoEwD-jF*VfDBZ
zmLq2WffNxxJ!a!J%YIbQJ?2~<voC~yGkVNS`lc}1`2%@mc>8kU#iuZ$SmT>o=V)Gz
zDJSck|LWOl*qtKg6$-Ae@qpM4lz-v`e!Z3&6@D#IH}*@oQ-avb4bwRTMdNh8mIi#D
z(C;-|fC8ylf7JQH1Y>ayIcT@FxM(&$rF`f1!aP8#7j=|)9ALG<aL!!447TuzW9jdC
z65biNn@5{Dj8x28v|~V}bxJIS>CE$^XN>-=CkzpMo)AI3qyH~gNX8gU!M}+|sEKjx
zVPC=@ahlN}AKA*Vkt68Nj%7`7MWVggxTWWjDZg8)`)FIWr*Jt#mnpQ<hp~8znOTMf
z^F3qnOJ!bQdI!q>)0pE&379=vC+0=Qa5l1<m#9=31ghBV(U|N4MyO}ii^Yp1ej;<b
z<f=(Yu4rtax^hu!f$-2&;US^luezUB?3W5Zq<=atJgCNz+>J1iH!|}Bq*;p(#_azR
z=c4I-x%jaP{U?~MR|-o!%zg3(z`Ot~V1@?oY&D&j-%Q;Jr8`B1#OzcdF;C~$oB`Z_
zt7leYXV?md?UyA|j!fjbJY&KaI0^}-YRa9vwR<}hC*Fp`=^%EWJQ8Jpr16j5P3?3C
zu`%sxg8L+<r(>(&%W?9Bi%-fw*YRdQxfN`Z_;E3RIV*zpj?@9K?zGgKPU6K`skgCj
z&v|i{g{sGTuQWq_rZ%nb$HGvwbPr8fWhbW{rO@h?aLg{OzDS2x6OCM@1*W5cTp85H
z&h6L6#`?6e(X19|o<usq$yd(edw_Jf_uK$g0xTeVWNr}rXwc7J9&XxBS0g<5PGIw<
zQ#;0$LkT*IP68S2WZ25wG|94W6yHm10fs`oYbB#9)ooZ>E&l$_@ABou7NicX)H>UF
z?-Icc24O$Ivmh=O!=6XqGa0T|3z!UdHp87aSsUAmiiA+0vUG-QGUV9|xs}-Jc}vJM
z$YaRDf(RFJW+FhWYo|pu=474j%$tCyKftCh)dg;q@g$a+IEN*+aC>4N6Q;)OhN6{=
zE?`-S!abK#c60%D>LBPQa&^NoGiJK%Ej8QWnab{|+d?%bx&X)V8SN~5KVvw?O<AgY
z`W8@ZfBE>qd~wXu^s`Ff+Z<rK<=?KyaKP|p7<Mifp17I@3>C40hzfwFT@crnXW!B8
z8foOF1>B*|q)mI;B`o-E<dIU{t$aIEefBgK?{Y-D5tV?#`3z;@7CI+*DX5&nhW(No
zY7`bY+@ZU%E2-5>z$r!KM5U+%=g*suKxIt1yPc8f+COKfJCSX(aQ`Op!LJNJbukdE
zG)h@#^#ntEWXK2|HneGnOLg}#9%6J?4z|>LlfI^1Mas_$i=rjE1=I?XbCwivS|>;k
zj0Ac#r1-sIt8g<Mx#ICv!<W!0_gF(EOjPC&arAm!+uT34Z5dp0rD^Xmy9*dJVr<~e
z{lwsn(e6&s9jdy|-mBJX<Cm*Fq1{^g5Xt11>b_2bU~1k?kn=9cnXGEY%}75-2KqhY
zALDw0^(REhDTZ=Ud7?Bzc-4-?<4T$C{5VVwRgugkQCYsGeY94r)w`sy{)8kE_ZSqr
zS_AK%rd_4FOK*19{|h1#+N-d-sUmi_7-q}Ec|ywAD%2%04|ZLu`|FpaR*Bt-q!~7d
zA-KQCzvI`U+lh2`u8}cVpw?MHm@`5cMEPo&-?XpjFV#(^HG2zjq2-8E<xnrxouiUf
z>tCmJq>g_r?v-;pWgNLJ>`D4lJyrH>B7?!IN)GW9wMI&EN7%C`R<c-Bi8pcG(A}zu
zsGoRyN1td{ofw{X!ug!k;p${0_1V*YQtk1qo?>MF;Vj;okZ{gClQ9-g6a5H{$XGn$
zzy2LCq_&|d<?bBEiau|!lU^-HFBbPo^qso}jt##{z3Ji+Ybg8aNjXoWAIu(k(sLvU
zwSU$~g-VH2h$lHQA{TpHgy;hMrIQxb+q)0;35g7cJ=y~}?B)*SniWc5wcZX8^9}1+
z>>QZ>D{b?uW7{H|RJ?iTuVhmz&wvc|45UR2+p=u=0?|)o?dF}V<VQN5<}GM1s((^~
z;tQj}o{m>brGq7Vx47VgoI;U)ZV>t*sM9hz;@mQ6vurWTF694(<`hb;VIUsm*_Gs!
zO5RFG-;`t-vLxT^cK#5b=sAK`@)wj+ooi_o5l5_{WMo-af3N0B&zTV&JFt`4(_qfO
z(>q=xy3CWDfNZc$U;=0G$-Z9-rK4V2WFy`Fy)M?7D(uZe?3l57YQQUnDQHr5H)E2r
zr%Bn4_oUzl8$7$*;M)vXI#>m7kxB>nK8PeX8Y8Vp52-tS9__yW<V~Ul(`$HvH6T?h
z3Y<@#BEW08UMAJ~FqvQ4^4SrJ4leF<OI#%-Bv<jP%vzOc8&LAv&nYDxi=i8KkI`@m
zsYJ9G*YhNH+*pd432w4ZR)Ei0x$r8+Ej=!6DivF-Osg1dW#TS%$^Q<Fm(HT#W$`2A
zDd<f_1k^|6v`(F5ux5*$bKIPr<fQKWE0c{WZ6P+4|HU{2xhwcmB8Sk;jyGkgD*}gQ
zKP@<(xy|pAB@-OFNp&kn4YzT|(Dha}Wd~bMuhO45g}M<fI#Afg3rWGGS*nxhKYNV;
zEH#8o`Y*h|00ZpE#XrL9@x-q&$`B-Qg{IDJIP0V&&VIWtLN<=&7!SMlZYC}c#vf#4
z*2$ZQqVfw#yypw#W+Tq>iF)Z-G?^N+V_TLM%+R*w^HNhht7oI^977&|Px%NI&-BND
zE?K3z$4Q~Z=E8VVN_8#jQ|p`${FtMJ)pcwYpa`pWk27rwlZWu?F<8*<LQSdLZk<R}
zl&Dn|a?LYH3COk!I>jn(kCzby(L*+zC4%*E6>O1e>s2WEU!}C&Vkk0uk$gyaC~JC)
z%q!9U*^7U~S|n!}nKPSsgS{&=O{uQP8dbh3js2dq+=x$7uAaVgBR(Z{`DfT?PULml
zh(G*WwFeKZ1|mIHs%xM-*(2YkNU82(z6yWACZIpDk=5#${7UvOPY{8xQhr5BYNZb^
zb|2rRx)Bss$Z@iE&l99{c^d>PzK@mp5k86FB|w1qil#vbT0rr&)2RZL8IbWXzjfs@
z;o$;@)Qr{)xdm{(&`{w<dUK+PHE-C+-bnp+vk#q<ErMM)=M_q5WbQm!^wswr-X$_v
z4ECA2^yxzHhVnOHgDxkBNnTY>o<VYDm`3L0_kJixxk`1vx$)RhYMrkgoei~5{w>9r
zl$89QTe33T&drpR#mjjFaOy4WQ@dMMG#3UyG7vclASBsSSR;G#SUJX0>;#D{b-T}#
zxWrgI((q=D>S^o&@kZU>gI*wEotY6A$|Ssf-G!4<`~A}$;-m>VzfG(5aN=Xdh4vnU
zbHo&J#;@h=i@Ze~pS<28iN3W~=Hvu#QK!}>)>G*#u0+x$__CS*vxw0C2>!zciKP<k
zRbv*D8`98s77LI#raDwgB0miADGcYVVHWAim>q9!ps5O-fyg+w)tBn_Qu@3jWTb{_
zy1)&N7DM2*slE0(QDs5RhlPN@27R@=L6mV=h7unkys~4fG$#@uz9hQ^XT!Xe#e_32
z*yU+QP3_T|dq`C=fKk+jXn_CGW<;yO`aL$<$NyRW-(YN(6><qLozaXP&0-o4N>T)U
zOHcLsQJJG#&0H4zD-j!juRKa<c(hB<86hU=M<eV)Um;RB8Z=8;0u8lCvS_%=MzWt*
zim?aXE4@8g8y?Jg6O4B5hGM<EC$Fu{u?~!dDqV}9%Zw-Dh2hI$1QYa3m?Mteh3e9F
zdtE=n!sVawMM1HWy#}5th_te4yF^>C6_kWr*rO0|?gnXV_g@ub7-@GGdR)8&dj+t~
ze#!nez%7351SRA}rF!Z|#eMUHv$zpCi`(9=dY@_FV-bajaDslVF&xku8PiN!N0c3=
zi~E!W?S|Qx>O40Hy-A!Y<wT}EE^{%N_E{p1{`m8}x#DP9U#W=ugtKufY*0TVsCE8^
z#VYGA_Ieo-N<*`;81oo=VAZFr%q5>QN<@CX?nCp(V4$QPPIOJmfA=J?xAZj0eNuMC
zt7V3qUn?0z#^>)+FY6wn+59s1{hRXs1-HQD{317Tw<KQaCN9mJZepJ#{^>u2H=Yql
zT;=k*Qr(xB73^@%Lp%rqoDy*qyR<U3X)1V{wnLkykr@g3#wIu<-R(0&+Y{r9e~Dzm
zB`0$Cd$t5~j~FlYiAR>{)|Bf0L0WZ?8aPxf-+#JJzQ<HPUy;w$YEIdFsZ`f^Js*o(
z8>qVaLglLH-Y>2-L&zYsz^`-umFPF0Uj}59c954fQir`OUI9V_l18WO;I*ogbuQ&o
z!&t6TT8&cO52O>=wi?05)1{SX4kLpoQx#N5mW!3@rckv#e#UbM*OL_Y720v^*_tG7
zKRG|MMWhr*oo$kFj1@1Yy{4C8<)0gc7Vs*FjrsIBk$Vs$RGq@3<hb@bbYAEY^sPdV
za_I|P?&zM6p-togkSZqfmYA+%lG4J<l-Vn_)Mt6YzPHqVk&yZEpVB2hth0ecb?jzP
zUxk?T5k5`tJFb~vgFUy;b;{kw(a+c6T9+)x#Qzy_%wd?FWq8@S(SD-!^7!clm{7sS
z=)hp)GsGT`#Qk_TDcGkCT9tno*Jtr+WHMPqf4;7FzXsedF<RRXC`)iA6O@VC84<G$
z7_94xBVi>8+Ss(JqMUIVkCe=%{bg97!3VLs1|&7(dSmQpmf2RZZ!@tCO}i{P^+=bf
z3D4zkx=m!90c1u>3p{222c;nQAH=w*!i~V?t{KmIA>fn{0$zzvAHJWUYzUE4-cu#~
z4CZ3LNDvu-Qa*fN`}L9cEa#@BxX>cr<j0AqH)L9Jj?#7W>{}_cH1S2<eyZ4{KP~~t
z#YSA*Ergk@+9tslGiy`(2@^ULNS-HAr7bR8^~c3w7_swUjF6k7=Pfbgjt(aOQECQa
znF};tA{r3^heW_AUU#%@cMvhVKmY051sqRdAm>UC@jxaXl0%B=p8<ACxxrT7B`8^N
zEKVY$#ZnZhD%=5OH}N&$3Che2;Mf8;hCm-IxGj)9j<RC8lJMcgT+9CQ!0II3Ppg$^
z23pwpCkb4*`)dG1YU`P~L~Jv7>gVA?{mI!f_Nxh}s)ael2Kcf@;_{9SS)5rxPAg7P
zvpEJV%Eo_?2B8NN8K|f5hI|M-3+=oiiw$Ap=@DZB=W$OQrPe7zrM5P~f~!hR+Zp=g
zqZVxv?{AeAAPDGL1NAUG9GijHP!IL35E|%}i$Go|`XEe%KH2}F)~sN{(c(ZbeT2Qv
znAf-~nJSId9>~hTAL#aXTh5nJ0M4Rl@l$F93JvJ!)<Dere(`LTCMH`V(e734Qq!$8
zinYM(8cFrPm+Iv<fR>1YrYk5@FXj{fd3rlD<XE|^m4rBdfjwal5s8)>B4j4O7nUZX
z<%mu=kbeffOh&wj5vNL3SVD3NWGbxo<cod{&1%AO!!oDd_8X&iAmd$1qNPQ%?&9xp
zBWu6I2}9kV>k^!$6IvsBeTY*Rg*>oK{qYE+NtKAHJfAEVpA5T(F}F7J=UxSImaW&!
z__VSS$X_TCZA{q!!75r>RAY+H<=%waPY9;x+SkhZ^Dmxj7qwr#tm8!j58Kz5GkN`{
zN)vL@{!lp;ct`5S>u%JIWw$>}I#%pD<b?GbcsJCR5IeA8&kCaw8+76>CpPW|jtT@4
z@p8Ws{%HE`wK5zsf{9o;qux`L*~OS=AaXKsEdlFfOo4$pCu22UFI{S5*UI3uv1%?z
z;EH%0OBs#uw)Q+lumqj_5T+R;w6>Se<Y_5&!rPx5L&lFJ!&VtAd}i8PEcJ@<n2`f$
zt#G$|JOJ<@K#SBeR3$IYMHOL3NE#}BTwpA!k53UZg%}bI{d2@$!Hs5|c17%EZhJyT
zRipZ*v4AK4G%hPCHGxvBvs&a9-kEr0B73=pvwnVVI`9`Jxv4Dz6PL>I0`cn}*jWgv
zeX)F+OWV$p%F~3njpVIN5)_dT3RerFu*n^02rBT0k)qLhdpz=f;XQGyvF*}*^jzox
zn}oiXO|-7emWyJyVUc0n5jk|Cm?k05!ZmLN&dMH0*!DQ>o-6s}MiVP@W^YZkXXfJZ
zUyFJ7>LpGgKAV3Xa#FakQoisHyh-w1Cy^}XA;r7LN^0sh(53V9!Wy|dp!0n?NBT$|
z8f#_dzGrEXKFgjX5Pmk_hL5knfiJi63%pp4SvmHi`{43f(vXdX@ogH#dmfQRQSghU
zdHYb|JF395`Dr5=$9;SZ>I6o0uH}s&vS!P%x`o8ehQ##{g84jAhkEL8m3FrrOC`?i
ze%;_D8hTz^BSt12pHxswUrFmzS)kbg3nGhERYKJa;!#Fh8H1&s&QW#PNQ7c4us^M<
z;c)!8C%=%_BAe{l{PWlb;T^}H8aYPT0?r#KLV#E1%zL0xw3*oDd?ga*@MB^-py0v+
z<RF2rw(*)~ZR2Ct$Y3pJ&K{W)f!w%NBqEVG;5B2&NxlBQ{gnv#l(;=Wz~03iIZ)nS
z)BCoX1Ub#%Yn7Q1T}1wW*0Oiye?ry5RZw0vDT%LifjE^nF2`^eMCgImImt~5IL(mg
z>eLXR?grF_OKC#Y)+lh|BEAbJkQS34Q61*;{{q#)J^*ZFTm4RHNwWirvJ#3<o7+jU
zM6U&+JCQ64tgaOOnG{9taOM%_K2$W_$hrSRDmvr0)l#Zf3Txe@Un+pPNl8_gD6y-L
z_JsVTbuJ)7B1OTK9v4@lnQJ9Hm9uIM5$%z)Vm3bF?m)~o{CY>v0OzOloo~o-PCC86
zS(XHeQDR)c9vS^fswY5;@wrDN@6z*yzrqxds1P!Mzok9WHzVWYDj4wvH2bOklAF&b
zQzoWF)!PJl^5idIR~LRM{O0U-zPUeZSVjjcr~8~L(*{9USua{u)-R_P6G66&;Q*yP
zW`lfVP~a!`UPalTS(1?(!}MF0?~e)x*z=F^kEY&qX-EVdmd%rT)vtFKtJ%z>wEMRx
zxJEkn;V~*}5DQ!j9x|&pdCKvLg{MZV4R=lRbSJTg7;MDabB1wR+qkGUwPj#uk<+W8
zcb7k+rw+Uy;f$4>TvMmkl2J#GJnT<?S#~wkzSrHiM1AqGh@DUlDBi23L{gUn=d6xf
ziqNlMB2p-@F<aR23Mc4!)w}>#YRDcD>oh%a-`EY2_tfM%KLH*W?@jd|wDpM8=Uxn|
zOXpB_)i>k;o|3t&h5=YLKA=uZ!gAC;5Q4yQCs~+jEQ}KM)WV!E3&XKvCm=G4EY7`W
zxyZdy&_-lCg%x|tYoyK`5%8*{8^4zRFI5WB+{Sj?ZE~1Yr2U-OA?@GjoBRwQf2l%1
zPL3l3y{)JI>euaVz2hyBT%x1)Yn?wQpY4RNq<r0)xDX~wCGQc$Od%0?av%?Ff|_TO
zp*G|5Ag3!wU*q!4&f5XClA+%%qc2lLklDx}fXdZ1tsEX^>-@hHWLUEWry<Cw6}Iee
zK1`>r&YaVr!%C1bhXol6LB={(kg1?gAo0avNe0SkVqa6TjG)%>!VJTnS<{R#qxt!3
zY4!Y_qy6{7j5)04(Rmo{X;_}A>)QZOL+g7P@^SJ^-Aj^Ts|;ceI3Xn)KL1@s=TNJ-
z6oOqZ{#ZEZzw#=>GVIa#+E|v`{e`cR1|<}wz;F`V3<MS^qQcb9dB@TkCZsomwC+|A
z0TfLbE5$J73DeRE`~NukK`lK7s;7@r2%V{shrNlB@zfp7p2RujP&|cv&-|l{&S$Fq
za#b@Wi&dD}9P4>Q22-ndWL+AXM>rK4+If}G&{S`=Jyn=jpYY)1BFZLa2Tbp?B(;jz
zpG=4&tWy*^UCzUZ;M9UrI3Pq%Xx_QyO~q(rUtMyBJCOUSaCBcy^A~O=K|o6csVL=0
z+60zQZHPK3iZz%L`wTDF3(WHuu2nUs9w(j8t3gUT_5Ty;{L~Lh=clr||C4lXI9L7O
zlg?X}bUsE&=VO#~KIXqi=)WbMSN%+|`9q}hQIg?G=j!k{*Lr}>{|O$#bxu>TPRMDZ
zR+eoH)<3rHa_m&YW~bxvPsK>Mj0cLtb`2{|gZ%)xt%@}v)+BDXh6VZ6S-TeSyBE5w
zbS$K`Gl{ITPE>9qTz7Dq{ZerhQkI6HUk>THHHsf)C)qFMQ_y@-*C;Sn_=nxfA>o#=
zx3CU+#+{na8WlYbif;rWj*rN%Ies5EAq1^aJwnfENKkK6y`WyA1{wXm;#J7;LyR@7
zj_QuaeC!_8Jsq1;+@2SX+w5W6+J^pBv5asjWhr?EGq3IFmc6pGz?8L(^P1!Kz4K(V
z2<*g~bM(H+@_hp?*zk@IZ(AjKoyVSltUx02XR_Z#mO2Ybn&T024tj<(=`H%?({ffl
zO+?Ss2KU73LrfjWsuC>V)wPJxJKw<Kzh(_N(9#>H1vs<+aqMRG)C#097OB<JQ%6ot
z-c%5C6+S-2y=s$lk79?uNgPP|D}cG48mzUuUH%jq^;Y718Qxt~WQ!(FiFyA>$1qXR
zvvOe0YJdCU$onv+1&YGVXy)_3;OlCPaUqzpULu~^ZW`5Rj_#7<6vCZ4&!gI4HymAb
z2W?{y*-8_;#MQ)H3&X#Wr^rn|p!vJV%~QlK$iTPB@(i<a$j!e>f(mv%S8WI_{e4n6
z;Ulo#BIdEHYhAH&=Ns;*r^<R1#PKW(AtEDZgm;{1JOBd!OQ5h@9AiHC{Ez<zfm$LN
zA0SZU&_DkU0#%l3EAfpd=-0y=?SJNvN}T`cVi!-2C?uFs=8vd*iKhh@<^^2a7rYR9
zpm18$Qbf??eAD|PC0u5>L}BOmXyot0&X13GdtFO~<FHdK*=1%Zd=cVI7~qTsiM1S4
zn5RnrF9Xa22Qg21fAlx-%P$!pz^`5Z4;bJF?DO=C=Zz2$okQyBi-at4X|m|pP~Y2X
zQnv-G+G;Isx)j0o(@`%6$m4`D>`Gi@pc#rwXkL)O;|UfHZ3HD13janhF;Y1&iz5i2
zI5?ntbLbD=QY7?5yAZ{DdS&4=i^4Fgu-MI7BMz=`F1$!w@xi;i2seO+AF9?;hp6oO
zne@S|H!+rLhI-|VyItiH9bcciDXKUDlMePgPE~mRNoeCCIjREf?5ve;F?XpbEWL{_
zPd;{wi@9<%HtJl$Aw}div4|7RJ*0P(JYo8LT;fHzSL`q7uj))Zw~smteExXH9ivNE
zte6vXF7w5_kkiYH+>&zzdneI=FO<1$Py9u0fIMwICgiM23VGXpXN4~7PQKVa<D_<O
zC4+rSkpyEE0{<^EN#eiRDkZu6>BeaKPsy(q7sl)!lf%O1!M(s#MJyFh7yiukH-uns
zsX`Ir|93GE{2q;p%gg}HmI`Pl^tCz*di^TpSp}>KeZ{9#@M!UJ!X9w!h4bIT&47d<
z$Nc`-r$`qXy+Es-$=d_@bH6MjR63xFbkQO^N6lM>tT6dF@5-^#Rz&WzJVD+kvM$G2
zc|?8@X_)!#%7mU=#Ho0QLu?3{{VSv6Ii0&Y5JmwIq0JkwoDjEXbFQ3=yTrKpA_{&o
zDEEF$BxqgaYtuWc-oCB2$Q|BSH5jR8zqdH5{2IWYh)(ji<Ut9WLRzV~4-pET*+JZ+
zRc$oT!o57_h(Wrg8S{8*b=Z>#9XmsTSia!~;kd0~sC_`>C?JgJ)f^A)XzO>S$!2BJ
zgr|y)6KFFlJ;<%%*GC=Sddpe+5UZ{(fQnA>{S#L$Q_6KV%4tABRPeTo^7GA1coKe@
zUMy#`j7+n<_tDl;HXpM*;bb63(Jv8?<Mx7xQ#b=BOH=ado_8`bnGLezhy9QJ?$>;Z
zx$a5Tbta>{hGoCxusTY$CFJ9ERMnj6sEHZnfW+%bL#iWZ`YcjC3ci^JiZhW7A3O#)
zxPTmI9`a@Eq4Lgrl_Y4xXbIq=y7-A%jds7ca4QHte7<Qo_^op1yPRFIpDP=3eyNNp
z+|t}_py)@I1#o__MTy&8$w`1e9znF9Q(eRD1}@#%e<a%YoYr|C{SigDnq%WvjX{*E
zZS2uD?$SdqEe|<fjHSrruLg}#xH9FAyK6C0yS{KAvxC}5G%r!g`JWR}SBTS=G=UCL
zk+!*!r$l1sUjY)PmqWf~vP26gh!0b}%Rz2V-t8ZV>)I{Zx3#5NPh9?F#(Po+`q2U6
z+F!O8$IAX^-v_PG4z2Sgfcs9fcI%vz0&(ruy>V^N?zooRLkp|-ipea&Wf$7&=cA49
z##`(KCk6EGH!$OpuEitTQ@gy;#=~UHIcc1HK3{cAR#hcyyvnLRCab!Vb*jq3PBq-1
zuaZ@-vPK+}HKLMry2`3KCab2BH9=)@ama9kBP&^Fxzh~(J<|;St!bXC+W*jLPE=VR
zI?a!%tPh=LgUb5QX?{XwedshVP+4l4*uMp_Wif`QdSPJ#X>wC#j_vett=8$fMs^5x
zymu^iRPce*9Rx}5)H*q{=y^w5J?APxhXbHPKhNJ)P-2fV7b=w48ErfS&9x{<-%op0
zjzWqZAcdPX4)l9%E|vF7ncs*#vWz%8zz(;J!j7i_TQ^K7iFzSLcYq;o_Nj%>lZL~W
zdqJk+bQ@pIg&-13XfDPSztd>!&R@?Dy~HDpcZ^|MvR8?%tycTfaL`b8abI@A7q@kF
zb1i`}1Osw9%H(2?-JNo(8wxKm;I5H)m_ATWoXv@^($WlO80uN^W&~8X`6?bbK_2RO
z(=QaTa$cLTHh6Z>aK6<AFy(mO=!kO$fisEG#q**~`*=$d^fZl=d)Wkx#|Rqs%t@(f
zlL?dNq7BS#rYsx#`pI^A81~~5xS@3}L{{f8q>$q;^;~ABZ&ZXa(=HG0ms3U4VZI`n
z+qwJbNI9lW1%Wia$nnh$UWh<0t%8gx9mT3WHEO?%d=jw>hI84|&6(N@r)S20hNHz#
z<Fkjhh)@v?y}#m>)Z@|}<klU`y4CngQfde#jBdBa?3WF0K9Qj~9a(oMLgy{#yBp*y
z6MLATOtA=KidZCu#`2**U_c1J;t3Uw;xZ92+_}!qm|ZMhcr5!2(}{8-6|v)xE2Qn1
z+kBB9T*l@)nnGK(d%j9zsmImClebvT7t{*jB4rq}m0&u<THMUB@a*blB^!?5;-BIt
zWA-yv=Bw@0H8TdQv%};E1g54|jpbIglVjeUF=tdP^qZJAb$`q*a9afNup)?+0b$u{
z>Mpzmb|xcP)50POumm8P2Mp51EcLqst^wq9a+#aB3*6(70z;{H&wd&x&wv?gY2sA@
z?gu8Kb$&xK+{tL`WZr5*SILBurrpb#ZS0dhY<NSETuw_Uc=fdNd4xDEueN3iTTWtc
zPU3LcP%N~S8TO}c&w3KON$4sk6p_UKF4(w$@u(>&4Eb=td{VKz=o=VipBlit6CGge
z>}cEynepDih}Q=bjd*LU%*_FR;uEGbS78;$OefK_pw&yDqzJ>8^34%aNtPpix|C!W
za+At~vOBPQ<bRWPi)!-ioKd{s1pKjg<_~pBQN#zer3|}Xg>^i@C@ZL2#&^4n@0`zm
zBmdF0Y(LI?DuEYl55241^DV4fg_rpAA>glf&y%to$H4yusQ2Fif5TB*+j879;e+AR
z{mI!3PN;?DEDh?M?t$1~w<jUyJkbk4<@849U->r06QtthL{+$`a496L>oM$6V6QaL
zF1LEfPiRG*l@o9dmSWW_!xYszC6+~R<QHwuAWW*UFT#<j)XAjTSqp<+BR8ZRI$gW_
zTXZIR-N9WJ{`xLvREjoo(@LM56f?Tt2x<@XMEpI;1R;-4QPxA4l9zMO>Lhf`-Vtj=
zbLrt&=HVc>bK0*6?65+hF-E;lnch7}F!j+U?y_x{$}L>~gIC12PaGus0-P6(>>S{4
z?M@o;#X^0_m#q+<sdu!_8<<?g-rGn(Zg=WHb>a+>hahua6vLurN1nzAtbSOelq^_{
zyD^Zyr`_{OD&eDe8oClR8@Z~d(6s9)%EZ@ms)utbS!rVnZE*2pCNj3F@--k|)s?TI
za$)X{mcl+9q&-A;KA+sI&QLH{yAQh>qupvY{sy9`s4Clcj=D)e?f$EQr@>7|WfU+L
z@8F7>t}d33P?Iu3m{Zhg6zy*Lm65`E)Szi2qYn_!Cr#>)1%O=s=g8qo(S3w34k%#P
zIm4Uefc+uMyPx<z7rXMOWBeqzY8qr2FqZojd`J(_ys?<juc0#P5DJVp_X@*#R1oQ4
z%PKhmN4WV&_6Ctm0h@;w$->u!{8{$nvjn;ls_zm+Vw+NH+8GT~RNT(8C&Q>awhEg)
zPHQY9dpoyGDz#J{Y;o<+W&JUzjx~y0k4vgsoIMp!X-jQpt!u|7v2`>8NHF;^&K2^7
z6IDd~nwre*XusUq^Tp=DNR7{%T+m#7SxxbC+Q#kN#;YIPse89`J>B9S_D8lgGhTwE
z)a^8u@_OU2dt^s!aks=J_vAMLK>IK@cf$0JU|+9|SI--h>fv?Xn8FAkz#U(>0CHXw
z3_4H&s6ynS$jMVAHhQ~=NNKSn7sL{*+uL;_7!fGg2E~S>*eLUlc;CVF@;1NOuwXeZ
zWNzz7ZQ<_nrxQ`Rd?~a$aSqd5FfU-g8;^#zv{g0j)4lu9koO|eEm)*#Sea|RW@t;|
zDJeKkw~rtNZE5>A^#0;^!PqL=-y!ncnFP5f>H*rk0BjhK29un+)7wMeb6QbsTSRKB
zLBsLxl)K!1u^K$mZejY`ttUshuRgAAeU4kP-|vlUt6MoK=-%TiQK7>u{RDZdazKxt
zmB9!?^nkdo#r$+jkULgJCt8dtivr8|#g(X>JKb$oFAU4w73x<@>Omx|1!7|v6S2=J
zj*=UlyZ%$?-iam&V#d#KFZD9)gT;>=9S-u6p4!U68D+EiXED(5OCE?3+Y{VT@pk^Y
z)j|v_cAFY2bV+yOLQ}4j?qyfWiKYy^g%bjyk!`<{Bjsjj!pP)*m|lVauk)*@mt)6X
zXcnn>7#JVCe<1ay8!ub-;>&f7a{0i;G4G&hKT`}a-k9@cNI%4z>j5GCF=b?WLk9bc
zI|Y@t@@qI@D->*du{Cr_f3mMEdM3i?vZIyFOROf<&eU2$#b7fRTh282i!lMAC;91^
zv%%#pg9*;kb5muzd=`GpAH`A%LUT=Mc<6mCeJbyT!(_2^c^lSD)HBeMYfWJnjd(dF
zx>b(!bQdQ`8C5`-y-=>`K$lQ0UWW1q_mwG^oZ?bvv7-6GFvN>hc+04cablR$7z6q1
zZdasBekY9Ye&mrVM1oZ(bM3)2dXO__#T%l|%n9s?JI3&5YAx6ML>jYkE}h~?W9mS#
z`;8I)9mxw({)Zs*1oLtmm8vK|ZIoZPvWg!Vs=eIuaz|Ix6K!MydyAU3F{?KcHzOSo
z{G9&+#Q;I_G=zTvc5;+Rpq3phj%aSL?e`v>R-u$H-_1}nBVJGOfKs|wEfS+9R~>NF
zA~Uy7XyiTZK%zvz@MwJXpH`~O@gd9YGs|?b_}T~X=Q#Q(5kAf}L1%`@3*t0O$pVUg
z5;PplvyOZgudMK;ZDu18LGr_P#nDFQwgLSK#Yw)fSFJ~4;^0&kVItXF<cLYv1{~Y+
zdzd{x6NpWWbtu-zzEeXED(&mo?GC=W@jk=x;I6%yz!Ei3lL3y?oz>jWbxqJn{aQ31
z4|jH@LLP*?RCj}pOYvIp8q1ovHXDq_m9p<Yu)&?%gfNIBBaoadKg7dTEWUB3{TsF^
zzfL7cCY1ZW+XY$oBi^x5+->_U3nCH=)#j4-xwtx)_4<hngwwKECvUz(^?tA0_Jjy`
zS%kQMg#$=wk<S?<!k|`IuPSg&e{29Voe^`mGkmJ3fl)#yINLSTu>$^Bh~ToQC(#n~
z_QafVQTvrxW|3EpvdkpX2mj*`_w5s-gdG=O^yTaYez#^wE@rW>=2AwD5(6>&ZMjb)
z^g{Btsg8Df^$t#D8=oSwaJwnommg8$di&bvxK$#C1nU*cdN$EGEMJWu3CrUG`t4?@
zd)etxdsnMni~TEGO1`Swhl?liC+h7fR!8`SvCuAU&Clp0%EikV$qw#}dMSFSy6rZk
zHZJzqfld0oxPg&M>{F4r_QHr6FLN)Ew=ZTtZywyoZ?qvrZW)R-_Q7t1QCvng&$<Xt
z;cvWSr+Q%z_4`{f?A$f+9bWgT*9GqkkcITP?LB^rBl$usv@`KhqJFxM?t%5DT=kZP
zD|X9%#>ddp_NL(t6`n<w;R0lpXA2RBI>+qsXl$0pFCwvW*%p3Iv7@b>h_4-Q?iMYf
zY!Bd;s628Dio2LMg;&XD)4}1DL6J*vxGK5i2X6Ej5$STH=L(`amF%MeiSqaU#nlg2
z*NO1@(|T#&eozdoV*lncJ~0Xq65lo&8Le5_z~z37Fg=7P5Ypc48o|%Q6i#H``*O?Z
zC)A~ypH%xJ6|VP6JsR;8PcJ8Nfwn3s7IF4aDjYyQ|CNYrxW4_;D4_-|L?&=~)?`M)
z-CJSxcwiQf#B#)Ibp=!dUl3KCHo3HzbmboxlGK+4Kc_WlXT)~=j&>{EIIRubW}$9j
zLKabn$m4eUcJiHh5&HpA;ko1-zl@hRB$hsPP2;kg(V|`PxpGXUe7xeyKf92djI*&U
zPUga+$I7uiWl%Q(k%^nY7$aR9Dcvv8do5uVF}Dzn(!B;U^?fvRBBBcClH^_}{$3<g
z%XJR>37Fd@w#CTT4S85!pDzg6`GCmS@^<e7>v?N+zJ02|uGRi_T|0;%$_<#Ad<vC_
z^-~~g8n!>RI>cVI+V?&sjbMXzk0fAey*KJsCYU7D13Nf+9tdt@+4rjo5hpD`Ct7%X
zi+B~9?fX@=gXye-KU>XyRBY}^GvYib$Rv?$5qsaxVk9%etM4ojgf=<|<{IRIxpEvR
zIhQjeRe(^L^&Jis>|-I31V<O%=LN^G>O(<Uim;q))4S4r^usRZ+A4YD>SO0|K@;wN
zE$G;~SVCV5m*HVT=O=a4Z}e=p_eL7`%54hTBX4_m#T&2YwqWm-wYZb?#y+kKo;HSG
z2z)voZEPN6aS}(Ae8wuxLwzGt9+dWz+&SlZARH48mf0=CK>1ypX0TJzGO>vLxXfKk
zd(;q1x%4DH<zJzW6sD?nEaadZ#Oh>TBa<m}by2UOwTR}XF5}gm*o2sKYcS?KDx6Ze
z1E1kV2}5Z~!XBaah&%a06U%C3rXe1;O62HcDoO}><Pbt&EOSGEsk$5|M$Gm_OJ%`+
zC^JCH_>62i)R-2fJUKs<nQ)hr-pG%)Ji^^qhx0R+!D%b&G>hmIE+AGg=f>asfm^Gf
zW*DsgTE@C~YFcd-J9<o{v7ft1xR`Q`TCVbV)!G-n0oDV=AblD30|KUq?II2{hhgTw
zw5u$O)v!;H#kjir4C0+sx5){}In0Msc-?`fU2-z&H%tji<%(qGp41-THafL5E?S~y
zN?)v`^o#)5UEsu$`T(!XBjEtMY2$F23GK66g#fld0Ku!6P`=hN+}#Ub^w9v0PJ2&k
zC)m#U>C`8Hr#f?5=;qDLOy}O(M-IW|iBXL)rLJ2Pq{?6dS!5`LNOQY<T86_~Tq-j<
z2GmG-QgbymNtHqb=J})$hm0cUKPoM#4hHhqQl_#3daAj$iUBuQ)<6ihEVGjl1SP;q
zE%vd?q5xY47Am@I(8AlQb+xfYJ;l@yGseUr4ENyP*35(!vtx^#VC06eZLmj#pGy4p
zJ5!-wNAmKpjtud*tM-WejT{-6>D+wB;hFZ$cgS!5!BGz<cSYsgNO{#%cZts&%MBwU
zfpoq&gvB9dcfKgUfd@y6%sT>u^3Ag{&FET(alQAf*e!P*#49JZl*LmgyqypNJu?k&
zC{}xi1&@?}cv?1}oa!u_k-srUge<Y^LAd#CD&ixFhWq+-W*E1>F5AO!PLpe#;winR
zRQNQ-p_dInN&dlpJiOxUXbE$N63($h-Kd~^;PA@EwWlOrPvK;tm6#k+w>$PTrMn>a
z44`=N(J5p9A$0rdak0g(M!9GX!6H7*UKQs?wjPx39p!D1n8CpY?ypX2vBiC=(9|4C
zvto{Ot`0<Dg0aOz)SSaFBV?}RmjNCKGr;8cDO(j=yf04iMHG+PTZ;FI23{Us84E-g
zKi6V;G;=Y(KE@dIT%?uq1O{@}Z!wJ0w&Xr7wWSCO$QT-Y)a;$|pde~np!<+7wBxQ(
z5iwaxkWDmnXxZs}Ew9rvW=Y@7GM4mTlL7zRUA$a!&X--MZQjqFXWLUdy}A-s)avXj
zevBVnsF-DbO<Y|i6LUq@-ous4T4#Z_pd-?~Za*Dud>*uoE#AdkqjpI@xceY6v#(($
zl1;#J$?hr3qp{F)$q~Bug<?F$bukilPADOs)jpiBH@7P5%|$ijqo<D+wv`x%1?M6x
zI5jQR6E7-qzcZ(!Togva=L^5?Ye(ewyCkMqbr_MKIYXaQ-RhyOcbzZxlaFEckBZT=
z+r1gOytc<LMe%fZ^P@r%<$hujwOIjf@|-f|u$&;|UDy{A8@wv5con~cGSOVz4Oze(
z1%BN)lCwT;DK~V#TyVP6shB>8fyTtoH*gtuLvBZxi4?vAYAGV>5^QZvfF+EHuNzc%
zSvz~c6|~egP?i|?M$gI(q1P{oI6oB`ZBRLnIK2Fz2%L#ib5XG+!^)Jbio%rT*0BvU
z9N(LS&&;qVycu&w=OPn>l%bG&6=&uFnJQS2-^R5B+zdOzu6<MN_KDGInT7sq8x@q|
zQ;-^+2W88qo(DReFDqN9W4&U)fy)c1b*ckb&I1E9i^y}W#HhN*+jb7a{)e*HwR<Kp
zT25!KlY4<+0?Y2eg`VZTEb7ElO42OBUtNjGbgGUgKkgim&D}X{&yQo!<!W9;VMldT
z9<!EycocN`*V2K@3d{M0he@*cbnM3|a2L{}c5CNvmAI(gdhc&VT0{hnylC*(dU3wx
zbj}r_&$2t`DWc~3YLnYTdlH{4?+3%V{}}}udyYf|-yf3-#F{F(0{(+Db5Gk|rt%88
zoeNbiq?4aJU;$M4McnpXQyh;Jw@CV6wbb!>-}BtJ@<0~Yxjz-HrN2zB943b8h+3ni
zpCbWXMAk@H7R}A#RRs^rS=h{jS&D(_vaIOO@EnSWU?sn3A^YwrENLpC++<{ml4-Qg
z1GLOXn2Je$6zze4wCl(bF}XIJg^6xJZW;Y>m7zuV#I%S6G&iF({D<O}lI3J%=*30m
z;;rsJ!Z|z=bEI4yPBU}6*jEwRSCy8M<D9XekB@6o&F()2%~3BE&k}E${Xj1x<`>=U
z2V^=@q&zcBwGUTu<CU1g?=N3|%T+Yd4FW{DF~#E2wxEiTdc(>@H%N%bE6BZq@F|{5
z&=o@Et{s^G7X)qNr$_z-=_|ZiPCFK;M<cR1vIyT(%b<`{Eg3)*IKdPI#`$ICuFjUO
zq<N*+coEVtwhJ0W3BhwQAfLO5A5(js%8}6HY7^eKhmR8%)!toEM?kBJXks{XIPVd1
z)eo+ARQ0$}|H^V~_73fy3~6k=wP~K*v$1R$Tkk1g#KN@J>f8;$sbI|S+{TZ6u0op~
zCCit0O~iRzmQ%Z14hLd*M8VvN1V?$lcK7+DaqmE^@hvlTD5%|i2H)fawbU=@q-j?n
z&m(h{*WT&wI$TZTa45-XC(+tEm6t`{?p4<si{chpCkowN*1Gwv&iy9~uv+c=$H?};
zZh-REn|w+_CVoi<IMr%&-~$2j8K2sHrZ<mk>sg8#R%X1~ou>B<qp??v3r*W&&V(H?
zd%|`kqX`B`J7K!JO?#7nDBM7c@+%$#O4`UO;jAT~gtL~Q8rigf8rig<+@mU*;64fF
z5#PXIcWvTa?qikuLR~N+wFFviYZ}r>)+a^(6xxyCHo@(3X=`eKb>btuz&7W!1SFD2
zl@r5ADal~D^yBb*D?(_Jl8r^5$a;Anr{2e@_wnj|ym~)Xy`SoK)t$_##f{rD#iY^7
zFTL0^$Jki}l4*eP5SerMr5!InFcX~+ZS2jrEXKM6j)oo-^ji%N<En<jIDmTW25>Si
zt#OH)=(lA$r;b-xp-u&Bt#dEXAOM7(k6tDa>eKG&AwBiDw84!8kMbANB41o9xJ+)N
zoG(8oisW2|U#6Dj9#-;))%sgqwO*};QvB~i@khy5$~{WHQuc?Hd<;y97??57?8v%E
zQmbgX=`Da9FH#O9nV@)p=`9+KI|UgqojMbqH|+`hRNux4vytB>%z|)1%XcRKpdZYs
zBlj+MOk9lHe4EhrGVQ}{u3YAvZ}t9PyuAyURMnOD-PKfMgWaA6X~l@KNl?4JM2MK!
z0b-q|3Qj>47X?KF88gI=lNe*53NS(Jwz}1mqLi70d40bz6K67c<9ta*%|t~bNmX;{
z25&Sdaxn^Mw2CsZ1w%JzsPFgRr>ZYr-gz(2^YJ`%owLurU)ElG?X~_ZgP3W!2lI&X
zi=hkhh~PPXMM@OL-^RF1RHy}?*ZL}1ha+$)5_T9q5NsnDheX`<qAS=!p47#yL-&;g
zT&b#%X_{+}-I0bJupk=8sQXg5_YZ<8&5tSRt4EV(oAP8)5pnnEaslPo>71*3Vz1lD
zuLM84D2O6z?B!7V8=g6@)40lsv*jCM8UjMtH&f1>)KqZAJ}lp!nT&kn<V?5f8;s9)
zBCq#pn5yvCviT(N(eZ=9M$?MeL^f(wQT+SbMXEhhbnPOYAh5jM<3!xZo_Uef>;iZH
z0OQ@Uhj{lW+NAx##%<O=ZfbV#H*MzfQbv9-QVxfS<GRbz!<N0AAq+<#LzYE4>aSsk
zYJ7j$DYF_^_c^hz(TX}M5NS+_N3-reN{15bnP8(g%kMix0MekeGiQnhxP2$@uqO`$
zymGz0d-{}dwsogW9J%IW33^}6HDRlvnL>Qw;yt63t4upRDT!_UaC4~cS-a%}U;I<W
zwC201X@Bez0X7xewsJnT)+P^G>2n&MQGs5ji8WZ>T{daI=}(W#P=9(=U2B*(b*Y1J
zS5me)O_9cDmhD1*DjwZxdlRv$aq=T2g}uCR*%U-AOj21BeHQx24z=>UBoZ_mE87fq
z(K*11th?lliw%9c*yYGDnEZpok>243seLV99N#9cc3249>7zg9&UA8df+wYmn+;N%
z*r;$aC2<V`g{W&}IdDnbA<QvePOur&HS`{uKI9r2C8YLa@y+>N{qnnyy}$5op;0QO
z8Y3U7i=Rt1zoPr5tE+VOv7Xq^<{bNOI5|<4uK8~xC9ZdtPL!FAi@51wATy^TZt6s8
zG+kIP-Pwk&HJ^f|`J%qvkA79u-73wtIbW0Hq9<(JmvEEOlYM&$@|MJO33{fV*3e_*
zJkw7@WU8aa?<#3=Fd1LPEyBr%%41(Q3e(qzaZZ<-$`ZMatJQDRg_6IVAn{kU@tqYR
zDmWtS_J+BujyAq_$BbrO<R#KpD7jz)n)Dq~@PMn59K~uY(}Dq-><Bod=H^e$GpRe-
zXiN@kMynWeVEi3-u{oJ4<As!_8%7?BD2?w_GIHGQ4!RqO6Cm8^Dv_s}<rs#<IZ^D-
zN5fnoBwk0@^qSNAS|l}LHk=gmYdY4mH=__zQ*|?1A(5NQr6F?j5hRB_k;Zr82O^F8
z@RLsKj&)RFi_C*^6dH2ktq;QP2jSjVxR*fKIGZFR9h4J?-p9^P#+IC%?Z%d{S8PH^
z@=E+qf;+}dT0EAM#8D;<N8C<1>PUq!bbk&x-4ic+qUi-{Ml#-mQ@Sz8rMZe75Z&X7
z4v={6Wa{zJGuB<he1Bd`=jtls3IMQ|Cl;3FcEKk`8ukvV6l#m78Er+7y|4o5=8}Hp
zVb%*0COo*|hY$^e)YP+@-N<x2#}PN^k|on`IP>rdIeU;5>>b1Tv(itxk<E#N<?%6$
zCs#$c7Du?*z1E)}P8d_gJw>URjdO8YL>uNA9n08Pw4=`+Nn*U@a6$ep#`FdDe)hLY
znbL6vKErWA9oSl9_iojW7QZx_#Ek_L2@d_;{8%#?KU4a6e*eepSn@^=1N#!2P?;a?
zrAUq@w|oW8LP`GN3%`N>5jru;s|H(ZY{P%U0MVzjunqSMng0LUHhjTI%xF8HOI)!V
z#F<&i1tV$B$C%MZ+`s_H4SR9@F+fIQOPf7#9V5q_SLv?1hdIKRx>&gQ1(cgFtIAC5
zk(DStjU0<n_{je=8`|G3gF1RPw6XFfn@Sire{oXPoAk*uA{u-}Tk1dE5nj|82vEDS
z7ANSVaw7I+WhHa-<PW+uyS*Ip!;i`L*5^OL^VP>;^BDU8#~EC<(eLqqGV49ia&FU-
zfubwoGtoLIFB{^DIG2Q)7)Tip3u85}qQwlkrwoK0t+|48O1p`%7DdWw-8GN6?k+4i
zSB>S~&Pe{U?|^8`)YJ)X5}ygrzWtoHl*gN_ui+HDdbgB~iZ-57BC^{2Ci1(y)PYAp
zx4>3Wh570+wyl{cI*vO9p7<0NT*pKH_?h;kbkW~(n&dj)=Qb$Wv2<PhEc~3Jh}6HI
z$zmU_&dJZxyyiB!K8j{><f3~XA_eR`*RD<-NJA&(gtTokf!xnyhp@~@_Dy3J69{GT
z=L}sXzo*JtI6|(2xTvimlZLzK88uE~gR(^@Sxok^=~_g}QoV}w!84x#IC!C#L_9sg
zMb;EqC!Fw^H1tdqrWTaL$<07tY@UM*7s7WHvZfhzpqO%*%sszB8~A`y9F8sT(4|d*
z=HL`Nu<Uigvc&%2G_LM&;<ztw0+}Wqdk*Urg0~WJZIe2dhie&Dvlv5-+gJRO+cey~
z@ppmTyd4sUaKay7kJEW5-~8do_sr=IZZ6-V{!)*q&)T1*AFwNkS3_3}Y<TV(WItvI
zk_(1G?hLHSRr}RjapbJ*h*<f2{x!X$=gsv8fUR<tR!Wb&^4<Keor-%*&t1(@F0*PJ
z+#JlS!wuZ&tmVk*aszidTsxdVB2WjjlFxYhZGhg}AJUItBGTF;YT9=(S@Dme(<7sX
zBbxS|L6~n$!^?d0pJ6xjaW)uT7e{=%kBh%%`}Z{*$+;xC&+9NGs(az767N?o{}j|c
z7bZ9)&A>Fw*tdAeJ<K0D3r@UWw;cAnkoyrMB>#|!x43-2rE|deWO{1c2<{t3%}GtT
zEbMy^795wWuZDfE&PiST1vb-4&x>JCxcAjb`}_H)qc&{&;vW5sSqwwHgQq(dEGZLj
zt;fic9(c%}aO11-7emN`Pm@Pd(~jIT)PyC*Hhw2hLHC)&>mSH0Pf#R@H-`1su2`|t
zL35x&GgB8|DI~pU!=J&wQpMzwG2+|hTtrd6qm)(?x#)Jp1;^C?oF~>)EjOJ0bZd76
zZ>UDwpf~<zuo0!SQf1<!^VlXHwCKeCFf<XqMlbj@(R>IiGH1Y_F!e^+*cZ%n$DGAS
zbU897!-)@kE8palrPH|X+vjsdeOlNZ!Jf=@YrrEl9Hft!Ew!6GI-@wUZrG8HUaM_)
zj-;Rf6fCc8_N|dA+fb7`W=C*Ejk_HSZw!doow{>!&E#Ef_qpAPgQw70gY1Zm!PCLM
zaPMButk=M94YnsjTLYiA#?`X~6=SYPA7kGf=E456kLpjqWs$XJzfN|>ROHAhw(lg3
zj$MCRCSRlAY7R~NhWp-cp6)Kb9v#6g`^)=-D~iD*6+Emz*k25;RItB4cvvxbxPmMC
zgUgG-egzNj5B3#<%N2YI!Jv6^-@!R<m-#a8`rKIEf1pWxUhY>=f&pGa^8t1SH$}L6
z<6_IYE5&yf90Cuxt~Y!#8<}%je*Zuc@X!XWU-U)j_maMdv_+riL<`4gP?)nd=bLM;
z(~R~nQ0oVBPeZc-BxH-Qz+~|5zY@2NEsNJN=mD`=XEswI;ZX<<WkypWKOD3JkP9K+
z>|@5h0HTZ*Ac_=UCO6#W`VoF?%U@$mgp9=)b3I);ucKBSyo-}pP2{dcO^~GaEPo^I
zeRGm)IZ){&xVAz9HZf0<F}=`;%HyE+A|HI-!3*AVS@wZBN`cTOsuU%u7v>|L*+U{-
zFTsK7k-N-KzZ*DmFv|GaPq0llFrEgZNj?L*-;uIad7L(;lq?8`{l|r#pf!xVb5h!n
zxN;6}l13~4Byx-b66lwqV_XPpGe;=7UO!%Bx#TECL34pCD3awr)4YxoAvf9C%ZpoM
zPMLD14dWfD?Jgx^ZGBY$o5OipFq{np)!mnAE=p#*@rit(JceH%Fc!73h<k!?+w6uw
zcO#kZY`KRZ{VOti=HXt#{ueM7A@LC(?58;vM_jZ2&q_voEbx0CAq&Tt0W;=oPeKNo
zH<<mLW7totEk97Ua2Br`#DQ`gANV-7%v_(WQ|%+kn^gz^mk7Gs>nTb`8BH&G+{0G&
zii_-jqrL=_Gtu5N<3#lAuZrXJFGMn5u0gOpYpits8`2TC2`{3UH6t4^17Nj_C2@2G
zcQ+5YJIGL5H*<89Sm9A(g-89LvBLlPjeb@bRaJ5?GQ(E;2$h+t{<R`_>}>9s<Pz?Q
z)<b-{W3Ua<I%qL>uQQWX!;!3_I*!#%U33KEEBxNiM~H?*HrQ2ZVvYW<VzENXVSeJj
zu!S6cJ`*Z32cwoTD8W1tISs4QgLTe`Zi6$_MAi&zWCvhUefdxE2l{Zjr`QC2h%G9u
zXUSfShPh4Ol`v-*J5Sr}Gz{SlwTWH8jg5Fe*$)~!W<XG6%`#H&{YT(t#vjZW!JKGG
zyLgrtlFf{O)%K$1iYQQXr&-K;6GC4jxuCIR=3;Z=#PDS|IjMPQJ|dDn@Ijb~5d}!B
zcdz}_&y~TtS=^M12`qyIwY{_fgh?LOzSLzNMz!r83)CbOY3=TM9x!en#W5VDZ|o{s
z-&YRt-$9kEwoQCR+N--uB=)m7if5xKzod#<gV9vgHstdR<T|{V&LSW=27Qh(+e$Pl
zm%Eb;=#u;;EzQA`{Y_#eGhaP8=0t|adG*<S^EKZ$BfpGQ7fGAU6pR~1B}SeqQ4+-t
z5hWGx^FGEt8Mu7NyZCDlR1gA~al{xVYqHfZs9i=$ua1W~MyTr~tBy0q><_S^`AZEY
zY?GluNt~5yV!0LVkHFSo+jt2$Wn7AEkKxg1KEl`|u{VKf2nLhkU}(HFN_?@Gpj5NO
zg3k#o+s5;pra6tV?M{3nbjNcI-fTDSi*vWv#UyMB3bH5mAZ&e&fb8TijVj%ryNS(o
zMKyeRflCK3U6F;i+P<TWR&2c0CVvm65S<^4<8jsu*F_$6v$=k`OHNNjWUrCi>Bt#_
zrGDr0iR%T`7@IflGCJVW=Q+942=}b=FE$%uGH{cV9EVW=5^zzc{{4j<C2{HGB>zr+
zra_hS;2@4?pF$%OWo&i<-DIyuJ3{N^UqmF5Gix{tR}Nku*qE8zw=);LK7LJo{QVk`
z$UZwWhy~>zxUUT8z8iU{wztMuC-QDznsdx44s~jt;_bA{eq%Sju<|pQjC*VKZyz(~
zi&191;$N5ww9E~b=ToYNG`QQ4p|Z(*k2Z52<z%|x1q6_5jgw+}COAvl5|MHPG1L|`
zJ=WoMel0HsJMVKQ?X2OLaIh4h@wmVK6k&8o5wFqcaNB<)@TV4<=;?0{KBIFs1LYWS
zKe>JCDEfQa9{&tr>dViGB*V7??lAqBe^O=4Vz#X=0>WlaXYmX+&_xAD$9sE3x5*-Q
z$lVRlpa%rE2!*T_^0`B!D*X@n4N~uutF$#+!LIDKUl<Lw*fgY&VTcP}d9)Vf`f{I*
zh;$pq$3Pq1q&~Co4AA4a)+~2w54{<{nh9AcqL6}TW~A9WFud^Z3kN)?dGLi^LkApN
z*{q{F&aJDKe^ITaslLkC#T;P+xCBnzc2imW+<xTv_?QT8za{fUZioK)rPRz*l^^Ke
zYb3w|iM8ZHD{WWe?bvim-sbdg4#SsGR0&%bMEZEW7BXieUu<^~z3jF?S!}eV6LE{V
zFuy53$p{><zA>+?=?9E>0({JFX3dJK#MYkfKL;CMUGWOk065HWkjsf~Ba=4~wI|s%
zl2UL83yxszpKg}2H(WmtCtDsey^c6A|KA6?(8!Y@KwQk<hH))IC`2`Z*k#Z+$wJMb
zoG*Zl)R-NH-^LWd$Od9K9^Q^mMgE{G#{GQFlH3dbj<CCbbMowEyzatCfDD&x`mlpB
z#?Sp@(yklmU&a$y2|#YViQD0g=ceMs-4(x16L*0;0NCzMM)UNV*o>rIltGR8s0=F4
zu3#^kn;LVK^!j!5s_~;p_K+XFh3zE`nQSfHwvGuu@gwrCl9RjEx4Sf<Q@@<hLR{{o
z4Aj%}o$Wz__0Ir+v_D8EqpD!KI;GJN3W$wcQfx6$Y3EQGK$DS`+}@=)$?&|0ZyTDG
zJIvdRTLlD<9ujYI8qPLB#trQUcn4Um5@0o*6~2j@Lt3AZm3I}@)e-vd;qfM7@_0Z_
z4^r#zSFY~Dtn-v&!;9+;KP)C1I}JyY^{W)8(-<Zy5>=|BK4yvHK7dE@u7Us=gC3EZ
zr}L32mhBlUe)6#g)i0R&o@LbxqprG6qaymTpH#d&yUp`;o(BR*HY!W%GRJdJ@MGm@
zl*mqGZ~ciVYJ74_>J0(|><~9W4(Jb4>@1g!!rd#po0WM{3=@jz>ZVz4)d{wAjn5!*
z*rwJD(8HmqF=jex8MpnMqL^v`Ynlf_*7IOoO|0bsQ%bV!-TFcSe_BRI$vB^QS<WY>
z1l?UNuLFd<R1r&a@Z;p5O+*O$-uI@+I$qrM=0xD8%%V(Qw+J_j-u##xK!9`^b3l`a
zsmuI;Ahv5pMcf~2(l9Y}d1NMrrVR>qmzjx?HWS0>zZm?P)Q{^;swK>kA20GAceo1~
zf%Rs1-GzIGOpF6e3`K*D(!{t)kDcwe@}qw;YM>%!x}-u6@~EK$@S{A|z?iC4+72Y!
z<TlKkB51p1w*!U8omf-`czc<1?D+l@q&5jk=@g>0=%z-|NP%zq&s)tHn^?)KZ^GHD
z#`ylhV=UTXZ0v_G$vw=6bxU%p=!cH@H_=z6W$Ss_^oBt_%5;6i`%znXQ*r#Xct5v#
zKR570M;zcs|K#q6d5qt#6Krg*=^%5S{|OO_A31;(YI}~G@21Bz!*pB%e+xvOI{bW<
zdtX(QN&S00xSMQjnd*3ui1^&;WYD@vu8txp<7Oo6URNLPv?Uzps&rD=y=_syOS2L&
z!+z~6Q@xrLYS)@lIw>JuQ>fj|o4ZN;()(mUo@x_Zs+P32_w2O4@z|+Psne3iNwnM`
zNmt2$7N+1_olg3iX}F=11I%>n(5|j=o*eMxG#d#lu3z2Rby&f>v+L~*l)>Ch+`~^0
z7THd0t3;AE`{Hot7PfQj@V+%K;{KvVv66G<MKK$QxU;$XG@3!t)Z`K2RAfX=#I<`+
zOg>?6P)6AwB8H=erUA+6i$L>W4W;%_R-`c(Uybg`WF&Vp78?f@;vJ1TOQCibS`-2o
zFquOE<gMpBy~@key!1jYAr>K;0L3_G6M}#4;YqUw(N}HVteG|B4Ds7aYL@>gHXb`j
zD1-1+e1m6($b`|M{0}$N-qgl`s+s!PJpJh0&i(O$B3$$A2MrPAkZ#suWLSOvl_HDT
zPVO*Diz35rs^otS|Hp=VUy2O-7S|4@$f)}t>Kr^b<D1tB*f``}#Gg5=xxl<I?y!i^
zLWFRqal=IMh_l8qxZdn??SSK6R|$PkKZ?DcHbtkG_-TeYi8TI7;j!Vx&C5&l)F^Vv
zz8KI%Iu19^zuGUWv$(%6)P9|=MQs{8XS!2^m7T@WBDWfDdB{2~nbI0KC;%>^*>I<-
zXLcJiHUD)nKDY4O>4|etW=wn^e@e3v?`G*k<1jOO%MEmI^0$4Y!}y|DnMbLDlF6e6
zF|&V%w?SPD;5Uy*_*dmSuA}qcL!2H=ersGLxjYc^{VBExm%}}g)Q$c~a$1}?NU8g@
z*y_kfiv}a!kelT;*e<+Gexs8izgXBYVc%A}VGHh3@OOCQF`D0*ulT*hK9MB(CBNM#
zgU1o3=>NfIUM4%qXf``(DGdbh`$O(;Sa?hj8|{Lhpi?e7@<qBBnA#-H&~Wz~OfDVg
zq!u1<Iz<$iAg5+u0soGg_$m2kQR`t2f1v~6#?FW}y>C(>+VD>7KKp5+2AtFq8h6S4
z)FRsWmPkNZAZj&reyEjbPTGZ+$gsB9#9EpdZs?3}&&ex5q4tiyl$YiI!L%_qi2xDi
zB?bzqA5M<4Zk`Yb3hsOd7Oa!DSx<dq>}l2y<)Jm(IpCoc!k4}4Q>OY>(fL@wZ0buk
zv6!+<j6SBBkjyuT3T3CSqtiCoi8XlY!(1-flb!VwvrsoPF-lQ6WbD9_zy<UHx6|_h
z@*1%x{!@Con6*<l?`Z;6Z6^Ja+>Bxy442T`Q79Zf86Tw^*NPGI$L1?~caEQrS*z!2
z*W*vq+?MH>Rb*2$@v05JK*9G}GzVa~`(xrz%>DZ^<~2-sg^4@xiQ2d7lXP9YP;j!_
zx0zU0sG~n3#eAeR(%M%5)Lu&Y36-iezPbj->d#BZ7*kX{Af}_}Urx*`WGg(SrG?Ix
z9uuynx6Mn2$GIa>d!OUZ@<VIpS);H>tO?w}@8Ev<n9P^{*O^C>0q8%9sDV`oAlXbz
z*$%Qu(yrpSQm%@d>R?nI+$m_%8XE1#@$^Il9}@<%@E?}<YtodM0ed5yi5v{K7Tzyl
zyx~4?Z|pz^Mn1%1XUY>*>t@9tLgKlN3%f50QIkFEnP~EsdHAmnlv(Y6A}<`vETUT`
zALFQ=s`X7{$)_q#82%@NIXS2e<xZ;NHa6#o6+*xj4G78n4o<kgP)#~zSxF{1Q-8vq
z%#Gd}!8`1*N4yM{9Tzk~_qNFxov-#IUKBEVM<v<+lX6Q{|HzcGokI=blu~`VS4uZ^
zqNei#>_#a2nd8HS$2#ibXCCVaggKt)$8jqTHe)8hVZ9@N9{$uwecn}=<61#ZCP*CK
zg;*cM+$vRZnirf7yCDZNx$G?uuua13$;*ABFbq;<-MN-Fumjeqr(L5<hncEQ1JP9c
zCg3hMicAR%vxQ%_RND&vfm=WB+O|$aB`EfJYK%lE9ecxR+#3I5IC%yoNtJ38g|Qa_
zIblqRf^I!+$}OOB?b=-GDS~ZK<)T-n0%KAtJqLs+a;&pAKFQclSvAp0j3>#Y{l7-i
z`J6@!)WxdU**4&zoRB=Y>WyjQ2Cb%S?k`B1J-a)oR%iP-veiGweXNW}eq{TAp$8jY
z@dP-LLF_a)DjH3C!r>Pct%<OTi+H516X}r~^q8D+D-OZ2r!z2IF!rkq4Tl3YoJXg*
zp-_3p0zU5mrri4vVBa~FoKvP!#pBdt`p*7sYLzmk9PCs@?{78#P?Rovet2+@q;2tZ
zT8P!hG9^r|-Li^bbR$Bl35R7Hoi`Am5(kFcrc)3iBhz{fA+pAQ&5s#>ZAt%0sz=AQ
z7?U0P-In8b48zc~kT@C9(A-p2c$SOC45O!>o8|gP&gu+~tW)dM4^8)=?rSt-TOK5+
zDOuHm?nIMY)k5eE#b4MwqkC%A_^g^R7xwe(5I!%c)Za)Y^0ZO@O7~o-JWwB3Q6(lw
zu})UoMbz0&%vj~ijn~sgIlw3mx^?GiCa9W%xyxEZ3;&9|SuK1(Gh8j~=3D=?HcHIE
z1aT^;q%jlu#yF(uG6uPZkm3<Teb`_uR&;(aV@nk8V6UB%CB1R8QkCw-R-uFO*gR@}
ztUbnGzYKle=0Vw;p_K(jD*n){q`%j3htF~+_rkk<bkMz%clH)o3Wga#KKi>CONki9
z-v_f7+>gD%*^;Pl6z+PihQ~+Gi69u~l8D+Dmr<$f+Am?j<Syn9crZr(rDG{ugQR5J
z0lY`7G43kew~Pg8kbB5fb;T9rlBzukZy3RWpcO><CJkAtUHwJcVug;(a${q`vrLO3
z?ZgY*F*Iv{0!oV}b>}Ufpf|PujQ=45cA{z-Hcq|W1(jowkr|JvLr?Vb3T0RexpI)a
zQ*P4Djs||nH-l4Vu3G+e#KyPcDBgO!>MTffY=I~En~8uf3~7#?PFJp@vtcqGlq2Jb
zARr>lWv7`7&dV6wiXZYP1LK6h9vn5?ox$Fxd#_P5*!+UreT|wSu#5gfs$^P*rw}&n
ztSR#+E)PYLt?TG;cPDZn<WUFxvy;I})bY}>3z;#fM*7joX}zB)*bw^XX=1n!@|N)b
zJwzh2B=_xqEa#Xz2%$$ji)p2fDVIn#RxdH9yVE}AA5{}On>~}dS6$UFo;|N{2b0`|
z1M%uN_&&UZ$tpt->xXa|k{M_0%1r!B<&3JREphP-I&dPg%bNJu-)alxFjN#3FSeI>
zc#cRzeyi1F<Z<y=alKN9+~kIt$#MS~P5y(L^xMs>znN3U{W_i|tIF78zt!IR(CP6<
zO`dG94~5(<?#mbisSR^e6IO&XZx{hy-A852H*$Aumg&EdH9OJ}IkRD(`?6pA8$nFW
z94u!(jRn+$Fg>6<9P5dB{=^|}VcyN|e$C?+k1IZFtw%#tC3kT$m1Prpj~k2jBxQNl
zM_gvZ>{RX$JkN}YIwNSUPugEJ%iNZI42cz4IL0)S^U&2Y%q%PV1h#Jlg=QkgSoR`j
z0YofVcZT^pyt%0}Scet@l(J4*5e1Mi{Ak<a>u%<)O<VmF%frdJbxhUu5OG!flEbXj
zn^~!)`^F*j<2;Qb12Hf^xT1vFE6xw_(<*B;F9u||>;8As8~*SAB7NQeW%>0b7I;H}
zl?<gAI=@%x7;-DLA`I=46u$$nYE1I<2KBC8xx;E7E((zRu4AwSwrPlyYY;}G82=hC
z;ojG9dM_RaO%d3y7a^q(y1o3c*#IP*S}*~Km^V;odk<0zub8;)gEEXk5*Y-)V=izC
z9pS=eX{*HF%;~HS7s(jBCm-HeDI-*d-tB;u{QyLU;-(%=XV0^>Gi~vq-j=HV9)$s0
zT-eo~UiB3x6-}33=5VOAAM*hp$B_;6A1W3gE-u_@Tz(=+M|(+Gud4>Lwc)}+lY2E$
zzT`!*3*8ck4~e!(vq6NWj{9Qqz^B;Q!thU*B)4%Iub#AXN$wN^3`zP(?_XgA`vxuR
z1yWaV;Ktuw^7lQYK-1l^lZz)z1P23RRi6Eazb`K7QyCC|4ZM<cQ&_GMa&M;(;(g&%
z+XQtZHi<oxjxhuv9U({^9!fs#S2)TGvEjifcTA33PGKvQs&VVGS8@-lKw+n!$o~5z
z9X8{KO80spAdHN@NIDK$OqA8WEmmKYBz)s7b^LLnU+=AK;)-)`$FAB6KA$g#@z~SQ
zwc<1GHkvRTB&?p~s34Z%BRpA#UD%>|Q0R(hoy6_%25q{}QYnSne|nQW`8xBu5c-_X
zK1#-u_CqvK3hXp`;i#(j<xjJJFVc}egSOIt5@;-1r=B_%0|MxC91R$?q55V6%TfFH
zwf#3{48iA<?%OJ7XQ6f^6%d*GEacOO9}BfB32ILVto2;<ac~~{M~?ZU7_(~RiaaO!
zuGP1I^>`;`*2x7;(UrNU9&ESvwUD{-2xs&*IcF~*9Wow{wo@L}u(JYVR~RDXo%257
z#5r&tb?{Y(N~SLEMo$8CF`fNyV$l(5#?Q`AXbGR);&j?Kku&Qto&7%Fe)||3i)p|Y
zDcpU{^pL5K{2w!;fn4#&h9|yPB|mk^)-KY@>6!cYdXm5E?j^bR?qwaJZ&nm&w7#8Y
z5|&PqLvQ<Hr@;g0b5U+V>p-Q4r~H93MsEON94+8Jp{-3bnR6^eC{__}^u_8Usj!0@
znh{iYz^fn)m)tNe;9lXGAqd(-Q-9oP2S^J|z_Y@+(m&N@?5=DS?#;yGX0=b;{dbvB
zoRVR_to9pu&L)Sm?|en`%zc^s!%4d?oSc6H6sN8!Ip)qta@~XEYryTNPZ@J3P9_vL
z6@O4(pe6L$?g?~ND+@^)Y(6I&937>z2iSL1=3n{kY?sZ5{+S4HRNM(EDEt2qme^>%
zT5SnlxM}6k?8j!vNEw^u*{S_W@_@7{l`b)|WA5|v_U`%Di{s^>EXWGmZ?_&0Q{$x$
zPHDpI=zH1%Ys#&fSsW5@NHA(X|2Z&>LQm&i4is0k)cuv7q(5`tB&s>}<w87tXup7W
zx_QDpF3k{HJtHL$bghgJ(S=5}IRwZSCQ#NBp^>abnImU#VlWY3k>Xy<poC82?l}II
zcB5z@M+gf?qxHPHcDUpN2Z0xKQkOraA1ipozUPHd>bnKZlj4v1P_4BRV`*g2UFa{u
zE%s>sO;7p1jCPCN{Wf}qWEiYK;dpAjZhtHAiWEH%P6aEtUIe`_8QmedU}3k8FE!+4
zry>)4HX9V96tw1I20C{)>>R>{H4o+2AX%=5x#8}R%x=fm={xLj#hT!1Vn|I;>)jJh
zEvac<H#0Ti%T&fl7_Eml%f{;?WsBwgpOpQylU%}_j(`{_aJOJ`p?}SpHj27H+2H5~
zNI=zSbx2jhe3#i@l|PHRA<BeYS;m9w57TuS>+uYHEo$L1MgO<yI(7>O_*q91&5uY`
zDRXd%kNTAHf9BHz#PZ|t9vvgbL=>R8V1P}5!b3<iXC&;f)&5Vk^w{*(l~(&9o+7EG
z_3!|my2!4JwNF^>Z}9<*_0o2ez38Xj#C|~ulDDJ!^u;h{I70uETC0ly3_G0#U6rV*
zpgG1+%J-y!4~TT48PGOU4P_$OpryN$v7bGHrvMaRedS0=We%oie@-{R_>IW~;x{{q
zDP^(dNOGwYNuqEq_vn8|Jq1enZFWNe?fEAxyT(AUHR6#X683ElPr=s5YMVmYE#JVa
zmmFy2Kg~Tf*%liF5Xh12E59_&X_Hv4WwuedcLsABn<B|?)kTvVMOqD0r306NME1~{
z*w#^RN1}gwk0irXD;uUxOwPI>XD`<KEduCaQsf#ktq1!M+Qcq14v{Xg6MyUjBGMp4
za@Pp%-e%e4ee-;S5qT-<j%aL$8s6rvB|pM$=z>{Njc4&a>V6T<d?bAx<+{4K?bBLO
zkteQgLb2~<M=C04Pu2k*oJO+;BBRlk1tMc2jUDPXH<16-;0Y99IKA8D_sA;T*cW>T
z*jFd8EE{f&?Qr7oX^|ZcE)L6MyQ9f@=#K1^A%*NKwxR;{z&vkkuk+lY1{?RUco@x)
z#n(x5Xz^M8#OuSGQJ{_gKVjc9ERnAa5Bv6`e^(iGuXpn8#j1%EdR4PHkCy85bwX7l
z)tMDomZLg5o%kWDv(w4%7pfMtq%V8gJswXm(ZCY}EM>J{PeK+>9}34k>OmluxT%cO
zi5yu4Qk;|TP)}ROa|Ak*MR03<u909Qoq2ZTfi4;<pDp3bvY&ah_UoANyEh_uej+k~
z6$U!8QH%O6b4L1O3BeC*CgxTX;%$N45@0v@PJWc9U)P^Bwk1*UFV|LOKtX%5qfbD0
zAs}28&X7ft2VRl5{R1B)`VVEfI~m>Pb%{dd@>5~8@+-Xj7?qnR;I(p#=e6=rg6T)E
z%on=`rAiEpy<Flf%ozbBd(s3)ACqn4>sw7z0;rN&ZQ{psDGK<w>;`&=@uL1)_#X_S
zcv|J>X@TFk7{oU{O#v`V`|!07Y0<^Mr<OnjN-!L#nJ4<rU3pC;d1Kk&y13M30L;Rx
zk&w^HFk6Kvh^#JER{fREJ<eD3-iyx2W(2vuV3iaHV58Wp5A&RZ&!4(=(4}rFa56Fs
z6cJC^`lO++))T@r<~|ru2LUBu+<w(bl!`bDt$aP$&^7olI*9*Dyj>?sT*tUAgB~;i
zQTHy8uV|?mig3A5^x~J=i8qTB!DFc+@H<e1MW5l!<~tVg^#&V`nh9|N|L?Ha4PD}6
zJ+>|Pd186ozz}bWW|r-S8!(_?=WPahRriK&tOz*rq(J$Ey}HLnnU^zV;YB7H>bzSa
zck#<`e~5<9(k{ohE&B+5Fj!cUC;Z-X?sP$+_A)Xw7n9jmKD#~n(>rJQncZb}0VeMY
z@_4AzmggO*=!~w&b(feG)lMB=x~rU2FbWHv8>&L>@x9{eW0jpc>6YbZAaih1p#xS!
zpvG!oUCoAl2u`T~gw&h*Q<E6q=7ri;Lfp>&n@b%6V5-AUp7+_$w7v1bk!K=F?X7aL
z6|M|pCi9ep#bx}r9``wgOk`3QZdN;x*Z>s2ET1115zCvlpUkAwRIK`&aNaf^aot^9
zW$q1Uz_<F=(S>%yk<bsujGS@LnDTHT4QeYgtBUwOCzGw~PfRM3bcZvC&kucT-@;(S
zo*(!to9+pgSCAwKM5;-$wP~ch6%Aqha4bUoO6<MW5Wm%PQ^esK#>2Yy7*yt=Nb2^R
zo#Z+D_HZ(2h|lAHAn4vW4^%w5Ghoi{=AKgGJhWeQT#q#;qc<mx7h+#+J+9z*^Rdvc
zD>ppB3W|Nd_4W<YqKGd`-2SvL{*9snbLa|Z%3UqQT`}6ze9(kVE!>d(hjY2M9@dP&
zMMrmgBT+c%OI0#Iu~7T=%h>2{OZ1(OW9Qzz8`!qd-F!B7hAFFk+ie`-wh@I}$j2$%
zs;7m(ywm6*o3-f_Pn*=6Tm}jF1!j!Z5bELof#h}Lo>b-#)oi-e+bvdeg2W^Y^^l;u
z3jGkL#;ds)j8{HQoKF9zH3j&*`qO-``m}bDfjAo!hZ)%!s38_J(n?J|+w0F%6#3i{
z&NhYGLsXw0J!4Y3@pk|3#}N@AqP*puj?r~Fyj#;!H0=uN)jvHy<Zouku$T59!5s_B
zd+em0(uTB?b63HkV;<Cn&?7!J7t!SP?ypLQl8pqJef!TymIf&JIw<ya0cppb0S01x
zJhodhaq__AAED0nZ$%_fNX-3=x8`-W`zlmR;PUxu(L1*D@@V6$v1{ih7wnZo`oA3+
zLhGsZkMq*(c#VIKvlqQr)<V*d`?n(%Y2L>~dU9~2{4WO8FPd6jkS*2)CVy&s{YX`z
z^-VATWARg4kDBal_xh1h_tlVlG@QH+{buAa!WV>NvD$js9)ii`L2AzCmg7w@rdYea
z$|LszYp)X@!$V}2{KJm)mm{CD+I3#c{gyvYBI{drdN_IQO-^zQ8lO9@_D2ZLzXks;
z?n;7I>FVjUXg^)gUkQ3rOAv6y{rPhSnj<`B)<SY7hzgr0h8wpmpKm0k$Ncra*c&`9
z!o0N(=^MsCaNrQ>DDz|NznDD_0wt?{XQU8()O?O^k0fsQ`|kLETi-Q(;5sAo|7@u5
zCka@F@-vVT^gc>tM5lDIHC&+!iNe7)-xo}M*Vn%7$rEbWMy-jU70h{d1oL5duNo%<
zS_IPqt8l7<4cjqL4!S!VI{vOB%Ta&Qe(nN$j|3aD%WxfF439#M?^=mbrr0%x3xNml
zS$989-jU=N8Q>Ws9|~CQ@AxSZ;}O9`$#m}SCP@xt$<P@vl4k52kreRetwF3SxQWf)
zUgw=+ZYFl;i~yOIwO~_W?(ODqK_6xW{h2)WgXgyCBUwtQgzg*VdHVMm>EAmw$@xKS
zvtqBQO9EImNdG?4_+2Od9HI@S1n9<{AI$&G@gQUkTCuLs3|g^}ilrS3j-GB4p(O3H
zFH6n|x+y;oPAa8~xuSI)&_crF6mBq9Wd>5HR6oJgd>B7iDTQ0JcKukM2IB`;(u#g)
zA&`X{)`3>D8^&(!OG-prJde!OXYE2o_E3X%#P`^#K!J<D9io-|gNuK9h86`${>?mK
zW)V^fkPtH9EWZ(3;ko}cf!N6lV~Ei=uBNLh;R8#qro{(}3B2l`&B?31n_R6YQl7b8
z+jGTwfyDF?PwP>YCkKcyg9hM^{XFKuI{hz~`pS>JQok}#D!G}QmA7E&04Nh4S;?z0
z_J^jyfC`$*v0WGK&;M5@d}+E*wE?B=&ITKMR!m~Bb@iH^2W%I-RE=nU&^%jhBN-NV
z6CAx^>t8G6a#U3PYqd!TY<o`r5aRf7p)srtqh5%M?*&^ho;ahgHiMWn3b){f>vmRi
z@L0Ph8Arf2@<5SK#pnJT&ksTWenb{bUT*!Y_Ir3{b2DqlK1XXOK3Qu}+<ehOkz2(&
zar0Vx?mYg#i{xGd+WLU$+P3S-!`+mdrmVb{>e#v*DX_Z<raU)_4+Flg2JWHN6zX;b
zKe{dsyZ#At+zH$l8zen-(xoO3i5ql1%q29e3_JOZu}O1T?Sgq`eaEab*4vDF@8+Jl
zr6q@vS<>`^u2I@_mO*eQQ`VjNuejUIV)KuXy9SyvK%m!Yy|tOOsi(CDW>;%%DCC=2
z2p@rb+iuodn^|hyRT-RzHnYq$R3(T;gVMDpap135-D(2z&0A_lXHx`u2#ceBZ%zb;
zvk3(%Iql!;q1fK5-h<|Hz&>8SY$Eb%7WyIt0lVjEk&6S6`*lTDEU<NDKq_-VRG63T
zM9r6*z_C#*D8k7xx+}pvmAEL=g1WyV&G!Cj@b3V;4TDw%@TYkyF%xLnV3F62)E0Cu
znWTgp-;Euz;YED0{ZSFgmt<@FJJ^QV7=g^2?P3W64BXoJrt;I>wZ<eQiX$0SE{abB
z;GSO0-}fQ9z{WE2SVx`J{ws!$<Yw8@X+ft3<bbjn$tn@51!aC&(Y8IOF=nvaH}fFe
zPN)Z{WG(!V=2w~&Xg_GWQ7CGO{=rnLqd0Yu=PHKg_rLsiPi}9uFG2eP6%>&yh=-v)
z%EXX%wl6>h|D8gL^D}osn_F_d$iF~m*5AsvQsn__!XXpKIMfHwRp$$)@@b)=&*Rwu
z2>&S`n6y9l4q^x`L}aGz${?JY!?7o&6oO65{IM=N;yF8c8evK)CHzF1810LAgOF=_
z=$}X800={fBis6fH`mInwl32V9<2)sF*4$EV5R*k4%KUAt3^2LF^_^?!^t~o8dHMq
z1hDc~|43j;B*%JUeUYS_`R|c1u?*l&YT0^ItqKm6<*022R_bN&=tZdVXcNo)&uV*u
z4<HbhW>y##3{9#744}y#anSsxW!;)@7td~7(Cx&}o0*zC8rJQBNosQQj42O%K@ZC?
z>HzU<rt6t0g@Hu9zLd%A#vlo2&%`wt34a3+o=NzdbF{2E0$WdfwP{W=_Np`2#kh$X
z_JDyt?a!=~PxJId+x!_M_8kj|o0Q&b6!S>Kb6&`ck(60&=kiFJ$J9S_lZ)SV#BzRD
zrNRm?M^L{NGr~WI8lSiBk{C{W=<FK)#!kg%@y+3E4ksbyd-)XgJwuY&T;9sf8FI8)
zPA)?@xvvNqwv6dOzC&Fnh#9#-Z4A1Pt<rDNZGxB)38wH1js6fl@0FC8$0O$M|J@AI
zdP8#oU%_g0yBVX?Rlxe8<A#`%aqBX0eO!@25cUAqXAoCjp>k%omt?VN*>m)MmlNMg
z`+nq@o(~~Zw2Z;$OxFv_YYeVo3>NQZ3_x~c41Q$jCu876>Ccoga5M%5Zw$U=#=v0=
zm`z_bW55Km+OGD-;K$w=EZCzlXfyb8bm;Yr!6wEakIO6TF0q$<4K`^E7MC*yh%pT^
ze0#NW_jQn@i7~(=In5Z@PVO&^L9vx?7i-MpFJjlp3Klesga_l#@%QvTq>H?&#;n2P
z%n0Oifb?z=9|Ujuf+Ry$`xNs5$QSr1NPxHO4Be>AeU@)3LxB3^G0O~-$E(l>B)*%>
zMdCg#@pt%!lA357Go{&GZ`f0hJ9Tg?p=u1!xFS)MLZ1rD{u%WRxaIa)z5N6cHpwLN
zivG5#_dJS@)C@0rN66hsV9<RR*!k(HF<(d=V#`fycLg{?KOjeFhix-fEqYpO%v=T|
zNVL#Kb+!;Bwgg%H=NEA!JaA)XM?Z9gqQcRDxbS>@Uy=N)jxB1q+kO-6_yqE=K7srx
zhRFZF{;)*;zk1BH_IrF+*Qf+#;+Yy5^6%jy8Kp|ee19vEW9|Zy4I=dY8_Z*-AXuax
zGWstNwmFHw(+x)0{y1oDj+u|ZLgm8l@Hy_}9D9N`JqlDw@Kd7b+0V4AJ@OcZZ3zLe
zR5@u0wfv=jEO9C=ylBk<rXj0lD!UNm&rIhMbnyWDTx=22o=38q+xl~9b{{ZXWbP!}
zCWWa(y}7nZJ?If1%{2|lK!+Bq+dtRt%$EB9RnWlcZuNg@B)!=t;3;^7p|j2Kp#%GC
zBxU-WolN4L+ez{NUzb0e(ET&uJcbFu4DhfPPqk?dFbi7k0d@0VkE($lkr>p?W=?AW
z7e1nm_-o{57{(&MnA=J+`qwZTBfOcG(oh#U3p*8(0;geo=yg#(!%+Z9ukpuz$>AsW
zE7mf(XoFxAHXSFk%FqTx!9r^ox@ml5yv*otz0;!$pEnJWWZo2!dw{$Lm}?^+mxd0e
zw$hj9N*_IWtHuVAqX{PWwg6U&0k<iTv;`0lyJS+D^DDv#nCT9Irg@-j)TqrMcu`p)
z9@>FOV|v+csS8T~VF-RsR&%Ck6YGgcCE@T85^&}EyF;osmZPnk6>|vV?Qu?=Yw1qy
zsg$&eLu#jYv0^Y~ptU!$hSjT8Tz7Mt$Jp`}LU6t4{<V02u!-H`>of54@m@2ht5bzV
zgMdv364C`Hh{0P#_Sle35QnF6;P5qpM?)uk2WX}kyMR6@1rkPJG|iz*a&RtR2VlfK
zn=EhPXV?A08<kJ9YrzZ&P~CcB6L}c?r|uj$DR(dCTdsjBqe#l2gu1vvbVEC=nwbnr
zXpg}jKy^s~0nKjoNb*`P{NFPYle=lbN8}fP$$CeslKcWRj^KS*f!9RtGx$KMKB+>d
zDgn;6wEF{`UEN1chMnP#<prb`69=Y@#{XrF|4V%u|7#7y!1ymznv(Ehf4{kLGWc8{
zU8PtbPvoPIK;iXS6h58u`sbvfa-k!d+sapoL-5nW2tP(#R)>-p8nzG{zYut(ku7}#
z(H#tt`{~y9*S%aHD&~r8WJ{muRs5{Mo3h5d2)&#i<s_qfq)wMIp&s!v6T!@o+}mWu
z_!#wv;$#78&oxXP!`VOiK!>!S1_{WsrZw}A9rpqRHC&cREXm0rIHArw=or68z3|O{
z_v+hcsI|%7@s+X`I(~7s*on=)#>~q9z%3AdTHNE@sy_S!Q6y$Y;%S2#0XHJJH+El;
zy}1I$!^PJ-9S)eN3(Or$R>27)AF7F6pSYv0EVe*y`K&e_?a)zh%%y(-{8NlHkm6?(
zqaac45qZr^JB`DZou})5+>Z~7pABAbWXjUY*mrc(Kj3@qi)uh3Q=eUh*g%B#d;+{e
z^UWNI)VKP_hG@DO7{b%mcnu(Sn~bW8HP5}xSqEurm$|?-oB2LMyu2_G=DL|R7jeHf
zF=1cft1b($5^UDu$cU#L4~i2FMu#fcT3PTEwEJa`X6;l_6?GiT$pg4A<VTnARy=v+
zVJaGSJBkeTJQ(T|vDcv_24Q7xVA;#jWMsP&Z9Evelp{q4Akd3}1(^ZI`hcO0ItUrf
zixr=Tw=L-GV#4#Ejk=(+G>3do8`Kmy>$OJQMGOxY5s5PZ4HI;r5#CBPc|FWD()7RO
z#XdG&%=EQ9QWp<*g<k2u|KH`g2&Wbc<_iyg@u-pxfYtsPWrmNGAy|sDo!m&mK~o7x
z&;b<o@Mbh3&vg4rNI@l>GQZ@w+6KRr)7Z=*Zg_aZ-qe^z{Nx6F$30lHrrad1&4+9P
zrArfCu?o79;xGxE3WAqhj$Qsb_CDAcUd+4WzJn>{g*+u^d>vZ-8Hz#W;+nCx(Y|G|
z*oEB+GkIWgn19(&eCb)ZOZ>L`N>g(2{|In&e6y~7|C$+zH7Ehnt~tgAx{g?y(WrId
zj=;0YwD7LTgouGPxV2$ZetV(z#iw;^6h9?jxdAZ(QmmVlr!Ht}l<!0ouK$Olobo@`
zV?d9|CH}-wUt!MIDQaw?)@NFD`AB|pm(f<$xKO*Fj6ddTU`SWBzI}yug5rLORN}D*
znW&hQnXOYd%22w8xCkSZ<zH7ppP~Ju>xwBtFGj;6&<FiVP6tjWfOc2(AyJq`_lUy8
zYxUkwCV%>>0%PO3c!tri>P=DX!>YlMeb`A(2_{!cv*yMurwAOpJ)1qFnUb|=_rSpf
z-Jd-`g)mhyS{B4R3~juXATF<?NUA@_Z43xu3IT5SPf`oPjaqj8fkI)9yZTQ(%0BAr
z4HvdV8{dw<(wx|+{Gd%qa!*db!EM*OliDb<5lMafAtYpipnew8{#*}bts@*hRCg7&
z`y%RQR5l=M5hSeJl@oqfdiX7L2;5Fj$ja@;XRW(*mMaR)hl-=1d+b!oSUq?K=Lu1?
zH;4}V8p;ANxwScHZ8_irh>+K&&bAwsuh_cBl*+Ifu}1LS{@CLrhe<a{{O^+2wAexb
zKDUJwUnK2gguVHeId1Ha0CwW<O5J=X<(h>`n_zmr%@`$2Zx6HXzCka@lJC5h2g$MR
z#EVq=7+kL^B1DsA!gVd@q1=xEx_u7?ql?%kj4%9B#aPNA@Q_z;8K~*;?0+&pz|~V0
zI*hM`f$GD)NmGwX2Zjp)G+0(?!&#KEwbU#qtG61~&*QVzU_iShRGY|a(u|%v{f3C=
z-5dfG;7reEBG*tSvM1Oj)VHV-4H|6E{vKvgZo2`H{Eo@XsyA6%^<F`v7Wh!xjQDDh
zu=stsL+budYR~I`_@B22l<Kldlp8REkCat<!>{UV_|N3%rYioCcV}rzvoXntP80Bg
zm1?0_9r^Sz8F{9T=bLzrEbYO|E*4YDr8osldoesfg0Dk~`7j-g0F!_N;iTl;D%?T<
zjzHiryg2(JKMW9tjJY`dmtV;Q(;$QkTceHdS?#qaxd{Cm`qEP)yqQm`>X-N(SUO9)
zRNve+BE8$Jhn;b5<cDY(j|=<K@OHZ<_9wrjnEZX()So=R_M?sdjn`<^1SW$<FYN<~
zVQO*G_0RZsv)_6}6p%*3!>L_dGZ1SSh0|;$_fazum&1?>tL-1i*G>f|kS4MPw%1!G
zOhCJaX?I4mJI2TFHF!frfl*I>qrS)t&NAm&EX96`Eo?4y!765B5xej#N0u88=eCKf
zD0S3y3KCK5ZzW1MrjyR6k06TqG4}7^W6E-`vY{D2&%@24O5IAGvlU;1xNkOF-4K7x
z1|xLPHn$Lgs&7qkW5_;U&K>91%Y~kFPM#OGzsW?<1~FutE9_EGahKbzBylWQwTrAL
zRpKq*WovG5*W3X9d}r{k0F`9JylFr+NeVV4Q!TS|94^$p_n6U!I2Epn$vPYbEpRQ~
zB2Y#g_2{>h@WIUa5a$@^;s9_PNsf*rudj?W?2xf}+Og*Dus6^FWf5ym8ss+2Hb2GD
z0XWvueQsm-iZiXpZE=F|D362pmnj4rcEsLXvI#98r!%cN7`DR3yo~eWpsE(tz;Gay
zyowDh6K%lv$+oaHHy!qpMXhk=cPibs=0NGw*;~rhDvLv+*9fCol=QK$eOcUsyD8|t
ziexwCpJW%(;6cr}XiV#>>e$@g-L~&2KJEByyGL;m@iNhogWA?lG9h1Aez@1jLfZ8O
z8`CS!aM2)22a}Oj95+_AI)yGyyer>v)9#p7W2vt;(TC4I`>gB*aMCO=fLY|3KXc$L
zWzGY*Aq>GxoR6<S<eg}1pT!|Mk{pu>H||_^XvG-2cUQ=_2j_HhCb%=wxHGW>69d!b
zo;}{6{#uHnPt{*)=#OmsSIvejH0z9aUY+E0+GtzCs9?|EKgP!15GgXQGw`syBsYz8
zL+u3z<u8V9gwuK(XR`9LWfPR*sY*y*_JU$*pn6dn#_XM_dcb$M!ZOxm8ff$ogAcT3
z$Z^;xHmAn<eamg-=<dj5%TwdZTQ|vUr}cFyji3Se2UR`$yCq(;M&tjYRF=yz*~(X#
z#fdEs1;VZj%-=!wE1tkXZAi|C-g5D`W0~BL_mTfgrXgP~=6{jXT5N&W9v7G30TdDE
zL9%FMEaU0a850&y6Yt&9da;MBe~(dfl8u}{C=%nP@-UdaT>CA%3<n{7QEyYg?UaU%
zQ(SicVy}r)LBEUmCK3r@!xR-CK~$KkLN#4z0oPQ5R5~oX@wnJKB)g}WL9G*~M&rFY
z{aN;;gXJ$JBG9jsX!^ni273}rB_@+!#tY$!%gr#HXx*+cj4VAI@nz|tEoNR#^J-_c
zJ!`6KdMDyT=5cDo9WR@=M+leVEIZ~2qY{gK6q`Hi<OB{*n{g$+HR9U}<h18aeB(Eu
zdK@Tw_kgzjSJIY2LEa7fwm~KkOYf9R@qZ_dT#7%+@4BJ>#BqE&q1*E(&g0^4IHVWx
zC*JWv1o-C{rOn?LyKq*@k3-uINPTznItFh?B~C1SG_ugX6MN+N+h)m%wihRl-EWrK
zZ@*j~Nsfr7{644Cr?ss!LUc}Y+_tFOF;t(3#a6&b6li)1B-RB^a&kww@#yk5z4PQ8
zcbxggUCK6eqVX=@cy!s}d{@NvX`OsTABZ(j;{QcPaJ6EPSo3EV=Ubw)(B!V(*b;Oj
z>)Sws4`BolUAhl{l<wBvSMhi19$~bD4KE}Lr&#w&jcz)An7Rwj($}2i)V*_(lR=A_
zychh$y^-YPOn50)4pa9=8&58;jkr_6*Ww!ik;dL-RrxcT*G1ivJTI?8t_`;~)%&P~
zq`*o2)Qmn1(&q`g0H}5Xd{)wb!#(OC#6PyY)q5F_O}Jm}U3nz3^erK-55!nECwcS1
z9vUgE^=RW?mc0{hd}Yn2BJRa|IVv3N%Rf92*U-~B=1c5gUof?-JcQv(1NeuV(VM#X
z%h9DLou#<MecM{Q6((th8{F99E?(b8?kEW6b`sXSF4Wky<}1;qY4q|v`piBDMaJ1F
zK9st-@JPp|qQjG^L|K&aU32I|<)d~wOMTk-{PIq0*7sJ1Qr80`aKeYm=^cmik8rnk
zwzIS&m|WYwnu!!l2HRT_9VaoX$=Ouk<CH1~mtg31aX*>=@%zaR-QQgj!dYtfVfK?z
z)IQ8TL*{iq6ZS0p=PcW=ZDnW3x5I2J9r<U%jk^YKD+2|3_J8gl&9-kgv4z?g*@{jp
zj;Gl!V;7ly)n;F%GzgcIdCSlAYD7x1><=qWH`^<P5i9?Er1516gVnM&(BOhmgE9LV
z5pdPFY&71*Ra<k$pVK(ztk^0OG2DuuVqe+HZ-(Ld9oL5=spa!#q8kpRoG*T+u|9D-
zJkZ7(|0rzZvE70KWMUVFF;PKU74~(ZUs)44z#pdvoGVT%qXIo#WZ_TyB>62nC>wk1
zzyu62Vp3ZB$UtY9`JnwA1?3?%swD@?!i@JoDX~vx#cco2ek}bpJd3pG+WrHoBlSg{
zl#>-R|76&gd&RUvN8E}p5U^n)ac=yE6yuVMIFU^2{#!{7dK~M~bFoC;>TpN;qja#c
zCw>Xil3)IEFr;Slx+k+76%lR>N+2Z8P4PG3IqxH<<S>KK@p(gNs-JrsP`8_|DKGOd
z+d^&JL?57hc9*+P$?fI|U2)+01}YUv-k?fN^(qyy9=(7{b+V6`O7+Eo7r5k1Dpi~>
z#rnKNeM)g<$+$WGW+ZuD0WR8>eUa7vuM`EO!33&RmVJwJzmuw-sLJhMXaq86I?3uR
z(Vb*%j-TusCO9?=n%{;qYoq{sV->93yU%P(WAK=)NSMe*x^v1?94*TVI}#Ny<zdHR
zh>rC$4g<8G0#<qjtWp8XDIoi0btbh^`bT{EA3b@ls#i(%o-MZTW5*i{W*r1jvaj%y
zmuHy_vtQt>Zo6nCqa|FOm^PEzlv(%I(&p66LZZ*N@+_L+Vr<Zp{S6{#F#giIMt_e&
z`#;E?CI-K5U!uns9MNaBZ}h&(q@X8T&DTlkWc8m8(`(zTd%+S!Fmt<~jmNFtL*U?n
z1SKwc-g4^1;6$xQFP@<3g;H#BdR@x&iegMQctw;AnqU1%G@x7JER$)UQv;KyFvH^4
zGl1Wr!0gBcgmq%-$XUAW7`<@(Z%|B6-i}Ev=J0p>Cjbl-JH<mpukLT=Z;%Suox{!M
z>#=wPBjt_4opj!_#y(ddBdO|g3R{wU<?8Y>t;5nkt=}T|Y=Q>cH#0mhQJ2IO<+0(N
zWg27FXsiig3U<D!%fI^o(=9daoBC<&jiZF_*)R|355uoDo{SxmKXms0cM3c5d2<vm
zM$a9Fhz%rBeMBot=Ow-4-!kTBN&r*2k;w4lrP}K}Q8Hzrw#L33x<EM-iu13qgYda;
zsiqE$V|7rE;$0!Qud50}DH`XkYp)(S940S+1y(*e9Ao47XhVQgPPs^WV(Rl{@uQUU
zX^1-;rsKZv?T>{8C$)VS+6j6s&H<$Qdhtg^E<E>bZK{L!`yu7EOl#9+DL`x`u6=98
zGD0x_x%}$>ikxLCQf%M<etouUTP@Y+4=kgB&g99QH?J@_0|sgCdBAXiTZ$4CMGS&H
zKMu-(;0$QV9YIlob7=NuM#Z^*tADsS#w*w)2C^J<es!NWmJZnlCOqc5KhW92#pJXn
z`|^1>zLJVg_8h(qBvyTf^6O(&vznG^F@_PUcniyUs~L8N<n6lbEf<g{gNjeVl)r`l
zTP$*Q5(j#+OMwt@8a6wC^tcsYCV6MYRAr*?$!S}3VngV3QN<=bCHi0vr5DPk@ay8I
z22fi1s#af2&`$`$1~h&t&p*`j_x)v(##h{>xT!@|iB*+C>Di-5BlXquC*VvuXE8CB
zV>f#FY!fx^A3Pg^Y<k0zv;9rO{F9K4xd0;4Do?jXI;(WE*F0<#9ei=_OjfLZQ{;cm
zO*leQZEL^IJ6MsaIER?a-})IADudMfIsb^Yl=)Pmv)*ZZ=Jts&Twm(ZX`KBp@+FRB
zW4@#^!w9muOHfxPYir0eSuvWw`LvU|v2uv`J9%}bcJ6j*PLg>QZCu63T8SH&_tar2
zFOk%=-{AAkep-eIs#{n@Str>-{_MdW5b&~Sd>@c8K3b1oU5QWIK0A{>2V<jCth-+%
zS@P86bUzA(bCOk)<}Mv`chq;nE*uJ4kB^O}eyB`CZTs`+LXQQs`XYo0c~Hq~@~0z1
zGZBb^^51@BCA;Y3aKrYf51rG6eTfrSt~@{7xk<HhyTiL)5BKhhHtxG4lA2X01`|lg
z>Mwb9nXjU(pKi7iGkFSf)KAr3&UrAB^n=)sft?WAv5!@o>ByW~L^!KS7vibvbLbK{
zvFtX}b27-QK5#u7f(|q$eX9DO_5Sa?vz@l7%Z6IiAvDCg-T-Ou;`%7EblSJyz!<l^
zu*POGUdQvS;wh4YvWsT%NTgXE419O&vs_%)j14#TtmNt;QiGGsFz&68+iYF_it$8+
zQJ!wI9{4OX8WB?4OB4=@2>JR3<%^?A7g2m&T~nvOPW8(sVFv8v93!S>|9G7`xRE;6
z?Ls7DV%-Y0i+)<na~-eA(0h#Rn$z)x9h;lz3&dtkYauu`J&#2bj07kd<*`!}eg4=a
zdqaSC?xIE0zfaB#@b5V%@1O(@vB`zmS?+=zNCDsZS1pRzf<(n)V!<5CW)+!o_Mg#S
zmq2fxH-*0{;D5UP&FiQTLv<zD+sSLls$v`of#v@_-PA?pt6wKdR@_aYw)<bS$g9g4
z8@D5SDq+tK%;7=w&e%*YtREntA>;y~GLHyOm}@e5gKVEVTg949Sj2P|U%WVFJVlH=
z(oCcbJ)50M*kA(b(MMxpiOrx`s`w4q0YbYYXLWG`1=i%0i2G^By#^7DG4n-a7@Hlo
zHX^I&x$^gSP_|=jJmDmIuXHnk`r}dSXPNM>1IQY%b&m>W5%A2GjL&*}TjJmyPGevE
zW(<j~_G2W>)iE{YpCln4dQod58iz-&jN!h8^>e`4b?6v}={?S_tTO_u8?7nL)yz9}
z2AJd3aOTf-AzgCpkiP&d53RPvn)|MVslB~9Ns?`MyNxk`96Gg7A|GFNdO?HV@AR^K
zH$_I_6XM_c%AHK%O7`H$_-7*HJHrj{J7=L=_d>+_x6UgC5Y(M#>V~lk3j>Iy<a?an
z9geRrJnA(AET6qHGNLC;9+C0yhsPJ9CWEN;%dYZpCRdK^;$-|TT!)p(1Hq-LZ|{x>
z74Pki_%e}EU0Ugx+?C-G+nr3`mErN3$oO=)VN>KR2n)LF14F=JG2(6?Joy->5oxdO
z-KKf8J>1*FM4*_D_UHli=ssuHVQ0jSQjczOGI{!OYt(%$Z2I;!uRe6=k4=_9VLQD?
zbC2?(uI=s3pEV$l77~IFmU<VKp?LN+M`Iq|;vr%^yk8xbd8;luqBq+3{z^vaU|nPc
zsu^3cIZZna)UrzmV`lIkG^KT!!6SL@kz#>%FT&`|Ky$42OCW{0CecITboU<3k1f$R
z$%`Bxi}hpbgE8u>078KdMSbv9`+BK97@`6DG*F*sz53ifP@ki!kI0Qn^?G}eeCKP;
z`4#&>wO?aO8{+3`YUtrDJy;J5yvA$uHm9*`Wp@;hx~BMNsm!Km!)7xGZ<}!yZc<$Y
z01xElx8%maW|_i{s<8g{dFAc<*z#z?)?#_ih~uU_6&9wggA4OqArwop+I|5G7je&b
zI%gPhcJ7~suyo>|ttYw@9j9at4`Yw4`0dR?YfewNa_WV#Z}E^gaAl&e!D|0|I!D$C
zZC!eR8ezCG!n*Tm^Tr`3aeS0@r;g{%P-Wi6TX#Na-fHw_TM6Avk^kvjzWOhiaOI?J
zQ_I1-P5DzI;`x;_xVW{H@3NbkH+Xq2`)Vn_Weae$tDJtAhHq0_@=Yn+FWDStxJusG
zWhdUX9<2%1Z!@HF*MajSkF{HR>TK)ruEfDBK@<C>%jRP}QAOWb(=(FnqrIG}DsRmc
z3a6Cy?ir6g{9x)igx|#gxyRjY)%Rq-F_or#E^YlF2nE8g-qtb~tPEk~v>q>8&9{V3
znQlkxp|Tdvrd86t!*;%}j9Oa>X$&>n8@yWMd#J~vN?o?mmjE^cWp?);i2}pWyBD4M
z`-H3gB)Yg<17&z$s~dUuNbkO&Z>y1QHoV)o-HL3dIKKGGjs~r#w{u=i9JG)J+jw*T
zQ3uNl)BOUcahYhyW6e)G?98E&p%L4;PVTUGWo=F^sz!GX^yTg6m9-QKBX%@fo6}|a
zW;>HTm0I2NP3rLEr&TpoWX&iOt6B~AB2ME*$o9RvMo`XcMrYm}=|jG}xu+~&=f1n^
zK>l<)b8zINzF>VuV?$knBf3U(5aWo%)myQV)@{Vl;{oS4=BK)PjOpq%Y17kqC8MXy
zTJEqCA5b5!c|5ep0FfOba~Pc$?bgf-_3#0jH$o}Od?9Ok2TpItJ$X`}X~_097h4M|
z#&GVnuBkYOA6&$kuHSyggeTF}G2OoX_KBDf-I7_dNrFP(&NX9bqjhg9d1MZq>7y05
zfFSL5?>a!E<Xm#eCOMVt-5d0Ec!Si<NZ3|n+f#L<Ichz<!wk{6P=?0s$PF^g);my2
zQMNznAkPsUyAES3*nQaU?Y75vtMqNn*8b|RT*bn$_E#)5zj<oJK%Uv(tz;5}^p`4O
z`mfn^p!ABlPgs-osQ+Z<144z?<N9kQ&gE-Z(hmJ=VT*zzgz3=s9}zE*$z4uArs>Bj
zuD@{Bn4uFt{p3j!d!2Y`Grf3nzAAT3#c(R89>AJ#U$HaST!N@^G8dt`)1Z5b{dl42
z$DdLRDxs4ddXmp{<&)3$_xu^nVbk+a+Fb`Cw9Lz3aL>|%k?r=A0kSz7v7YWSeS0Ok
zI%f8V4NwHfg|f)_F76Px7EnJ&t-0Od5gp-OhuOe=;qJpu@6O2hoyvZ@dV0KR%>If7
z^Q)d#3rtT_5vM;>hy8p+cVxsir6kr60%G{RRpP^M#hf2?(9rz`u{Sp{=yn;b&}pI@
z%fAGBy3W}^1N5&&tCir`g>VY(+g2^HpE}8Fs9}4sv3t$;=;_~J<U&V3#}A8U6=!N?
zYyDd{ZrI0+hB4S{CyrkEJB=T_+>ykwD-&A-uy(c;I_kj{+YRrU%y0XtR!r}{ko%0?
zyFb{tcTI?Pa+Y71jyAx?gu1NyP`X%1h^W5pYn+gTW5#MAb5K!t!02%L-$T?L#i;gg
zfsQYP8lEA`+kyB2Shq8zEx(LNj}#+?t)K0H4`da<O-A4(BfxkgPUs1bK(hjK@p>t;
zn)U^K9$|0jvKu=X?+$Oc!wh$e(muTt7L?{~_j5h5$!>Z54u&~+#a<RyM`^H_%;Pf%
zC8$0mP(tpB;SpURV_3gp9%LtNdkB2o&<-FXIRSSdGw6o-{pEI_)13?V?hKFT{ww+r
zhrtJ}`sjm<!sp<&tp(Lz)Xz2a6Fjr2t0oB-@1||)%%SZYQX5SjV8xsf>c1@QJy6WU
zn?|0zEuaY$K%Hr;+XJB}+%avRwJo}G=~3(Yt|L}W#WBPpN382IN32B^N6d5S_hQ`K
z)|~Ta@B1FU@8!MrP49gN@4Jpzqed&vKEj|B`&L|_T;AXfRx5wmG)lW;#hjzo;xwg^
z+bDL;-2DtAk!ycNH0!P(@TNpRH;HiDTT{E5M{1-Jw)0yNGw+M2;i&Tb61a5K57<}E
z#A;gG3Pd7v@XQ87I*Y}G204R}SAx{S9`7zMy9doe$_VweA6qq?3{S~dS=Uw^5(Pi~
zlwN`526Pi)I?(Gs?;y<jTmu6IAC|3C@xa>AIQHf5ebWl8ypE2w%BH<Pegx8($7m5B
zR_`qjSa*K_ZG>sF?pX<|qIMQcV`{2@j*Pq6s#hbsy>49G!Lu6KRB5=7-1j8`Z|$2p
zV_abQH9TzmYi+;+#-W(~=z!Ix7n40c7EJavWJ~+1_4~=$lW|#2c<JQ&{`f{XEY(x#
z9Ix-08H=ieUcVQAFQ#fWwE^!tRbE8ZYtFgCd*4f0hmKf_UnlI6iwR?Z-(FG8EKo+5
z5s<GX=)ALdT5%Elf`Z4Gv^BMF)BB9G@}vuD&UwRoSDvsD^@J_nq_Ni+Xg4WtKTLr!
z;u;#Z+4yR<?!6L;8_6r4^O9$ZRXU(7GsP^)>P7xj^~L-6zWI}~hEOE>K5wmk%j=d3
zcOXyFUsv5~-c3GgHf1b+wpdj&O?lp%`;XG#{D-O8qKY4yR5jK5CB`R=y#$BGeXALq
zvjUhY5kf1ff5FyB>1J?#Zk`uad%xb`{M7s2KREy7y$>0j`v^0G^UdPm{38MRWt3G`
z)^i7F>!!tv)9P?D7g@1KDBsMo*~NzZz+_xgt=~^>h?w)7z%4ZL=MuGl<Ui%5uRX%{
zIC$g_d+-0%$hRJUm$|!qzDD~sFUgS6-c`(oQTd;a_7zAS633@ncbz5Cxm90^EV_0T
zqV~=6L<=MqFk*47ac6vwQ)G2+upzu=-)^?v>^f?_xsCG7B6*#im1e=&y}5^QT!N2z
zrr8=5g@$S-U&o9d70TLAs)L#Z*yG6`?38_yCPlXF0WXC5e6A~A{{6$6=1{uBQlOIs
z1LK2;D7r^PEjz-D7Uawf&ue@l>r==i)W^fj%G?(rQ>?3sfa#K&>U*f#CyyAB3psx=
z$zMz>YO3}7$w}zBLav*?D&=2`N%Z^4NjO9na{pXRGPjsSzn`3h8>vF>TV|Bb2=&ot
z75A}k(x=eu+|`7OU=NY!x4ylIInuAsVKr<_GkJqn!()$lzrT8rUk-l_KU?Po{J6#Y
zU4N_ho4Ub^fPFd-WDw9h8BEl7BtP!@19ZRRrp6M0MrFVhSaG|#W4rhsI~DjVdbjl^
zcE|mHm;S|t9KJG{+_{;)(Y~%!)fR?}6CNIYecg%7UxU`~x7nHFmhH;`%K)1ZwB~FJ
zrl!l>;NXl@)gKjoCh^5ciRa3P5K_6n>Z20YJ$v~Wa$gTMY-&nPy$I0rII3O-KdxP<
zt~pIwY$f49e%3>Rko%V1@ETrR%Wd}qJMqTJaPKRVfX=$)1?~>==NkFN5w7fqV?lwC
zYHJO8JSP=B-1uJXa!p$PqqetyRdvwa!y}O|jI@_2%^b9l-Y=|9%N5GCX?+N`m*pRI
zdcm4EwT&cA9aOv61m#g1Lg<#7rh6!*XtFN!|0ItydY(aC|I35XrSgPsdJ-HsuTPs&
z{?UnambV&um?Hr$_$u|(zF&BnoYm*P1Rn-s5(@9AMGYed4OArMjGcoL+Jj7~u<tOS
zNf<eQ5bj0G(|lLs+mwNpQt-I|%1ih^>EKeN8-WPHs@9}qU^^~bj2v)4JiCr%H#bXj
zud6!3<F!4kh%UV@IKpDoE?+aZPw$Z<`UGoJbBbPrN3y)a{&m*T$seGk6n~7qGT4>3
zQAsB?wTE|v<^yGU<AZ5gRiRYiqD(l^3ER09-JQPp>$xv0sn=<AQ}3Q|@qo~CrITE*
zE^9qe&a$HaqzSzI%;pei49sHnQDUR|dhG4v^YsXxCP$DMHe{M398rcwSUm!X!J3Mr
z5w5)2%SbYj{^@M@^K>asu&&(S=!B~2mN|Gvu|5@9h}pC<N?&FfX%$8I(#oF-m|<=(
zxiy%a?AC3C!j-JJ)Z0`v=pIYFsj<{p8;PE$+U}%eSlO<*jl;0STOT;Rui@mlrg{aH
z(?e~%_;Ai@9%${gZz%YZW(8X{)4ovreEGEE!?cTe$d4K5bmOhVbX~}On@L&|{9`~q
z1`PPTo%pLSj-QT$!hG9|5L<GXoR)aMJT&MYOdLGvq(WD4v2Xy1lvU4Ge%%Xf6Wh%8
zfv(IbGgFuqFPP0FXkDymY#7&d5)C%`%`Qv;jd276Ut?=#Wi$m8zncbKj5NHhT{t&%
z4l6f<8`w<zM^ua<RLx?OKU^;F-O6G&dF|-WVjWo!5P9wjzGt%U;M$po9!1P#ZG=>M
zqGF4-Dhb^8z#dqfK5OR43^$ncsvC4Wk}1uRT_<c`_pU>B15#%1QxXda7VNG*Souiu
z#~wLduL0($c;Ba}NG{Ev#70e9D6RQqwY|X$l+w07x22fMy7PYGv3sIF#kg#QAa8Bw
zY6C@gJXbP8R@+-7D(<&I_mIT@+nA<#?({h#qcycQrM~k{3!L^?{Q{1$+N5+(Q;ZW5
zTk7Eunr)c0iq;ryt!beKy8cHdf=-Xb^>Q+C+jhntv_*pzH@==C?MGOwo)i0@=dZJW
zjV}I&Qdn&|-sHQ~i|DXvKr+YAEH+h#Xi+0IR;b)RGVLriv%QX#lt3{W^3Nr`dKuVD
zR6)|Q)4a+E`(}gszM)%9R}nP2IDXcBzv7d*FKXGSUPL|y0WiHE`#k+#{|u9^3%eL!
z><mp34aH{cdx`q}&*tvphdHvCsZpPieRA>hEreS?xQV~PDc<IF?@sb|Q!2vD({Ab@
zk2i_qmDZh}JTsN0YEm`<LP4L9E~MI92%DSoKL{QVo2ckA9j|@K)0a3p-TKagbv^nS
zw@#X?XCq(Q#KTTKY=@}#MH{>0dw8Law`Ts_Y~|r2Z|z#hgMt0&g6IdaGFREfb`QE!
z4xZZ9zE+=fuh6*Tj&~T^q-llKZqXKKrD}+`GOs=ydlFBZK87y|7h>;7<oSnuU1`6O
zIwoXg6l6vA%3+M868AtUY2xJY(wETIohk_wo+B>A-bkC{bT-N#m?T>sWJ6khj@Jii
zaf9vm(5XZ41aWLr-1TzBc-X3oU>4T{gH<ytOQzRViKNtA<?Ud+FUWX1m?HEkLL}pD
zVFZ-xJ(w|j7+qS2f*vZto$*J*9H*&An}iOLh7MY>iD^GTPS=sJrb-kr^3sFQ5%#YP
zOQNHILMQvzpT+H!=9rm;{ZlOdIV+iliv(`;5npMt-g`A6b}9-`kM@c2-i*&pBh-B+
zD1Cb4SvPw=?q1-nE9T5V{FU4&rfvDyBhc9<x9w+I0C>11u1HPZVPmL1hlo^?ieAj@
zD3WT<fVC!^E#A6#Ta&xiOUt+^A47k=tqhqjt|#{98>LoTEU=jWKwp^sJkf!X-vLDv
za&h8mv*OEQS=)UUf$6!eCnWgBuc{cnko&@lDVW1mtPEidqoH<p^zLar;nS8r5M`pa
z@6v&Vou6G?g2w#yMq)a^5fo*o`6fX!wVrs6S-0#9Pl`Wi=;pp7(gjgCemTl%Et!Jn
zmss{!x+|2ZOXANR&UjBe8*=|F;(N~`btUMh@r%SA!qTlZ#(AbEWe5M40FM>vAc_j9
zIR%o$t^8~}0Pqx>Zu&#%NM=@yHvpp|&nZ=B>5Eoh|CcND1(JFax>1OCpq}s-hkkK<
zIg}^Tu$HJQ<_Fu?n?>NNZll_sJ3!QE%8~61PC(O9x68VBJz*g?r+uOE8DyM6E3#kg
z>ef)|YUud>STyMF=H^!<2UJipsu{D7zt=6;+ozY{zDnkGw?h2L&K99Azp0#Aj4H&d
zaUjGx*pI$15`TtiueT`od*Mq7R~}XSqQ3u+y>|hRtGw>LXKcyV;LDa1uq`051R;@V
znp(jmb`v6vnISV|21ttoX+xSesnbgwh%MQqjja)qfT=1<XwuN@M;kaz`y~%{z82dg
zgxO<aMsjOrq{c|r0ZVoR8V?28=IG|uI=}zB_a2RG2}pW!zH^?ZdLBtL`|@7byWX|_
z>+&8@39%RG`t5f9Ms9F|R?`&>6#1p3f*@$$eO)M-AJ2{1i<>tvhnRv-6@G~)pfvXh
z>;6ABk2+70=9F)$F)tqwy;9g2?AqjSJHFU`|3RwzLo+Un3FDHUZYHJne=OdLUmRBY
zHH<v>`xztiA?tm}cpp;U2ho{%Mi8#~@GbAdBYe=1H-A^FTe%g<Pgz?&yiwZSZODzs
z;Y2HVsj_3pyz?m@`ZwzVB?vTmbr#d4ifxwT_Q#Igl>ZvHNRm1MKF4lQbcoxm{<QyS
z#FWB^QSZZq_rb?Nm}e@y50&1B)!v6{J}?v&Q4)|oZipY-<5l9ULlhJB=d}TO`a{sV
zy)0)QVw-`mdz&igRCyVlQ?D8;@{jP6nS^`!0Q2&<4Kw^g1VXfBBMtr^L)<|D6Jbs_
zzhWlfQ+)T+A9LSKfca!*z<e@OU_PaI+j-7Rg1Kg9!F)2)U_L$K)H2ch_nHIK%sYbO
zdn*>S4J{@_c`f|Vsx>-r$f`9eG5?K@%zsyBu61?jT34s8HA*)3U8TF$DB(EXOE;h8
z>SgqI>~%<q%zu_?5TetMd?B1}i2p!~2F*d{xE&kIZH)8#dH_hS7c7{XWtj5k$gKP=
zDITfd`b<;JX6qIm`qL1p7ku~;3E|@dP67(Q_#wy2R{mH=<F>x?AmdO18pMSdD4X)m
zAxyYgt9Fvkq((OWjRpg^_S($Ik?%r@e6VT{^1XZHAm91Q=hVoP&b^dX`>eV5_a*nv
z{WZ_kg&)D^h~MzHA|~dL#oZFAA>($2?bB1)rdy&_*{yFU6Q%4C0UL#?BA1xNUxY^O
zrhwhbzmJpPrhSq6ED-faB5mD%m_25JRHW@Fg3~72*GxMO@{exp9HPnLQU1hzOow`H
za)Wbj-y049$^YFUXi)RrA?U;XqjU%k@ZB4Nz0SSj5d3Y)y|a(}=ZD~zoFO1hP-lFf
zhRq&XD|8;~RnX52eLV%6H7e+OyXmS(eMZAW!kS23I?^_vwd|L<%9v}Cac`88r{)|d
z4bG?U$ba@<4d5jEax!C&RMz*(KJ52d52dY*HYX8w-B{_^C@R`|Dy|b>u{P#7vos}J
zMZPT5bt9O|L?u_SK5on;d+d`7g#MAGlkYYUOLOL&KfCW_U8XMU7$j658VN!$Cx<}W
z<h{<>L*;lMS4WdsIu1yasf@HvsV$tWf@x|asEBC3qU)9kf;!X^ZeXO^h-;0;%Cv<I
zvyx|RwTBd$6mMD+#WRj4vuaX(H>nQPAohH(MY4~Wj7Al><=_~wFTwCQmQ>EV%_!gv
zA1{6(=M?tE49!fF@x40U^~oXp^kab|JU4*Zj+TZn7iMv)O0A8_Ehb+X@A}xNnoOHH
zrZUp@qL1UR578cq+SsGk^YHp;vWF5YC~+cU23nqR&a)J}F~u)7vK$55A67B;t7XBi
z-~V^IRw@6fwth^U8_)7faT`zL#;<mM1Q%5~XLWs4vP4-lc{<7>(g^W;m?LY9Ssqt7
zys+>?!FGrNur4!}3lmJ&HyjSwoQ_a5BN<zg$KTj3KI_tqJYv3<#u{!2#^2TxaA~GJ
zWrd-ZaH{LZG8s6a7<4QP^JJLu><TUjIRrCiFXU~^mbqkZJV(ZAf5!S|4_zWCv6`tk
z&zx-R`6i2D2RB_ZGEoj9rLap%NZ^?jE;(%`Xpb6V%pe}_4rNrJJ!)EI>ooaWGK>#-
z{PQFtwRo~e_I;qw1u-48mS4aDk_%}fZX@CDWY2hS+i|}?Ykf24G_$d^nWAs^JPM_G
zg4?yrmlx7{GRS|&jS)&otL+dBzjo9Re~wwRp{`z0R|f<V&d`)zelreLW!6TzNKWaj
z5@D<Au)Gg>)W!>!REB(fG`-#|(292GCfwr|lMQx#ybJ=$eHh8i;v%($d%8A~C|xUP
z0UhLNpaXk6M~P-0g4Q=PP7f0^Jyidg|KIwV%|C~%2HP^{Ac9a;>W%|mT$D$EW_%&K
z_WL!e4jcLZbN<nXXEkz;`A?~(|M$-S>>jFr&fMcR08g&BwT{c`$;fQ&|C8TV^biZf
zdWfkrQ)b2^sST@I`<7wkm6Bo1wTgOEN?E<#Hf%lVy$(O}UU$}eXAqa;fO$)dy}CY)
zQ)|W)2)(b3@ZI<)R@7(B-ZX!4ro3b(H*(b`e(G#|P_E&JHQqX`4}Pw&q4+abS^WHV
z%FmBIvU-LKdHu<aM4nU;`a#x-)a4@kRDga&mRzFHNKHmbG)=F|BDjb=sbcjLsp*OA
zQ|bD_k&?$p)>DlszjKB1CvZ+lBsUV>=Tx$3lX050XQ~l%s^Rc!9B}#PM_m%L!t=j7
zy5Fh9vSKye(I=fs{C@l=*>>~nH+|7uAzpJJR)-^LHd=#&?Md32j``hzq^()`3c2m_
z&$tDueO5QarW%M}q{7x=eGXhOmR)77a#mCG-SO@!i_DCqv!YFZEzW@#iIkO&56ZY)
zOUsZIXZl<^w76)MeKoS*8y>M+29=3n(7VcRacXkLlMD&Lil_x6l^`*znq0I7v4ddG
zKqj)^nZIkUiQ`Me$iWz+H5o9g`)6h$p6rPu+vf7|8k;*Gk61_{k_gJ=9#ezlI#d=5
zFz2Q<l;AYyL5Kj~8=A*7(!7Xd_KflD+H8Gc#%oILMQtw*xM@Fw<6Uw4qqA-z44Y-V
z!OS0YjgoRo`6Wi5zrd@`2EqJ+ZI-il7keZ1$tpD8110s5i$IAr2x%t6bF?ZKwEluH
z?o<T%;V)7ll!qUr&MTa1^ghLZBXzlN-utS5z6UO>pDMLkSK-0*kWFJEv?MWrsqBKj
zsh4^`nQ5D{b}dO9x8$G*P+o@?d$l8|AmiFND)tQr`-bp^9XskgH4+N2+wbkRhbjZb
zxtJ*r(N0Ca-Flk%Ecx+R&TA8eD=3;%BcCSdIiqqX#s(6@7UfeowNq{;NTGbA26w%~
za-8xk++^MQL5~aXcFNl8l{NAvWqIvG{vcRq*G0x*Pz7Bjc0ysRkYN>OFob|Nc2u`V
zVu4Iy5tm^$BF2<MmNS&(jDL_AriNY1B?9BXuNNl@?;^!PNttvMuRxWaFD+A=sR{<1
zHq=>Ko@pRycT(q<MMvLCS;hWpg4gT{Xm(ZF8k%(l5dyGA`8jDChL{2M*i3-&LpP)E
z(1#-fRjZ8UMpm6%W2TPt2a_4fs^Ow8OpXmul2b^Ef(ibv#zUO$&TuvLucSP>h;y-w
zGgr(mD_>fc3ZlI8%kuh{%#8PYHJI^(A9z>vy*`ER@^dR9mjx>{ea3~fINr1418e0-
zSFID0m15+R1n_PpQ_c%f`#&1u$=9Ryzc)mZ{jqv1(vz|Je5@`Xs~U-Q{vtUA<MqRw
z1{bd%iq{RrtA<MwQKm<}fwL;K5lQCa^{>Qu&^#5Z8dh_<4PCL7JV$tabo^y}^+{}X
zI^yq%)IA%i>Jwo^k{^jAKP_(+C1aV1)Mb85`%B_?HuP+_z&4u}#*-XPl|Krk13S<W
z1PBI>7*K6>j3aY}F?qGU7i}?UJvG@jzNYC?()MYg6Ly2WU!;)Ll@p|92qn8&gPhq#
z^uwtnAjn=lf;NiZ!eD6<9zZOA4=DDu&$r{9t-$;IF9efgA?tAh8J-W?FINTw&xSXg
z+wmj(lKGs*aBn?s2W40@r4w9Ig6Cm&QF+o3x4q*!Q`{>`sW($xIB-nG9Z_-Nz)|jG
z@Pk#uPuee4`VTtCFm@;)KYtB>o@}7+KhPiRsnNDEV*a1%Z9Batd8(GRIcy@8Y=Rm#
z9I-m&Csp68ly1MPw{=>uX=HGmG<{~waAA%l5Bvlp$9PQ^NA65v**xQQCTu-^Ou6>#
ze`SoG2@|U_-+1B73Qc0eHh7|vVHO8$O|TV^pBc!9l7o!0S7JEudWaJHoFO|+U584B
zEaZPt96&_0NZ~2T3XCOzO#Y7;G9BZCHFai&L|Eg!CIk}2`y2sKhog08VkqdjSE0C%
zDEKPeb@3m>lE;X<iulJ_Ifxhyp#Z`QF;_L?L|aKl1Ee|Eyr=8pfKKXl0<2<wS0HW(
zAeT*0c7~`Zh}k9YWTqq%O3Z*C_k3uDPkJjE*Df+(B#%Vv4@YUCU_mQ#C^CMOf8?b~
zjqJk&600AL)sX|@@rek*TLiqdc?S{B;jis*3FRWHKder}x?ngFD@uEb?b4^L3jQ@2
zYU)QL6wJysE~ny0QsL^^<|fvNb6F9X=lFmX>CxKaXva`pQM#u;27keX`!)Q$4cJ+c
z!uudG;cu!7ey@a-ap7J=G=to_*93{IuH!_$sWm&wninMvOcCtbNY0dOa14#UJNX=%
zENeY!_q~>!3}LC@EcjI6j<zB4dX*f(OTHWH(Qe*56!ss&Eh!>2U_2Z2XTvDtesv*O
zlMP`zu^t`34F?bLzM#L4BwXzIYl8M!Zuf=i21p0e{ExDEG!sTkfhuY|=SMT5ty!|F
zL_8!#<3khf$X^NNYChfZVxPdyZL{+@L*~W~Sdm`5_&I@#@vO5U<V?`tje*?T4xD&&
zZ@%W8EDi)7`7TV$WN(`_Vfg1uKvL>5cLspT!WFjF(amz0YX)%a(+r#n*D)89YpnYo
z(Ymp%b^(j<(Xkv`nReW+C?l4JO}XPgSombyFymj6(1-jvC~*D|49|b?qg`d!lMcrn
zV(Za<#@`IE=GuDnG>;t_KjP;|=`%sQu*N>OrsfF8G-51k-VZ|KZ(eB%Q!%8gAxMQV
zm^Bo5eb>_K(R}JMB2eW+07v=4yVjEMbYkQ$C(WSfO#8KFOr80l3%$Ymo}fK7Gaoc;
zFl0rJYCg_{>Y<9PcyS2V-DE|{e2^ajh(zOQ8;VZjZeP*k<k>K6`DuqYPq8IgPn{Bn
z=G67N(;{c<J{|Ie{NFBS1TS`|`H&&zVAqWd=%98k(n*xnj}>lWJV{zu+)l7(L4Fwq
z>ba2rIo$1TBB_%`%zE^c-;7t?DAAz)<g???`=3vqvtM0fPp_$YzHUN;_>2fRlpJV&
zn<+%Ek7xa)S6h=jh@;v~*5lba21eoS#qJvV75>t6B}<3;S$sjzBO-qY+6nnH!Q6<y
zw{4Pg?HwmH{>mSL$^l0~I&(0(YQn=Z{Pr?gkT?+wdo{zA$!G1?z?UC?KI}irzCt8T
zA6GRsoIuTkJz@WVqBiUk>><3t2F}Al9`*yM9<SzXPBw)U3b+Cf1N||7c2?UBKXu#F
ziHgX{gem+I<K`sLev%I<<kMs)daasR&*$TmthmdQ2vCO<RLaEzaX)AL9UuV_afoNo
z7^~s2$G9Q=?D35i;_-gfEaxy!<->pD3%1h~$3NepNb>3<klk3p@s@_`vQUM3oQl+)
zid2o_r>7kyT0g0zaP<?>x`}Aj<SaSNA~-)%KOU){iqymBCn8l-s<TIbQbx{#%u8oa
z{Ks1lXbrK>kJA8hm(hlqMB_GR<&OMA8jphu$};wrwpSu1JVSefDL{!t%w`#>KV8xT
z4$Nj+rW)e)xfrKb*JtB(*?3hBU$W5%$+xRVZlMl1)P%N_&iH7t=c?D({Ebk{QjN?I
zpxWQ)R6o1@T@;{H9MZdK|La6Jy1_J!Gt}$wUzg=}r0!loVwEK#i{g*?fw%odY+$_e
zo-y}@Ps!vkg>{ZGV9s&^gsQT4SI%zx1;v~7Gd^%vnOM52Hsx`loJw^?--!<NZ?>As
zZ@Ekc<>ymIOl%_msb8VQ{gKN)Zsh)%X)dWo?{}45RBzX(J96i>U7aksU*l|7m8HXD
z?kBO{)c4fea}}WXz56ve{DMoFp<BMjuPz&@?-7D`ULksa)_s9K`G#UC=Kg29NrA?4
zvXz+wPr#CCa_(~jH2v{R<g<$9#@XZRIINhCnEMQXss<(mAhJ(Vda;w{zFBt{8E|7E
zS^RU66+E0#g9YQ6=N+U5Lc}kt6lQVWCjkw3otDkdEdZjzq!Pv01fACil2dP-C1@7V
z1@8x+h1m<u2IhI3(5?p=rEcqC8xhWWFx{R*cxmr$TFhez=)PIgGh083Ily70^HS+`
z@#J$RWZ!!Htjt8?C$uWH8W84AfB}lL`N!ic&bsvzAMfgbsA$J|B|82R&=zm0n5cg$
zw&JBoa$HO(=6^A^f~aZ?yst+5qmdO;FwLlawjox3G+KWk8tB7jNwl5yaC#=FGG2cw
z8c;Zz9cu4sF2jM(>yoobKnbvk8^(wRXmU?D^htzq3JJpr2~761rsZ|Zc7fV-H;zx7
z&z-Z6FXOV$x4v*A-?%|g?$#x`+M_Vp!a9Xl|GdJaoq*%E)MdC+uL*WVmh~NPJ<T&d
zV3}1oHzw92?ge^?jqbgQt3Dw>MDQqN(_1fZ(w>#zMgW&rdp<_K26WxRrkQpvi_ofn
zC)bR9{OZDWYS{<oYT4BU26}E!_$k%ro>at0s1A}OQnaLrY;S8LG!p76k*w8PjbGa<
zmEw<;Z_?`3POIPTwHik&e-F6DmuA{+nRZY6ssG*FxlJv<X|9%U2Jj&I4;RQ@CAlz>
zjj}}bMvYgyl-)RsD@l)#g`6I(jRkrOW%b?eu)BT2_zxQ|#z7XBt<yR6Px31(hi3fH
zMq-+mO5TBhf#i&ue-USLQf;)gTXY2Wa&6&vbu)+oTx7GN<j&^((=CO#I(q$P>nS4^
zww<;(><scb4*A@8t+EgHorwGZ;?qwe7I;yZPo8Le|9+=?xlo`RYiyz1xanfpS9G~r
z6JRk`Y)(chO7}DI`&}s$<=BOhD={s*ysu^3CBm+U-%*T_U61oeA$A>4v}}Fb?0cgv
zg|+CAjU)wVJGG|k<Li_7yj=pM)^@z1l%ni?txy!KSq^rAjCBh_86GBXM3C%Sg+g(p
zoe!n-G*>HE0R!1XRbDL#sE90dg)cbmJnt@UA_3jKiN@YQb`)TWw)A=$nZ#`TNz^2W
zC`Gd&Cx?h+6}3H%A|kT)w=$LNwS?gkfeZnq>btF5=n*|dtLEq%JR`g?TFA%nYsiK3
zFf(2N<g8(?f`;t;s#ZH;Xap~$1T->KTlky_FJrKwkK$EBA2;GN+tdhRl1=6q?@(8C
zJ)s<l?&>HW;v`;(e$S8wCB*}M1`s5a+;3Wr_5c;c!8Z(Xq^w(DWtKu>IcO__T2V6I
zCUVdX;*x_6_6n!mQ8IMMu5oSaq`WJ)T?&_HKtAkPRNT5hOl)~!r@2G$p^19mI@g1m
zlXT%$B%P*@k@$u<;8P8uu3&S*u4gq{kEP+8L>6~5EzAifXdE%Zw$~JVHsDkK4;NRp
znFQNe*tjr>IGC91yzAPVA3EC|Ep`?wj90_xv_h?CI*Tl>uj^WEAGI=5OFa6}aNC71
zc=w$yue#s~Gle$@bNMil;<OBJw^N{@X=X3f^~q);Yg$T+#8ClH2{VIEKL?mWcWu){
zZ~n}>E}g$f=L+Nu%nh4^+R5<l;?!1rd(zN(u%gGzWz(<A=)ml>aFFGtMmrj+M*^|D
z-fMPpg%9!O-K)3;A90+mBs2lE9Ir22j>DCE*;uwl%w=bN*pz5CHHW)m4%70O#a%W2
z@Sk)tM<em$>S~2-pADIR`^aU!txgb$J+ch2y4=@D1kUjE8k6^<(&yWLb+9Yp=VJcv
zpgQrbM9cQ8?EEqwLUe)Q?vi$!@8qu4ArB6S$sh8k3SZg0&-WGjJ>Bxr9e1((_I-()
zb(yw_Rohw8g*yZ(DO|Y)uShLEU&6Ko)#Iq5Tm~RVUr*~R&c`Vlr)OzZIKW#Iep<Gb
zvtnhPA_)iXI9zDH2%QtV!4M87Xp^lbQ;D1Lqg28&;{h=iL+G{gu=UbBenwL;Vb8;@
z^697&gr&B9&?OfGP0PLFYHzTjj(;4BG+NUW2g-iGH()lU6-y<Jl)b%<DZTo<f%|iw
zvO46_>keE#srMj%XZ)6z0fv5gpX3A$-a0dQzwNCf%OK@7cAPdd77U^6oMs43W&{l(
zr0vq0TJPj|pfrq~O1n*0;sH)??cVN<=hD)Fgi_a@H<E8Men_A*<G0TpzbhpP+avEV
z6u2g0_P@&Q>&hXaMpX1XBHejo^#O*!Jl-H8^QBrK()>4hEYy|YZ=+L$)gd22rab6R
z<&FOk0~cf}6J%3S@cE8y&W4y_NiupnK6l~B83+G_J&kX*lLZXM;Se8&FI}YFTHn*t
zYcx`=lQg<=D-np$-X)SS_}aV_dT<Dz?l5T83>vKnDI1KEf0XRG8b3}kLAmgIvdxT>
zWvnJ0>PlKE@&|N%_0-d7=-~~yZSVKERV6|*DQBqQT9@!x6!DrYS(CSaFpz7t{f#Wu
zZ&9@?{)p`$p1XW0*xu80CH=WpOOA!h##q?Z^@l68>YJO9zvTv%EBx-}{l2fzv*ldg
z@o7HnX<!dRk}G_C&)QnC95Ybe&OpicuDD=OdBnI%T89li9$;mpMPS{yXcr8D!E*tX
z3SWhJk(UQc_cOMu2Wfm58x7HX<J01dPwRQ(lc3)kA2LCotaZnSOS8rY(lPGM^Nvq7
z<5O!`QmRGcvt8rETg_XX!C`EmE(T>+BcpRW5O3>bkn!2d${XXHw0XuRK^e~2l(cMS
zY|1q-OPT{Z2i@=QN#+bwH@4~-O~sSf-gJDXL5-jv|My+`S?AG@uh9`C)-gg$*muNL
z$#)}%Mi$HV^>~`di$4E1w6?fyNx$<pHVEiF4A2s9_nK&lu~ly8J#k^mX#O2K5P^t(
zqjmD!^_02PdlV7&rq)UOLoO+8oM*V4L0Zy!Tn&pM@DV*ixm$JW543|Ks9MUBJ%v9p
zW8`jpGpdq<zj+!`OL&wFHK0$MCcGpiv-rJb_`TVxeZEuh`|j9=%r+cq@D<6w+aV%m
zSKQq>rNHS<wVBRLtSY;0eXy(5EIVadcAs%K6KWzQ;Rjg|?>>+15A!~tzu9l2^*!-G
z*6R3Yt_f)cW6j$t-_EafH-Sc`<345C+9&-(8^K-MIqxC=XI%0af!f&XO*E2pAZNCN
z9?~18g=hAis2@YV!@aN%$G{isrx9Hnt*<{z&UNcMu)h4abWd)Thn<m9w}Cr^F4!aQ
zjs`faV8ZWIP_25wRjYc6+wj|BXo!K#8*Ux|eU-DpN=UkNzU0;ZhSSwjI$f>abp4#O
zy;K=4?bj9vSgkqr<5aTk7u{{f&Ijh1p<iUE&C4^JO?Upk^L|K*1dFEilqn2_szb4}
zX2Y@bQhhZ^s>*CQjhd!Mxw_BjFl;*A%#?NCSGnY+Y|=F4O0?!ckJ)>0`+N+op>&!K
zdDC>LI888@lV+O8Dil5vM{cFzLDmY1;oJ!lF!T=U^J|M@#jK7B4DtCPG3`>4j|AdN
z#GcuuKxw{+<M|x3GuQl}z|XgwrVo^C|Nig0+y93>Imp+D$7**OXOH<kvYoc#H9a2L
z`YI$s-N5|{$uoJGvkkh{@0H*zscTI!UjB>4K2#@f3z}#l(NbQyTdj`g_{)N#75QiQ
zsJU{vlI1-<+F~TzeG>egbyb0=ke5K_wNNwG>pic9l{GV#X2!5A2rGDlg(dOJ%$Qt%
z55}?OlzGjb#+NS>3BZ@=rG5zJ&um?!ju%#YT+>`^4mjckhjV%3;7iE65AgzsX!gv3
zpUfPvn6c{OL$S_H{KoNbgiiF+BC!Uk0q<cef(;5iJ4#5rr`1lk$PK>g#m&L*O}A|O
z0{nh$^n1>mbid|k^m|T&`NCNeOQOk>-jO6;3Fc1oyTr|6U7I+@Wl%eW_0R!+7hw2F
zh5h{)SQ=u10RUV)pK;y}^>C^L&CObSH@zsCleozMkY)u(b#dxJF^`^+Kdm2TCE}3s
zZ{#9&>9*lDCY9py?YDFVhubDz+hOq?8}!4ea`l%)c3G34Z<%(F&25ua+g9uekhc#{
zE{egpIa0Vt9}@Or44sVjct5WPt>^{to59aP-m+|vX=*o>Q{wU+s5K<oqke)YUfY2(
z=L{JX+ZFU1r}Zdafv(=O5MGZE=C!7BPrx)rV`Cbl4+;A{2wKjT!uwIDHE#b?)StCa
z;*Lb;rEnS`P7Sf{RoGUsA@ATOr=SI`KgCz4-{U-F#3Oj1@N2T{A_Sb*oVU@OoV?tq
zqwgeatbo(WUg-Ywe0Fd^P@EDR5a$6-8vtMKXHTHEm=$GxM01V@nuh}$IoSCBI63Fn
z8?&vlP+}0_2;ajT0DaxJiHrrWS&%%`dP4awVd|Edv$7q{k*@OVK1hJ<XO}(<Kr%h7
zEQ=%mFDVVr5Gk8nl>a$Y9CPg(TpM{m-#7<wQT}4@azc+rc$Ndt^5>vp^YHKJ;d1lL
zU71%|QM)ip9a)sTp(1}&&j3Uo#N}vj2BfimI@vSUJC<J4bem+gHO;pM$5R@<rjJ60
z_V6NsiU5kNDrvK=!=hv3FF53mbA5MWDxmlp4j~JWLdUlrR<*Zx|7pmjE?2mW!6t{;
z&~zL04~3Y!-OO<t(a*_eabX%NkA3!3Jtu*U5~$IZUJ|T367Jyi%bU;bvOvL}N%=-r
zGl+Ce!+LO}lVjU8KGxG&j@Fu3!j#L`2r5UWI*T25vgz}ouCl)r3yO8!R2ElMPTSPw
zTN^NpDitt0YG1VN#01W<e=2E|VDuCz*WLJRMmY3WW#;e2q(dhLaj>}nV`zF?)IVzM
z$0RDT%i>shUe^Y_*hlb6WZ&PrKLq}aCMQxu<*AAC#>C5ugL|fFUGFfNTUQ3ha_nu)
zz7`Gs2ZXeQYI4B<NfXYMe+B&aiJKO@Yazqjo9B%^OUc7|GE~uX|0fm{s@qd{Uv53|
z34htbcTwg!Jv2-Kc1_kEst5*BaFs<~f=)T*xYh~b>mFVLYC#p<-rB-9VwZJqE2D(O
zw}9Ddn@H@q6jOOGOAD*rc}we8FF-iZ6qGh#+w$EjYcmGh(8_uT2gxPu-{GS~01#3G
z!y$@k$5843hXJsz92Q`fl?($~TgJRHOTC=4{j_}h&9wSAOsj`>EW?kY72E7|OEOzz
zNi$H4*U%-!h87kj?2A0kIGZuf8ZQR8ZDN<l3KJWt0&bYvv2r#yR0K~6Gn}dUIx|2e
z^#;u7TwUaYMK)N}sNaO2{M+Bo&rd!HKk;8v!cSNx2jL9L0%4ZUC}H}BgK!>>PmF_P
zdyDc>?{<#c%FHmEXI!n@pwXjZ2>Dg@(}~IHrdzBhavbOp7q_6hO^t?I1PrrSGs7$p
zBt_^fe;yL2SXs&`e7=VL_b{ZeiPcaJ3AprJ!f30$21vEdzK0XQ$Z6xSi1>z6Vi7&7
zOIXA&z(i=>7gHnK{?71)Y;wXLDHpNY6RQaszL&*Sz3rVuZ|4(GD?@^Rj=7nfwDaXW
z@j&5slw87-kFX?SR3$d8ZAyo>Z2d?H%OKqSuQ;-d*x_RQu})TcLir?~s3c$*f$vQ7
zD`FQ!o2xz_r&jQTwpSM0&`o@DGA(X(Jj}6s6c#7yDY~Jj={L#z9<Mt@=sLXW?B!dd
zQIa3?&96l1@Tz#%#eZhHX_%D`0`=mbNxab#+EeEIyI4(#(S$r~tEp1?K*CA!JXO;C
zIyM{F)x-tt${tymoJ<Ta4(^@~_71@$mM+3gjl(Tdjx0`dYcha8<Ij^#YH`zQo(L^k
z2pe*k5L}F{Vs)S=dGUoj$gC&fliE-1k#!IXY!hX;K85hgPP6@nR{J=<W^I#05_3?^
zXT%&&wzLe`0K~_Mop4|Oo@)?x(D6_Jl>b7KjTfO%tk2QB*C~lBwOyyGiVHbSeP$t_
zC)QAuvyv~w)eIte-8D!!+m`IUMhp*8SbStzaWV6@E7TNMv&(<!e+vI&^&bL|hNA)K
zHcFi@*gB=gS@+%tp#;1B;2tv=i5+a67&)vz#mqiX)F_a127HCjc>G5LW1I$XR#qOa
z)+y7%WoCdtvJjREmt#bZ^8rBzxdyw4E9fXJ4+|)vEjen4SAmKkw?@&hqi(zg9QizN
z0{SC==lSKG_&48}KQ+Ivgg=qgL;UFlj{#+IS2q0V5LZrn{OJeY?LA6Xashw(e{?$v
ze{$_85^2VJ$I}|(rr*FCZw9-WG-9$jEp56PqY)OA(+#kx=zbCy=%)p$ssKY~E@y_;
zq@wLjOkJb+R!~1rX&P!kX>#*+6t0GIVUu=>u@dMZo`HI(AsWa!wBBkf%f}qNEPZVW
zFIy{K#+au@UVe<c6!hO=W@hC~Tw7#jYsAdjAQnAx#JxMi&A#wP+^q3JZl+WSGcJ0Y
z4MWr45{`CK9PMJ`-~4|*KjZ8}!_9V2_YR>@EgZ{kyrOK82Us)!0`(|}72_Fc=Y=ax
zF5G%m*UgJyfHzoA+`4FSu=ixJ_xSD)XpysqLKVFm@8@#ior%c>O;uetm-FQAbG<_w
zuLvz#1d|kI7Y*1qB$qC7(51B-@8=F+M)l?!lCec)a|&iIkC?Ha3M~>6;V??lPm58u
zxQr6?YWr#!<<kzMeETd$DX4=KngRx0EsY%qSjNQxIgUHfz2{C?CTWxfjTu{YC{xNk
zog#!^75y>1_Bb&MYrW>cwQ0-_=fGI1ZMD;;QK=o5d9^z_qRUL3k_`;@292xrU^|29
zg|Pe?k8Z<J?PBBRX`e897Eg~Ds~NBv#!6GIdxa|oyY9J1?L^4E46LXDb~)|QgqA;v
zq?6ggHq%bmtgAuHmJT8c(A1rc>;RYTzEi~EB8|#QEv%8O)ZK+k6ZQ&8zHpNIlmk#2
z$(P_qc&#J+0^>0_D3vImQR8)Kq+i2pOZzGkapFrh1x<uW>nk#bc&RhcG%KxISJC{J
zznquxTK9brAq3%YX<Z5P<!xL6!~MoF@Fc@$444`|f#2i;^jY^DWnV(46V<U@4q5kg
zalzS^9=3HR0}}W0{HGW3Y+W-6Ha30B*>&fh45v)N-!qe8-S=7e_q-F5@6*m$*PNoI
z8Mmdz@=H6h#;TERAE9&F#g^xPRBj&LO+)s*c|-nDohwp>b)Up!GRzw<No18|F8{|)
z<wBeI4Uag%`D^Rp<VS+z0G0q|2h1W1jvo}|S?$Vd<2BGh?4mzlnD`O&M}*}m(5aFa
zt@b0#sP2Fyk{{wJ4%0o|;G7s*NtXDt(YEo1Xxnp*c-%o_Q^BsA(O;i|!v0C#s(r^j
zj0$Ih8d87#n?rKPdG<%~n%9Gg={w`r^*`qKNAbXa_Z~jS4t8Syf|Slqm@M2@T*B6U
zI#3rk3gnK5OD)R&oW{4Asq@x2jznyiuH(o#wz@-Jx7q9{nAQc8#|SqvvU@kD;bM1b
zv%eIqJM5|V?<G+?yY?NVn!PhT%H}t6=OfBA&i9tEk3r`*T;UG7S32OEgAKXUf6vb|
zZCHoyd0I3&m9XwpL{)SgVRM3UB<p@Ue-V#R)FYlaNiXJJ*jAgOl;&OB`S)>`f>Omn
zpr8_WAH!yA!M;5%s|+2AdM4sU2@|4*N`C>WqLAHhp*6$M#{8{$L6p-O&i*8=!NJTl
z28p?w8T}?B<AI?vEgtZ+egVTrTPMZstTy@l@43@-4A+vA-pNvU%!PXMQgMG`o`>EU
zOWstGzmocYnwLX*S$WwL=@rBy0bS!JfD=|)jF?0uVK{9sV1pLY_+YfE7vnDcwinrU
zAcz7c&5y`2`}lG#_nW%P9*~;&m0ypNGSFMFQUnhhMey9>t?QKyDxMsVw!J)o7Wjj3
z{lAjIE4BH-GaIdzvj3*Pq5p;k_zW80%gxA3=jM=??B-K&4(Wd{g_F3{Fa0afaa6NR
zQ**>Vu>eJPL9Ff&s1xBHD1o=)!cSP%0e=)v|F)L^tjc!FvSD<<C`aG5*%yarC#-Gs
z8AWiv@-eoQ?I&3+?K#(c5}mMVg%h8aq?M-9`SrmPWf1uZRWO7A<;l1U5un(+9y^Mq
zKq_K9(4UxG)YO=qB&}B4<l^Q_ttVoOti<p+@V0uq5dAn0g%F^u!sRe8shLJ`3|$dh
zv|Jb%QaRqC*dxmpC2w7Xqq^D7@8_;;I-9w+6ak8qJI`qI6S!48&fLfYxK~<Fe;mi9
z;s%yt1Cx-ly`g0Dx<I)!R{8XvkJJjKvc99u8p25#w4CkPMa!j6n(_s?!{V<q(vJbh
z%hT{2!9nwBk@M8xT2<%L79D-@!umK#7Cqzl@D_3SoTL~>1T<J((Y%sSx~0M|nTmU^
z`v|Ld+a<d{QY+J)Bd$1-ilmf{T$>A`^MsU`5mLmoW`q=Qy7LvnqCVLA$^_Hn$tIxR
z!NJ<Wou2~(-|+P}5KZJUglN)HT_Tzc>}<03hMSi8IKzH(GJMy-mb(VGd~WcL&kSs7
z>I{DdmGL*>p}Ms5kw{nkk&$OT#WBwHft}lVd%O4c)`2ZsdGy%MiGeNKP4ouuU*)~O
zoA-B*+&8CY>2n?$NDc0kbtbG63VroD3S&GsZi^V2TsVV|&F_O|n%;$Si6(xk0WBLi
z%a?$?wq`^!!Tk$U>`-+C_cQQ?cNy_s_am*{=04yT#Tb;`Y@h^b2a`vM5G{{`kF$ZE
z)&|<$IJ1E|rysw71h=UY{5QOMa7*Rji1i1(45=DjO{3#De;6&I2yeB-KD4Qt<hoP_
z2y5N*C{Gg(=)**l<An8QVyTg2-E(S!-{UbKatOhUXBvoYZR9b?=BddbatTgZVJmbt
z_+%pwh3lq*`<+8@av_fOc_0USW>X*BnHmdsCkD!U^M2nzd6vI}-7gFj-aoi=h`}Es
zn0RC{$Ri2FWvejU%^;A#`Yu3c_83!CmN&8^{V3D(J!{~;@^EsZ@Hr*(D|Q=Zj<>Br
z^|&d1UNi)_s9p&_f5Pzd8ANY>{g(j3pBm5eY!8C-iXn1uhUW!K@H_*UF2>6ONN<0M
z1%h3MBUe38Zx5i}Ft&#qu2{MVb2%=u=0qPjZ#0l|AwBE6=X#HCyaM)XJ<$^hWNt#2
zl@eP4*VVEvniO6jn9Pnkb|7NSn3SOZP}6GCF7EmebhtL;w>NXx@ZgrU`I}f&!kkzN
zMiYX$5+kF;QsG;|_(+A4@!JQt+>(Dc&*?lKk~TOG>Y;Gp5D(lD;o-)?Esc3U4@n)G
zu~$OeX=Bv<Q<8UiW>XA?So!`~A&u?1ruBF_4;y6;W5?*$I@Cj!G_eiHu{^nYhvivK
zDXVXUsHDA|l)1QXsKf-}*aKYqEcIa=xu81YMKZ)Y8hdG!%mXZR38Ryv+Xw`DYn8qS
zcV)+(XzVpVOvxVV+BrS5sM|Tb%U+{<nWj&Mu+DC_wx=L~(XAgl&mt@vtc;#mUO70a
zx9|>Qg8jVXBMlrl%RkyxLgDY{n_x^lq-TLg6DzT8{`w!m*AI|E23*-MT-mx${)-%~
zdgxMd^RiaFC#Hvt>ETCYU@)dinD5;%26HjR#gX6Vn*sfP-MjpE-m{UU&9O%1fBj<)
z%@Z0Hu_qf8Ar*jzR_5!y=fA9C)|qeT8!zO<B)jWkD#YsP7(Jh+k%=*TP17c0^CYab
z>0@%{!zej<>C;u*wc?Yl&%TUy%aB)Xf8SNpZF0rKa})EWK@{PN<XHH9aFC_Te4kTy
zp5Yk1a{iriy7uEk#u@>fJ=j!L8n1t_Y`Lrf{>X-bt!HEu+-(emLoVP>G&d8U%=Qf-
zD3O5$(Q50v8WYbhlra&&>V^fdo8A#%`aMfH>{aMgS_Z;*B__+8*2qH0!wZb%arZer
zDl=n-z_;OwKxXqS8=*tw4t?+9$UT|VlSIg^GFGn^mQj(?eg(n94^6wome?AFs@XwI
z@RHB5axHbNYp4f6&dFYEfY6wMoL$>GuK0qSO&HLu6d-0@dw*uNhroQtYDrMkgj(b+
z>~PopzfOC+wLP@;-K7me{FBGaj*Gk|70R*q^&OXWaHf2(yNs$={LDh8f*=*ltmTxu
zmW#diDp}@L0)8aNjD$^G)C>nH@n4y}danFKS1MwE*7BJw+tGv|^yn%h2;FZS0*sB0
z74vD2)WuWHVu^9Zwcu%uT-$owStEqCmadVjycaLw#S5|XMcg(<Aw25YG>GrduX=Jd
zLkE9QNZ*$b@bRjgn&wi|=lB9NG%0N`xKC<d*ou>d@Roa!vPq(k7wHf~CTCLJ+^!R(
zWX_{l`8@j?bfk)=Nskcg-_o*Usk!knlp2DMWZyc4o;=@rvA3S#AdL4OMnGq8W7aNS
zlsLXP`2TU(cd+*a$r~3pUAkv=Z7z)9)Hfm}WMQa!AXt$Jv5}$0^o6TQu!BcFE24*p
zCpudhLd{sPna$3FXlDYQT!J+8f?R@i1eYI-G2~9OPp)&d4Qvbo%h*+Bi1X(ej$v##
zE^$r_ZN1D>^)c6wVvC4toTBzzqaBY;$D@4bzgJ%xaZ-kOqYY7=2?m-~-7I3Ysqj2v
zEv+;iA;_FcY3%#i{B|t)?lrZz<(m32VU-Z9S3jI9C63^LZtD#ELiM07PG^g};WNZu
zv{HMKH{3j9JR_ADVdbj0b<#1NxxHpTy0q)Y_)oeSF+}sOr@s5=Tu;A+w+s$8&U!L7
zCDzlU-m+K@HJbJG5LaA_6Q@gk>e_3MarTDHE3?;=($F~j*_`W1tI}CdPz;Gqjl~m@
zUKn9Qf;c1C^ko)^`EZvOj5DR{n3Vk*p`aDdwA!SGXN^qg!uA`B!wKS+p0Pn;T#_iJ
z2mz;Hiq&bKJ1+K~S$loV@u)k^;=-;pdO9YPKPzlieXnOfK3KMr{fPX$8`4|PBr|xf
zC|}}2vrbXs<-p>IkD)7;u5^NqaBUGQz;uFF$`v18*wnDJ46hXS8@y76LRW-VE@Fv!
zW|2ZoS^2xPb=|shu^y0ZWzV%T-;RVUvaHROnAw-EbS)=*bqpt=WNc;8a8j}=&$mx-
z@L=h}EWxq0FdIr2=0+{dr%M;+THv!$Z=E2yusHWIRs0Yq7RU(m5;DLt0UQABf|O-x
zDP6I1w#Td+@rgN`V-{}FenO*c8dY4p6RE8){U@3=(;lIy7?em?AS*H=lfuww5bW4!
zgd#&{d{UAqL+$CN-wSqqwUx$bErX?Q{T(#kQIGxr8#xudI6nBLQbMUYWR62RjXC5(
zB_Nyy@ixAm`ZLS!VdTx$S5%FMC9rQ+7wsIcw4cAst^1Uho~`q%94Ap+>b!(`gA?3D
z9fYbIw{Ln+qn*6f9(6pFCP1sAr`e+pW6DL`7}_f8z?ut-;78Pv^Gv&<jvlB3Mfp4E
zHzytH$Rd=!k0ndhPO@<aMW1)vA0n(StD(0#?gj^)J@(c;pW_<i|Hzw;zty&aM;)Aa
zjycFL<1TH&h7!*(976Wz9}PQLk+a$*Tf>~`&>gUQUdE=v`LNm&9%f6JkCL3ROe<uG
zw>l0|irXt8^KI|Zce5=<o=s~|4I?%TlPZR2--wf%PUo@WC?OwE*rqY+kx*A}BRI5B
zbi1^MnVGz+k+fnWMc8MyHT~76VV`XE5<m<iH8A$QALSjUbjZU5WWpejH9YEp-ZEo=
zLt=u}%600cMu8gEeR8|!VV}1G?re+&Agg!<qJuAApsB@`Z2ATXr3?wBei9PWke{R`
zCVn@|>x=Yh$LD8LK#5h?E>1f5cOIebTW~4mTn^cV7`XadT6t#w+fJRl;DG~1VfO@f
zJXdH|NDibo^O!^>rmK>nTy0{e9_D~NLlMTumBB(BXduqOdgxgo_)x{MpfM9!9rrLu
zp{_p`hmomf+uJ?U0~TtBAPT>McXy?CSr&=@$kV*V4;jh>&$ga5BT^IGeP^&11GX06
zRHW}US%t<@!f&4^clEKtW%LD%`gsgwjEY&F;VDc5nDx$T16)ZE_L_u>ozcgTFR_SA
zq(mh{q#P>2zFo^T?X1Dh1#H@<k`4Nu)%o8X3DUG$ewn;CJPX;zFeYR>l>F2pOj!eB
z!GgB&@2Upi_>{r6t3g?`WSopUrMpWB9&8|Ku#VX<x3|Ly?x?$9e_MqoE?HQ>xN{P<
zzLRAnG^-_BnB={f^>na;sbt&YXb6YyTTi-0&xo1s7DcAb?cf?@*Tji9CH$NrX8VTq
zxFgNp(ZFtLT(VR?cs2=W%q}zs19sF*Qf@STD%ka4>Gl(&e4>)s$PJQxu~!#|K|52L
zEnHRxj-3)6c+O4V5)~NVCTD{|@bPj@YGjcgXYVc^Qe6#F{YSel+*~qD44X>?BVuuL
z8QA%L@Zk4*5c7Knw!C+6OZBmx*?}$ZXV1VB*_lw}7Os0J^(kaV4tt!rH&A}$U;H@2
z>6yIs$Ekr=2h%SceQ|hT=Q@zvbtp#$0FS?KV9WcC?aT~pA<&KJ^lM}aFDb@U;Q-kW
z%q5o2RA^W&j|&~f&u?!SU`XO=BYkwG0;^qC7Rd(UdhLJC7svBk-?`ktvrlR|V70lf
zKai=nHJygx8i`TLpKfm7{6fF1=CEjALVPnmY8>Bs1a(9An<fUgj1G?cUV{g&Z>n(l
zt+)1x+W62N<ablG@v6S9mr!6bUWs$4%BKhecMp_*t<NuQb)b7Nj|x^YgdY(4{Q;?-
z8brXxwF6t$9^2VJu;l}U*f+$k!Sw-7Ks-T7HpR^kZWKe1k70C!z4bI6=0??AD(|4+
zcM*j-%?>>?nHw80;Y|hUnH8bxT(II$=zi9CaI9DH_d`a>B-~7U#L|+<(t03U$9idW
z<Nf4ovy&Nnq|yZcg$eHuC6x>_n3!6!t!mFjprXcscGQPl!8{b=IBVT;06qBo1N$%b
z5#-~<OLPY}93rss0E#cKTH8UTz9LQKnUoKQ=+;qR1rsLy4+Jci58po^rd89u=Y6#~
zBza<Rm9-Cm$a$fZ1G(*ekC!PCe>$p7kf=sU5La(|`<_)e7WEBX%SB(|L#BBm81hW0
zmAU<>BtEi8n6M6-$ypp<v-?JP+~=o3xe?P68_p}BifC6qVT8U!gO}6Btsl7nx4xrR
zgium$vktIsJeA(Fj>^G}Jp)*!(mOD{>pV$qlvF?{zrqX+I{@R=0M7JqMqXxCerKLq
z?xGfnBt(T+k11u$p2qfW*bHC8Ij?RuC{y=Z&t+)3A?{b+b9}>q#_@EBm*n}N85b%O
z;!on2Cado+iPaktNkbTHcHN9ANjn@R%$Wu<1CYROObH)8hHq>HpBxq#p|D>6mG1>P
zuF^@?QQs>^8TX4b2Bto`{vk<T<NYxR(v=PkNn+|jR_~R+<eSlCOf<QU*%3`PFkCK8
z(zc(7CU1H}n)KTH3u>h@eX6}uwcHqWTxjMZ%nzGsm%@y3?hH-M?SGF)m`+;_VWR21
zWy+jAejg|qKUYUmP#Y=gpUNhtuHAOoo^{G^JLC~ZrIN!Gt~brX*J!3$7tPTuhR~z3
zYN!l{H~{2aJ~~cv_-<Kj?BNoMhumYO6hA}khQ7RfOQ-@(Uo06#6LDo07s0`d;vSdk
zA$gV<Ic|E{bRl}WgdwLWg(^^14v_AJ8KTE!i161pBYKzKWjy^g0Vak7mDJ2l)BpiG
zq|YqjzVTQZQBO`R8q09|pkz9J4?z7F%}xC%JM&Y&<N>971k>@OiJ^&ZC(DrCHfl9}
zo@8Yvi@kKEi3UwCnT(mKdOKQYN2^epf0$bAEfOUiMdnekR70YtQNq*{AnIW(WPQQJ
znU-MU?2>Jli=ht)fg}RgF!Y|nZ%6_BRRjgl-0ycM6w&<sUh4_+8;4KtX{ya74<$~t
z(DlakFT&q(EfR3TL`cS`P;2{Q!|DrHU%=&q_a9Z7(VCt;56rA6fKOCTwgpuw!ayFH
zv-`h2SNFvUNK#jqHr>A~1yDeaCD9DiWQG93>4EpdEV?xa!ihLf=a8~sI-{^^$4c!O
z1AT5*v%)WH0M6?_Xwd+#9o_T!P%YU@dxDAME%jsJ^+b4o?VzjT8e$Bk)or#Cv$^F)
z#*c(*4kl0UImdfuV_W6VDILQXZMVDg_V@SRN`GIKqj?b{lKz+xeX7HB+_8}-4!Ip4
zqz9z`90(>(G5wR*ZhNP8EBW7h`evms3J`kx90TAHz>T68jh&%^(E1nIJqecn4!M6s
z1n4@&l{lL*^kVL2LzQ#Q`JAEG+Y8N*7(8{gNx<fgfI_YVnWo=2+kgna8<H=X`I7#_
z-{?P^J=^T8{xj)MsQ>-SM4T9<{}W%@c8%dEuoGE&i|hnm6Y8DCP71&4Y>unXqY7_O
zmd`UNjt)G?xVTF2fLH7SnC5^%IpybTeY?luo(vLe^a&;7TI;FxN+g&i#2R?ZaZfB}
zA5wEXe!<wpIxmfo#85h2;8fEW@GTHjti!G9Gx6jA`4yveoI-)9etH%+<Mg1@;uP%W
z4bCEAnpo|)OG4+T8LFwqZC8@_J3*2s>oNSbNg<?8!RGKd4h<B3RY~Xy+r%)&8WRV_
zF$Np0Cy1F0pW!8!V+_JEBoewT!wc$$dxu6P-$vSw_z;m<PLCdLK!}Kr_eE>YNNkOf
zzseINdb}Z&ATglu<>W0D9`A7Y$8C6wH;RB7osicXzl0K%Cf3r}3>5Nef*v=wO_lA~
zgeLX2{{TMo5P4?0@Ik9`5zgjA@&+kfO1G|F#K{Joiz1)B32!g}UiK00jgH)cnV~>z
z=GBWvt_6sA5CN)D2^fr8gZ-JLF1>}1iBl8L73z#V@b5}kJ^Or0T>o$Ay!_r!@>r<;
zIg^Usdg^&3?wG$f+BSlK{7^c);gB*~_BQnqdFCAQm#gP!$o%q%b^T-{ImLW(eY$$<
z6`a@Rmx)GXh4&tc$i}u0FY+~4%g2th%bG_WybDV#D#3U*)KT^)WP&Oz_^$tgIIL(A
z+-YRtMr$vQa0<uj8&PP&<so7df_x=7A+%`09;m-tg$3lP#%u*L_RxZd?TH19OKRjD
zFhd&X3{3vmU9Q)JX3F`|etSp$iGT2JIQc3{=kE{hoPYjqW&SpweS`TM`Sv7pbk!S7
zVy7N3lQ`$}#olQ8h`;@5=MND!e;M;fI(=DXn7=9JPdPvYUKQuBoB3PrYp!91n1H=e
zbDFpCAa?EX+zlNB6p}i$uuz90pC3u5%+KIQ66fsv!i}9}%UQ*mN7nSBtyQ6}Us|a9
zOk`|%*`CXcayP64SI~R{gwU1SljY2!;vGcS`A3+(3+LzLmig!BHs<FjDV>VzOTj$_
z4y&yslG|NkBa;)FBCK2Ut+ReTP{y&qL{!hQ!lG|9MgN)kS^qPhA19J!p|zKo92uk*
zEyBHy)Z9Hv#vSThx(Jh&nK8x4q!%}lXI$|>yVpD6e#g1ZRHb48B*LKzq{0dfqVza3
zUG-XRuD{IPVu*J+3~|F3=AAI>zJ>+BEa-w=<sX<RnYYeGNRaKH2YgSarS_5*uT<^*
zU!jl=A)Akoa(XB)N5@F#@>u65;J29=*?Zdmjb=#@Fi!N6d8K5zqF;#s5L4QXw<-Ww
zZObY3EeZj7&a76WWUy%eHGQ7Z_kI?d3R-TwpV7$XPaF7sQKvQ^=YYf^T_MM_^h}UV
zX#!-6&XO~lBV%VYZCsPs*U4xqVaN!DB~maaHg-!ARQHv0LjG4p87PGel$|j>#)#2(
zWVcyjNrr?eSbY&o5KY3Iq8d)+!!&Ky_V=^opH1hl&v(zmKdp`@AXkrvzA`rtHCbuS
zNZko0(!kQ+M+$o4v=u(3EpAS!_h%sB?PetRF_ODk#CIF~eJ;ihQ^O>rtvR%E=|<T1
z%H{TOC9sY?T)nX~w6X$$`KHdLD;?&6js}i^L)O;SM*BOl5RQNAN^4IO{lad*0u#q4
zTEvUoFn%Ef23hU*Fm5oHr4cqIdvd9xc^)EVwQ}6xr(TzeRvqvt#Q+Sfzdl!_<TRaz
z#>8Rt4^JK>$Hr+_sQl8ldeNSY7o=r^_LQ;~nX+F&DxQ=l3~QjEO(WkyOG<Q7)Tv1X
z%*j2=8*5LwB4&5v`eTCg5Hb6seFaa%Jb;LK#w!ujoV3~?ecEHA*0(b*a1pQJw2&v#
z20C!pv!H`?)ZY^gq*;ukGQ=@6qY|&2xyj!QC-npwPo7aMa_cK28n>=*zbm2tN*#`y
zkUjGB<~cd<z^g_WmAloCSnb8l@`e7+g~{;e2E(7r|05jdg?_7YA-m=y2%o^~n;sdN
zJ~KT%xMg?#8|H4Lb0MPX>SJ40=kG0E`0U3dvyO0Mh}Yojn}$X*=CxG*Gv=vT%QZf;
zmv&wtttx)s*-zVkDtYz#w<fPHd_#HlkLQtB`=iN8i8(iQmMvjPgqBnoq1E-5kl$i`
zsOz?(z_TQ<=X$8m0dW+qQ&ei8$nYW7M4WtNC?8r?L)St0*D;33{-o!^=bLdH9Z8T>
zW^hZ^__kxbsKrQHja#PiX7FsJ#By%PB6MRmK>4!nc?E(XJ(z3VXsR_X>fq5ECU+7(
z;2R4Ea83VZQa}xqf1JN^P0t(W1IUid_yp+$V_ju$3+|^tpQr4TimVZjQP{lEec7Y%
zgSVYinZtGVOdVhOix>JGlb6gOa)9$s?YfwJu)97eZ)yJo;SF+@F6dMy*H^lmBn!q$
zhaWU9>+xHh^e$mJOBbr;DJ=}awb05_IxT}rgwc|x^dJY7jbic9f|$>q2=I4hk^@bi
z>gJGRV{MpRvTdcnscr%JAXBut@KLycV`|8jni^6LhL68ApoX=5320LJrSibI<G{5t
zGqBV#+vP^W_k&(%gEgt$@2kxsHQ7TL8B#d;JtLb$aTQA+p*^cOoaL!pVruoax9wR~
z%Q<<a_5=apZKKAXka6t^%8`Y(72Lq4@iiQrOHo@@>gYx@<^(1BF}1q&eURFAudB^s
zh5-{M>fgm|D`9|mE|I_9#WR&=K8G`=tOpo0&6pG$&xcv|gWFZ=U8YpWT%e$v#{g@F
zb~m=CpmSlBMe#|@)?g3vLGbG1NG?;K6kl;acpn}|k`T>@68pd}$^ZhFbF2dRJFuw6
za=DZEqsZn#LL8X_+-^vHM}RTvJ9*Oq5Q<+)d!znfe_%qck|YR)#1MK6_&*nkL>v+U
zPS2Ji{~n333(nBU#NIcek(=hD5wAT}lK<u+5eM0qRtE|tWIy8~`;Z8ju}323A^UGg
zBc&ta)qh2?eizF}e)BLR;drScmS55k2g|>pA>O1^vp1sbxmZ5u+`<5XzOi1F5T6Yk
z;}W0RHA8QjrB7%`L~(Q!pw5t+5F;-nJ%-fjk+#T9q`g*~t5?IDk()<v!sjE<gF|qP
ztD85i7XlnNcwW0s0yl>!#6izmQ?sd0CMlEqu92MavZSSEzLpO6KW!2mkI`QT;-as`
z0;#6;u2fB5)6DTw2VLj<cAO#7u5`0x+iGJiHL$W_V7bEQq0V20gGHeUfOSZNbJGp5
zJOHw8dqPZbJxB9>?Z9kQ)v;KKw{84K=$2wGz}IK2s1I;(?Gv_Pa3oJx?q8mFdu8aS
z)12>%OvmolbnQ%cI8b25T7W50PD>72ylRIrtQvmI)=~InXQj<_1@`?!4umzg=kwTz
zaq3G9V<s33ua_N5ogwp<3lXPgW8|D)7OpwK8Hjt%xpsk7P?+IvhQ2iXrR}|LuJ%&9
z4x!fu0%ln>aA{Gvw5vs77j8Sh-JD70V*6m*9=0!LxxP=L<m`rfq$_M228a+ToD!oK
z<2~0x=`L9)#qlrNyJq$3=C{%-BQwhf)K%BKQyx&)W{J$U2U)|aOUP}euLiVp>=+mH
z)zJchtl1#Y0^Q*gWR2kK$jw03p4?pQyR(doqBEx_$jt4^%<g8P`E<`8;n*y5eh_*^
zAlGyQOWD|I+))6CmcO|HqL~z<slvJq5Zw)?j4zdTv0_u%$3oe{9R`TrDyD06ICQyw
z>2NL(eSzV^^_FxbKez>!jL=c(2GO=Y{7Lrqk;3ypL++#ww5;JsJ<Jz$>B5c7uo7@+
z0rD5(V?Dnzr_gUi{$EDqAA6}p<cB;_cS`W*8UfFoqV+*Rn5jaz^9I5`mm4uu;;3Ng
zI>HYN@9kXVJaJ`Fo_~*wIV^H4vx>6|WXuC+tlLu~_nw@dF2dEW$S)sk$@jS%IxoK0
zAkpqgs2FcuDB32j&N*DEUr=<N14A#9Sf8BoK<J+@0ihiXdM26>f0mybk5&*N?%+Y(
zy<JgX(DZT_nhv+8zI=Hwktz=+h8#q5!JcKfNeCwm$eqJL(^pNeQFIr;bURroXMpJ&
zm?LL_8vB!XKASRTF8SpA(+8?n{xPD#iW(c!2dV40wbD8KfHQ|*MuV7RGTayDnAlsU
zoLN$N?)1737w1?OhIJ(q_!G{b_Pw_Jr7`Pzh6o!;IRHxa)}K3n21`7W96TDJdKMnd
zuIm8Op^l}00w8SzNTV5WI_&wFw7f+GU38W?=ma7eQaQmg&C=TNvA2h-3<BL9kR~-f
zz0gIV8HD_r;xxJ3)bNv;^Yk=dzk1vJ^Yweo*W)MNbiUS~wknrf7cU$7jvt?;Pc0iU
z|7+QlE+H7>cH!Y>N-kWAH(^ZBx^iaBLu2)A){MQsIAag~gzHUagAWS!k`CgT4Suc!
z_A)E(g8BOC><6^X7!H7$mX~REmM<!SnaY;KQVham(4_@iFX_5*+OZ48mM>16`XF*&
z%rPcJP@;{WHSW*&t!GLGCf~{WD$b@mpQUJZ=cak*)4J~oWFf7&uJTugOQyARCF0@D
z^2fRhxr)RaDOW(8ag~x}Slrwsiej4PRIucxArC;6DC+KE29{=8?`9%d%Q3B0M|e8<
zmbPuH?H_0;jd=@OcfP=*4#Q~rLqyE1UXwU|{-#d{N{$hd7Y?#CT6Yn+RR^+)?n;IY
zl3eV-O4I%vvtqTsn<YjqE=tT{MWgsiWY~S>E0IE^!mDG{pu~338Czn9+;-V6i}qMX
zzusnxM4}&(D1eta8b3cJ!)PF4w-x^j*Tc5+*TXNo*?O=#cGEJChs}ov>qy!Eozm0p
zIfkr=1w(mrBf&FE)F8pjXOQ3<I&WQGK?K2#p5YH+Rw?d<g<<^r6|k@q&Q@vd*=C^N
zVX_J`hZz>Omy2vMKJUmkXbRm;w?gc46F^ua#@itjlXKw-BujEP!je4S3WM#+3%b-*
zE5y-Pp%R*fVhX>_@^!FXbP4$zA-wfFo)u>Vyu;`&bT?7bI7e#JB9Ie8shEmq#ra|?
zo)w%E=@F-5h(wwqPT4Rxg~&bB$-#EnX_`ObawTIwYkj4khcCo)U%O>a-sIr9)_wPy
zm&$+hg%Z{zOqT^&acoOP{$mDzJs;FP`nm(^Dv=b)G|c10BxlFA(2VlW|E=HGUv|Gq
zBt?POBN8q_BpjmPks`|bkSQmXM?RsPH(qaTKZ(4z@h6n`{&RRP)VoBk1}>iKDrCvY
z@f<-8&4%We1S0Zkm52xB2HS=-!r=8rK6aqm4g+}`sJ4;}_^SyYs`RWKqzBw!b8aCs
zT$Qu#`A23=C}|cAr1=*mvVpsHE&aFv)~+(2Kq%u;_N0rz8V4FqIBXQ^iq5>RkpjYX
zSr>J+2g*~A`F$HEzw&D@;C^HW{gXmmQ@gIAk=6dG&B;x*xWE^J260WJvDUkYD>_{=
z4x<gFL1iOgsfBk4ZPki0zK`6=%8`7%pj$v&4{8;y7NJ&0A6YB&?^>c{lrG^Eo`R#k
z<aq1L>N6MYk%OHIvKuUaCoLWM?HBdshZ$e%v>&f+yx1)r5$b$SSETnrP`<>Jzv=4D
zfyt(oJbKt?cK6L4r|w>|dBfqIOA2JpE$Cy*BD@n=cy2uNd50-W9|T^(YtJ@m3=j`!
zPWiWphov>bE_S7;nBzZa1YsBYq&xt@3fnXSmC)aGc`%S|s-lb@(}<3qyDK;3zT(!a
zGa2tVupzf=wD7u-GE99Ye)>svKK-=lj09@k=+^2f`J<2pOye82oa|E34cI`xktQ<F
zt(pF>!TQ;BIXb>ub%eTCM9#0A3%gz`oN;9w*B-y#oe*~GPOJ%?oBExjB%H*4UPKti
zgPLCJ)@6IY=_lw76IACNqmj;LtPsZ6*kfWXoJ<?5dY%IyV##BX@nal*tzf6diesj&
zjfrW06QN`nHI8uFX45J&PSK9+-7ClejX@_~mEO6c@D8S|ilfRTp;z^OWjP{Iteyl1
zgcdS~Y}@OLL{%!UF@L0Y;y7PC^0R*@ijw^A<douQUWZzApnH24WaGISg8z12)cH$f
z$uj5Hj~{Se#64^SJ`J4l*WTCs8TqfUAvpm+@c?aMe`<<u)+1j_b1IjhB|Z58vMS4<
zp%-+vg#s)#WSeUUH)7TDpceK+Hu+2F$y)dX2T-(S{2~qtv;H#GRTdU082ughv0BYe
zwOJ;uFBKQbUlY--MY7><SR|oAvq)0D)^pCnu(2{+=dPCuRl$hWvTK)&l|G98tb-Y!
z^@(ME%GqpfUKTL_Zy^&tz6D=*%mT%?JbEqW_!GUNi3~0~{?}|PE(wTMZIP;I5wf+u
zkuq&?@=NHjuTba43X?D_=){|Puox5Zp@3n2P7bDMRoZ$e75mUdu_~J(tFS>5OFJRF
zx7rMk@!xT!dKz_QcmztlgGPx`5vM=Ie&or3EyBaAQk2Z)(a2?3Qr)r{rRrJbe?tCy
zZ^o}y-seokxks3a{R3~puQavdS67K&tuXxREwie*_|wDG`lkFzl^XuEO8n_!@uxRo
zO=ix$`L?|%%_4t#zguhRoX^RhoSNzHrQ%Pk9GZ9wtf^T48?R>-|9{hZ#vVVDFX*lD
z+vor4r{%XA9K&yaafaW%?LWh6-TlHrq^!D~3UwWFHt{=2O!~tKDDj7<e95z<74mlT
zi8g0-RMU--KR@C!s^mbc?IT(pj>svC?QHB1*<BAhS2!BnxstBvY1(1!J;W1i{aY(r
zpYtJxVs{w#<>f6!G9X71;MQUH)|fAU29bcX8hNF8RsFfm<1g;h0f<)cS>7D=<%udJ
zKap-*?HN9A?ijS%b&-yYiz~N(S6?<Db)61bAALSKWqp)m5ptwNxhN>hD!YVT;Nyuk
z!ad+%O8UXRz(0)FR{I~awS-mZ9zHlbK>axmC|{_<8>)HMKF-G;eFO>&)%Am7Ci@ES
z<qRfein4ZGq4V;{P8CW%-}f>(<&FX^Z|<1ZRwQVv5DxTh?ijnfCG79#j0s<(dh$2a
zMU(tGObCbNaDa#dPWRJct(*6+(IFL5t1aD5*q7lWt3*bep>7VO3f2Lp4q6>ILonXc
zJ<ikQD&pzm?$b1oYU&Q;k>J^WUK`sSuIsnjTXj`iju6cqmu}wYRG1=EgqXTE`<#4o
z$?mtDykGC!RYBhw{X*23`Y}eg4J}qiHg712xFZExDA2RHZK8a0+tF!)5P|M6fYjvt
zIVSOxukf}#WwMY^XWs}me(Rajn!bZbc0*R}P8o(HMnGUbn_sFq#{*-&!V8i=jf5vt
z`>r129^r_2mwffl4I8ESUA@kMxd}(cOW^gK3U&PfQYKe$ALSp!8m_RL?lNCnwk}`h
zV-m0uW%9u15SK*5t%T<GnCqnO>B;}IZcI{0OLJAQJ{=rC`lSlqD6cd1-kHgN+q|g<
ztag~IPn4wpbSs1Pq5Ti}yn%DG`k={vOncTxdmW-&6-o|}n#iR^)}0hq&`Rc{iICG1
zg1I`ztoFauBvG>n(LTXwAL2q86j(RfbfqDKwuv=6E*I^Ek}vkXR6pG@=A1?c$pr&v
zsm6(`bIu?s1Af1IOOW&BAVCf^v)UOV9l-|mnPYo6knZ>QH*n1%Jq|TmkI`9_;L;qq
zHoV4ld=`509zN7|s`&7UAJA=I-QoO3hv2${bs4KYp;F0F0U*0$mG>It&1+{}Qqys*
z=Xh+_Qq4jFQT~fPg^!8iJ}{f&7#(uUu7cu%fgA)EY#V^!9C{1Ybcg)JJ$<peQ0WjH
z2r)52%qZcYciQr=M=yIlSd-SZp2EqZsO0Ql-gyuZ9m0?jneRGOqUqs6NjO=}fQJB7
zCT{AwctN}?;^%BUGK|xH@Bl<c>z>2<>}m;k#BCrq!;2B?qocTCMy-$bIgZ=wBFXWH
z{n|Q|DI!ZjOo2<Zs`z5HEAwTn=19l1)qaML5tDa-q47n3z*qewaHWgd!wVz!OA8}`
z7a6CziKchEq|vZrjYvZ^z?5+LHw=j*B_n;W#scRE@rc!&js^zsue0tq9*(HN)|12Q
zEqvRYv-t?hBeN8ENd9TAc%2??iE&~qX=2p`2+4=q%xJNgu3+wo6R_@mnd_dUQ9;7~
z1IpNQD8GRF#`VaBf)aK!FfW#|w&9kbqZ!p@oGy1P6M?m;9P6pWiY~F6BYiJ9&pvHv
z?74j21c<+;*c7Y%F`kWX7}&O|w1zf&f*PQ~0_OxzD5KD>i@k;+_BwI2J%ukwrM`uw
z1!ogz%`_<P7AG!*pa?`3ZR>}~_$00t;_Md3jiI~ne#WA?R`W1E_@#<7)~@o(Z-_D7
znJKIi1>%mwAeyt*x(nqBqF5$Egx5KzTFDi`(&IQlSRIE*9a=cX$L6Ea8fVZ7*%A^x
zFMs~S8lEo4PY{6`ttgxTo46kt`av|q2hsQ*E|mn+R_!HU{u88=TXR<3rbmcre<b44
zl0Omay7>KqKBHBqNn7zP^ucJ?hq*H8k5rAL5gu%;c+qO#t5N1D?>z*}<nuhR^_?Il
zo`X(;X5m&2P-WG|efdwb(W;!7`=qfyI=Tl>LLEw*&Xc40b@JWjsrqr!V>G`9SelXb
z<_l$`zMpcN7hARE>95m`+Dv`{Z^Y`+Ob=V_V~7}>ju;6XvD*E*o;-}w%2QVRAh%eS
zu_`=;o{L%=C(LTxILcutcJygTjUQFb+T6(6l!NTrXmTuSze?&9qr~Bd8LK(#s*_gx
zUoZ}_nsa1-x7vp_ChlsWk(hlKiXgtvWqw#6)}!ZGqc1Ov1zrjzv!S|Ct6i*)EP&R1
zukyh;Zg&j8^ISCfAJM)avs@j2*8hQv)oXl<2mS}rgch&$9oF-!-vZeQpEF~~htXJI
zdZriVgkXRs<4Ef*20`@TqhxS&?BYEM`xJI?$9Yz<uwbD$&xX^wEeANH1~{GRV8<Fp
zhXTifxa4|k@;R@-F{i-86bQzD&M+GtW=p%qDfFCfn@xdSzxf}rV$JHUAJfStY;Cc?
z2{_Q*w?_RFkri;rCtq5(?QLx@`|++F)w!vW+^fK2&`v6vJmclBdEg!z=+Olvs2rM`
z`XkSVvs{NR;@Nzj55f`ZID&+n>1U$#6OsBe)@|LfzyYgWTd9-4<eKKc#}V>?5NWS#
z8Y_GvX%@DBq@mZDm;>Nu*iq<LjDezGDaJ>MVt+O2WJuLnlZ#{4xBC|=u@olEc+FWN
zF-ZP{E<ahWbPgn;j|O^$8MpP4D1*yzlT@fi5SKE`CBwUQ2UlT$`}pocofruD-;F=A
zQ#lnA0~b2LvyS(?Jm=#n3tX@D8L<N~mSRTncp%sOubgZkbQgZYGQ$={SXz;#ya7J}
zB^tb1&Z!A&@6P*S6$w&c>-&S9n;sT(2_~o9)i9767$z-9sPm3*d3yxQAbBX}$I<&p
zwDpKDftjeY`4NQKv8b7TTAGM$I2(EPfbLm)nIYo)9y%CJz8?2K6HmSnZT*q%#5epq
zFa1Zf>KObe1b=PU3_E!=KyZE_ttDP{WLwP({h;068f;|S!iwbEoZMM4xW$)W3NxUX
zGtmvB!Ka;9#+_G+?QM)<WyF;XKvmg1@&jTR$;0vbgYo3^(fVWYz<6^tSvznNnNl7a
z4(?5e%k>PDfAp*P+jbxAF1!tn!3)%M)_r3!{<nW*xDxPLpVhA8oj`}_ZzOPL;MD=P
zttN8`a94w{;Z(fpXoNKX)<$9mo)1|YS$7*j*{1jhI%P0dGAv7_aa1;x9|nXg9n;P0
zg5TGM$x1yDY<s;S*cE$Mf`_5r7bB#%H#`OE#VQp(7Btfku6wzDii9>4|LEa`B+7mf
zK6PSYwCyl*=Fw2yl*8!Srf#<GlV-B#7F_O=S`Ys{${dw2svpy-e=^L9Ip#cpXyBh=
zSkELyzGtF+ua2d~VP513So?`W)M+X!Z@Ac0Sc3J~VYcg{apn|{ACi*A^wpi9i&jS*
zR+PV(Kh9NpCxwmN%o2lWHd4;rS48~-u@z&DV+SjmzJiJcD>(%#8K7liCI|e5&C$An
zSk;)d_wWF+P`5J^C#gnc#MQRRg*!G9>&me7tVIBsY8!8earA|f`#V-Fa+k};DEwTT
zjmMB_wt>~@Bz%?l*SbTT%i4NY>9%%}4=|i{U^0{>{G0o6{4RVM6>e9A@P7^db#M>d
zSm6}ph2`|`i2t<wh_F11O~{!nh-e5e#i3R=9CF=FVR!7qiNEk(@d|o)1h*tS7<E>f
z!>bgLtO$gZ>sp-|+(KTN0X)M8*U!Z>ULaO|?}1q0pdM--(138zxHw3StPLZBTZRfx
zdm@R8FWfFj@0JiE2mr&*AwUMg@&zzp9QeC!D4rqf&J^Fu-}?ZvQIHV%k&OqXkLnau
ztO@*?o&h03prmhi9=tO(Qe__eVaoS^8Uir@S<-|5LLmOHM<B8w5JMr?KmGP13^DA%
z5d9vx8~;4v5qFBd%Xf83(tpiZnt(KRWoPh-!DU}EH+S{CRczunU2I~RhfSoUth&$y
znWBo&MA}?;kcrhL$iyX<sqs$d{*-j+rtb@s_zQ<nNs8U{?f(KKklWA)9zhO$6F`E4
zo*h79c@dB>Ln}yP{Z9c&81UgdP{PbH+ek;H+EbIxU&j9;wPEj>jYoiNytZt85~>p}
zVGxR$NFkILQtIj)D@V2R{TDd#U*N>~;KY*qes<slbo&PSghfnDZTX+yi`sshjigWn
zC_o|rE;bq9Vg{_h8rZ_Kk(xAM21rGC7E-YkTw)5O;uLy`i&WGbRN?}pf{Yd}!cmG;
zY?=$H2zy9{vM4-fFpYVTituct;&~wzgq6>UR9uqj5K@tLkqQurgC0_G#2^*tjDB!X
z2u5w%Ln_j-D%{_NR7}kv6}cH5zlc=GfomS5!bB3zfmFEc!5|fVZ-i7}>iFM-R2-5^
zjE7WU$C!mw;MOIi!sIA5VZMmiM^Oxv>#vAR|BR6eypE5TAQe;RBNeAnFQyDqVM9Av
zgH%kKOuKJ}R1l)?AQc4Q7m<o7gH)u9%J{zosp!_G^~OlW@NA@F0MODP6}fqliX2Eq
z+_)GzNCkS#n;{k9)LbeDFl+P6WG|itQ-p^KeWmeXf+M1x6;Dd-4qkH$F0@5u{Y4v9
z#sm}^eMAD9T$DyRNC%4<U%ENxgmY)wj$;7K1nWnE*iA7>V|M`@aF1K%Q>g3q;myIe
zv&V%ubp49+S^h96rMSdc?FF>NppYnIF-603O`V=S^Pn$}M}{x?oTIE;d&eCg4@{oj
zuF2E(<y&|JjTuX+F?%k-T4;43(_tuUJ!dYh-fS#<Kjs?7u=20A@<u))QO=ku*Xxr^
z1HZrr+D1WToR4;uXAQ*DQno`D57s~jVqfEE(rBhsp@*;Z9zNf6sQi{ZCRJG}M|l<#
zXt`ui4L+q(G67SM6EJnyeifHEe7t)6cDU=}C17=@#t-V1<||SA9zE<2`!OL*y|d+=
zLd&iIOx1YX$1e&7P8V(!w5Pkfj>||TBjaxvJ3y!|E5quhWP0pq;<&|tW6$k7LEV!{
zyYDqpJsk-Jjs^Qp>hds-I1o7AFM)|523KpZeVw0{GLN!FUZ++Y*ghBX=P-4lfj*O(
zadIn_w-kRb`q_0*<ip`HDL!|LdidOn_@$S3>G%qtk8Iw_(}KWcks``S0S7G*(8GS<
z2?%2W{|puVS;>V`QaVT(#*vQq@Rmbh-)dnO_cb!(Up$!qU1m0Um;ux6bLRFEW`o;#
z9nH`RV2yF|A`s|~Ba~FAWLkCQ64BB#T#>o*(@<KzhQ~!KylgCsHvdI4D#5qyot{As
zGAP>dj+YXPp1Rz73d$-zg=NL164~rzmm~A7YDvVc$2m_Hg!g2%KO6G*x20Nx<7qwA
zd_@>kMPzZEK=77#V0w9vJB;?wDpL9tZo}kcZtgl^Y?oLAvDT#upEAI7U7ACVwl8)r
zMawvAtxs0=6A)uE*Y~Q3Lh&S_z>9e9J7h5mS%AD7bFeRAY&pU40qa4##`a^lHUWc1
z?<=7NeRSj*b6Roo$1@PWC#G0N5I-0rM%^A+ca_X`63W5r)NzioFsHQ}szG4S#7Quh
zJQJ-^LWfArk*<AyETXN`3;1i@^Bu+_*!5?+R6h;zn2SPmG43r1CtpmSiYA|9RL@21
zSF2?TOaLLqtjEtN`F2#cVPX`m#}9Fdl#(1*`C4^2`MN;ZvoZgPX!2Opez_XEA0~}z
zd{V1pU}S!>ycMb={zD;u)<041CloBwb)!Ghaj0p#nF86%e&55{M_WiECqrH;e?skg
znm_ztM*AKls-G5}DOz(Zx?vjgpets`{C7}q9n7nXk(xu14QIE1VCFV~1hO95`3JZS
z6n54h@sC|6Q(a33r18!O<E1F#K!4#DN^Wk}DOA6QWgt(6qUj<<G+6h2hVNz5(d1DD
z!5?Q6Rup+5(pQkp^CdtvFn3nV*V$P6BiM<O{R;VuZ8(hY8!myw#V0eIc#lIj{iI1L
z2TcET@Ye|3*l@PliUYFVD;wX^ulRk1VZO2-ps~rS(tex|v97Itj5Qm^x2^HS8I0qy
zU2?uC@(OlNgS*x}#~G$pTMe&xMu+oloORE&J?qa;V-PH%$@Apv)vRmJ{^u!zu(~=~
z0h{@a-yco>bJYGfY*;@Q>@B+>5;LNA_~EDtrQ(h`kRY0TCR+bbp2r=A<(hvHxz#-D
zXqDlv4!_WN(bcQfD9#J`hMnSe>mD*z`@&uK=(c;^x<`GCJlpZ0$b+9)@;eFh@3H&&
z7Zr;m_k6Ms%EjkG0!|{9#HR8%Qxg7+FjosW7pDI&vE-0@`EHk)u-3SOxhMQv9F4?!
z7!4(-BgwN|9OUVU^*Buq-$e!rt`Mg4IPR`WSy)XLLzV_Si3IVFp9IwB-xT+=NsNGx
zlPdV}A%3&`rU;ku_u@oCf@D7&JPk1IKP3w&YetC%WB$DU!9gPn@3<SY1rf@RW~+hE
z2dkBQ3kba$+&#81{#&wX@c*vZ+nYZFDji?(V%-07bOjLZ5ssvY`k$qE%!7w{XSkY#
zF>!jbf;D?s55)YFkrhYuDbm@Y5nLF)J<^HS72}sF_os9s;gc_|weER@E7U&bryVc)
zi97A{$Njyr&hKcvuQPJ!AAOaN_)0wxFmq#Txkfk<c)vc#_Nn866?_vI&8K+;B6=j!
zxwCj)2N}#U3dfB)wwrW;e($twZeSU$8r+KSVRNIqtP{+?v8O~p)f)2(I)|UkYS05D
z=9~7o0Ite`AI6efMlj(G(NGj7GI{M%Q#<3kV^?xohp`_YP(@gp<7-`8kEuwO=JmX>
z*6fSO-^NZn(Yz6m+-lce$!X!S<ZsqedbL}6b-tSGMefnEJxui_7DVK71_jbhIYwuz
zL#OY>0?%9RXSwbaxS9eh-2yA~&+(~@Rq?#o4IURdzalw_rb2+opfng`v^|E2E86$3
zB=%3fj3zT7mT5gUZjQ43cWf)-S+8I%F{B?({ZIDZ20qH_%=^zMv5A=8L5YfrhSjta
zTPUg0nktgfOgm#UN?TqMi<b3i+4k8-Wg$VT4I~Y*PP3_QS6W+Fmv(jkw$-ZJTG2|K
zNg!`1B%qiOg@9J?ajXVV5<toS`#a~J$pl3GZ=e6?^Sms4Cii`xbDj5du5+F1?LbrS
z=L^WUBV3$p1Stpr+wfAfop5sB7Ren(**bTl6sK`akb8jb2Y2ojn4@qzwx>kPc7ZHr
zl9|7uhHlK+w{i_DGAWd__876k9tA^HgB@Ku6uF|I)`ern2o*WS7u*E;d)ah`b|TZw
z?YyueBsi}Lqu<e<AyBor4T0(iCD9+8=+tJAa!N{ZSW;|s)>2dlf<uF9Dxwx=#9hq7
z3>K+bh6F~Q6H*9PHbq9VEsJlPIh`%1JSKB`4jB~9A@gFyysaG2?zw}?CYIuWlUb3&
zAo6METvp;lW+j2c1P*$EgNb*9+PzdWNtMRPW9S1Urnpfp$Bk;ZX?mb3lv5tvYq6_N
z9iHNJv@?PSsrp@#S)nD^{G<>kGys2{@BfAp1CRw7L81U~gb>{+kF0MNYR|0;v5O;V
zbRHf8Tj92d{XbU-P<ua0K*++(-XHP3ivoo2)i5*6?EOT%36j}iw||pgxr`JyHQ#xP
zu!(cq&&VDea+oc6#JeiyM|TnyuJ6?TF{*!`kjqjdhE0(HS#`nakSC$6DBT%&N(my9
z-d%cnrdW1kB)UBk-ILf)rU7nM_H-*shf?rwFD*+?*)sSe;V3tcbtXhAb5!u^bUU82
zMp6hUtB!L;2}Lej5^8AkC6`IAUveN4eK%b4VmS91r_tzY<f5n{0t7iA;?(5wl)e!L
zIK#7U`c7R7gu`AfzTNC5SR_L>pl87v+WH#jaKvy--qrC?ZXZSv@;Ac{zVoIZ)tnUF
zg9;se7(#N-DJZoK%lKk2oVyQQ9+oSf-OGD8QPcVg9C(*ULphnW1!JoUzilgAb7my>
zkkj}z+K8{Y%x;e*<20@UJ@hA}zJ;gWM*~kW5X_Kp>7j7LPT#2Z6F0B#nFZBh<fPog
zUV1n(=~buUKOiX5B!@s)gvA?K6^Xluk$!%egn4BtWnss^$9)x}XvdF+PMh0rUcn9R
zZXxBmxBOaBX&uh8Ol5r0&qti6aF>A|9tSFJi8zf9#3-DoAdQR2tj;VK8tg3>-h$0P
z%Q!o+(FUQA)i3sR_5a~8buZm?#9_*@hbc};adRH`4pfuuG0JH)hi#5fpI^ce>RQr!
z5vwlbU8JAx50d`RIXp*?Q)iij5*{hi=Ok{=Hltuq-eV3^sG6h?Qv+N+41S_<9drf~
z@1CF!%}!jY<^-O+VBfeJG)^Mywa&wRTJwP+{KY@KomVuRSyab}5E-NeKh)>FQQqP5
z=7}d8kx~{U!^5a1$~_pg%j*}_l*M<S&g~|g?t99Mx1f`(yMI@%yfoPSm6g2Jubd?}
z4j1~i*yC=Xv>SCnqbQrT<m}vd^1_}(d^gIiT|uZRlf!|PD_Rh08I{gh^7M2{z|i3=
z?Jl2y67LOCi9<Pae@$OP7noZVYw)X`Lm6i-j##Z>oKlb87HCdgI#tErybzSa*&%)C
zN|6}QnCRs|W=?@U*M()2<`#!6O(k>Ix`t6KZ@$+az|x`Snyu!m*))1^867Czg9V-~
zsNiXhN%2s0KL`W56SSHv9O~z7CvWFqOZC3N{UKt^G48EGjIEr951{~hPDA?$JdyEy
z3a7uIV{;e{fFaNYmo{=@BO(~ZDbZ+LL(AbSnlEW&;UGFMN6#jT{)CQ$BxPQZYhefl
zeAop_Owd6?yGM6Md_yoUB0fAnbNEx{zQZBk4zEmG;0&j+j*L;znxO#a;XUEvK{FY+
zO9uwd%9VlUN39<H0UaBi+wTUP(W{Q2-ZX_n6?ao?LFI1ylI!q*n9zos+9^0krVota
z=#I#g9pTc$%Pva|l=Mkkb^K~gUKhrF3TMBJD%j#z)TcHTDRCO@(-@vCrfdWaE}M~=
zlRaA|Pq)?LEPbIIGE%z<dvz#n5gIlJJnB&6ki6yw9q_(<gD4z6tN$(1xWD>3bit}|
z_kA^|yKw1_(bJt&#mwmr_56&}UAVO0Y1oiLwNOKrsm&=6#eBi}INgmT{tbu_2iZ$N
zX_VkJUcgJ@d;IYzj4|iElx3Oh_nN*SIwR6l7;LJ{2}a-X4tO8}??8vtprT}dsQy(;
zXmkden+;iUz)~8o9w$oUhnYcJ34(;@7aWG-K&7boc_{5cczp*#Pptapjsu$S6~((K
zKRon`{_3!WlK?I*86p(j#0Pt31%2;`kjF;_*om{4VCBJW2)!ok4%uBT8~`>_V8;OX
z;2fCkEJd6D!O{Gk`?&wJp#_3%0Ip0S#N0qIIv@<k!jL}F!yU3(1UoUUanbZJm*MnR
z`0!$i#w)s;EQtZQBeBSYjdTKyi%i-Pgl!|*$($8Aq?w~6NfAsu+$Z%+-zJi`bMhJj
zi@pkx)egr=hwAtn)Ii5lG)qCW&cnO-$zxd9_Z&&^l62nyNnR<0g!lDgr(mv_g|+U(
zCZZ=R;(JD9dBubSn57>kgtM+ZwqM#j@#io>S>>-C7l=M1?2Y@daC8HweOf6-(V<9m
zfCrRxg2zUFjKHwEBpiihwVOJ1S45LMbo9m@!^3+}>EpEv(B1rAXRiA;*gbYjg%4#&
zdlc@}QCNQcbVPOTdy59DO0?oNj=lX6Uz@rz;yWCkuoc!*L`T@Ix`5GlDD$*i;oGn9
z5NB!&;TVPiqCOXubMys+!;;X?f+FSaEyo;Sp?aubC+8Y2S5p)ahH|}K%C@q)xD+hT
znGw~$P)?$V4{Ms8J_VIW_gT(;sPtgUv1aemt5WDBt1OheITXDJ5^Zr#VioC8>D=K{
zWlY5~Dr63@Hut8vS-ELn7Fl)4>!8=ur0{NAOk~pV(s`rBK$uoU3n`{DCox&YaCd9O
zc`%-`2MUd!i#B^Fdgoc{XHl2w#C6=!Acu1}jY{kimd4k93A>uEX^7;;Yt9OnJQpt6
z9LasnX%rW(FMHK@a0Yr&;`e+oD*%qbAF;q!ETW|$o!&SS{WE`38!htE(rr%T!)(S_
z7{hgWu*ZkyBN(|9owV&)PQ#rxDyyN(mpIJ3>XF+EvSi}r4p*0H`INp8YUs~ex*)I?
zLYB^4*KT}2G>7Woo;dd(GACuvCCE<BY6q;YaIm;7d4BFDbK4Eo!x(nV8PqiGav{q?
z{s>!jhD)D=05;f5Sj=hALCsj%gMOcr*T?27>VU(A<u1<ORzHs8vy>L0ytV}z+C~z&
znTI>kuhPE=%ncY0aQz#82I~F!Z52)5LWmu?4Xsyp)#;vYreU{TFG=@ZLVg@#jS(%b
zw<}7zQrn^Y9={MV%(gHJr&HRR|Jk7BgBDX)juUYiYrZ2h@Nxn}(b~lo(Z|H%;b^RL
zB8TNV9w|PxFDsI}rx-qf6butixeu-3YnF%Crcimf*ka%TJQITE!b1bxjma=~&ocJc
zyFjVt1y1V!gkZQ_7B5Gl$#DE-ry|<C#?)E;GC^)-@%V@X(bo%MRItdY8@h}J!^Xf(
z9UPX!zCqz2P-Y9r2DItx!thD7uuZa2rUQ^xfOFt_c#u<(P>#5BV$8i<STa)K6ZT@)
zf)VlpNEUBQFJy&%`-E#NCcHpLgImIrhJ#TIYg`b%HVAG}MKS$hv_T(MReIm2DiL27
zDg&aS)!R_q5NiBz^7-&EdHOIQkI@4ihR;{BKjP~X5)G^TZ6JB`2>A|#O*O!mad7=M
zwy*=_dA80e;}~zl`9l;2vy^<}Y}5<OC24?}&+M`x-{uJdzwfo<%2|z3w3oM2AJ#km
zPamcV54T*=eAfMRJo!PVzC{yXB<3|HAP<)Cd%zrwvavuHHW@|<0XssL`vHiE%r^;A
zZz$_7_3{CFImOP@uF;`RX1LV55#N9w>~F`{EYt?)+_$liJ2sEM{@dFBe9voxi}-ei
zCp;fI#cTn}34L$2r2E><K=ZPP7wxNWh9+<eopwUf42LId)0<sfCD5!aP%C^XtY~Un
zLn}3k6;1bOm2i6z97wxRUe`n`kG{nr<$3nc=r%jk=mvNta8DrOD-8LrCXSRxp@JUf
zav3wAq8r*Zl@6+vvgz~<26fF&A0zw%b=-w7B??_#XUgAQf+wi(1o$)q#6bdW$72Hg
z`Q;!S)<URh-5TKP4|_Y^V(0cd)e37>(0r?ck^YH2bNgl@u#da|GGz-qhb<|$SPbTr
zIG7_`3Mcjj!!S<w%5<mk6(~C>xv|XEk3+?a$%~E9no*Q5Ca=6k6h|;cIOI#Il8MQ?
ztzuG}^ZhfZ0wmRJkH)5n;ar#!kxJNwvlCBH5-WiD2k)WhO$d>2&s$94DGY&HskO?$
z*wNSkS6icjh(V(fZKZpew76lQv$c9~>$xcseMU4CA?x|=fN4qu>go@_%un-Bhm(CG
z;3TmR`5-0V;v60HZ4H9&;Doc{G6!Qiiq)YBSZ2Ho`sg=<!P$8eD~&3e+AuOlkI9ez
zhxWR))RuqZR;$fpnS|@qGjOXz=gwVgtfowlEm;UPd<?dDlg8N_%8JtM;YkOj`^_+}
zWmDrH`C+>OQy$SXTIv<lJUTbV0)R_v*t3bS8I2z7q&S?`OvK{`Os1Mo!=nA=-@>#w
zpJ=gt72R1gl^tU&3;aYS&xJ^@y$F8ibhXW}(f9Hq-ta1McgfLN^(-$UTE*QBqP1^!
z@e~L48FL8o*t;^BfxpW(`&#BU`>wWG&ORx&8(9DK>Dt1a#?K#+AY<J&w&+xj&!%#e
zaS__|Hp4eDI50}~<n<0b-Pe^L_N-8giM^cRE21^sG?d=yr5WAHX;hseM!EE>US<@D
z%1@qRn>~j2i)xBC_%VcrcMeNEM*UZ~J>_IIKl_S>SjpG?)H?1P<BLLR<c|TM82}m1
z*hl#WnLPpfC+mVMaLjaa`o2F?1=&M4yfJ&My8R+&WleW<8+tCWENmWpPh?%fI0oUX
zVR+sAMQ-*ve#t`gm4~B)(RO$ZzV;re-nY9SrwRL<s+jxOPt+~L?t73_=t0MbZF2|t
z*cVXrPl(2iyU&!spG{df;v)CKtmdnH(P4}wmi~L={_hr=WKSrWlb`nw-|*op^IGO<
z+?{LkAB2GjuW*dE^=vVHQoZZ-m%n3wi?2G5gw2<k%AcG(l^nCrB}W^w^aM<qKYLAU
zv^!Za>K>H)lrY4lHcNKFG)tW0>*yJ#d7TgVs$b(7PwrB^UV@Y7)yw)fS%iV03j8=P
z871PyG5axKGfJFpN<3w>#5=t5UQU;{*DH@F<&j6;Kaj^>`a!v8HZ?V#@-H#gKSLBn
zK$xvFW|1<wSsh<p;N9<SdT_J*&MuADVDpzu_e_Z%g5Tsj)N=^7tmEJ8ZZpxt(Va?L
zvoZMsz6U1S&L0?KY!9B;4%^G|Q(~HjYwYk7$Gsyagyw7i`8e40^|^iV?JTX1fNk^A
zoR_v^A@XMOvv4SR*@!LEIax3DOI79^Usun;7uBhKExn!FH@?(gj#fcm3%WX*E8Abf
zssw}E<tMz<+keqDtvmMU?`VIF^_PZKNo^T_YNqq&`a=GEE1y5tWbtS2Ab%pL?iUBU
z0gD0kh~wv`UKA<)2Y4|1THH?t%&f-jim7;p{ctt2TivJr*+elV+uST0!z^ug-!3!Z
z!-8sae`28q_641)H_2s#yUK>R3OPhbySv1OsF3yUV>UU|D#bs*2l*^$bFZ{8vU!Pd
zKn*@<^196{i;q_K77JY2?oP45^3q{|e@lFu`*q@-X))*Lt$en-6{*iysJZ6BRTwtT
zU<XDsW<wmKQaH36y3#6UXptTIItVT)r(2t|Y%C7+Jb>yVv5JVob(cwqUPigIz7tmJ
zhW2!BC0i`Ghh(};B6HXBFq&chnES*mTf-mzmYS%_4-oK(k4oQy8yj$kWMAUX$}7Zi
zXl_y2;jHL^qbqx*sq9%K+9Bf~tInFLuG5Gbd{+HyUY%py8$?@khgD_z%h}NO5vq*k
zQ9w3I*{M3`tM`N&_g(6>Vv6lgfCdPXA(J$~uuJOkK4Y3Aad*i-*_mWgKc+Zq07d)l
z#~>)E-Tg9P?oS9|a%!%$xKTbdJzCw*DDGx`mOJ?cbFT(Zk#&oE8sRjERz-skC}@wm
z)ki2e0NAQ_)A56MD8NW*W{?SSnjz;aKc}+I?IGGd%N9naEqtaj{WX*4fu<9{0j!?d
z7*z{)^G6HIuO;T!V)JX+`LzK3T8jSKGWN?}$O6N+Ulns2W!tOKY_Vf8Q|f%!w<_ov
zZ%Wy@qmbvNk!Pi&o^O{sTNVYK4Xv<r1~im#c9cPN{;DlCC#{Or<gCJ!1?iKDU^Kou
z(;Fa(Crzi9r9yPN5m3yXnhFx*1E4ndOfRI#Pi5<0_GaR~ti<VF<(Wt(&`hJmCGXiL
z#YaOsY-wBI*=iv+?G%Vsh)w6LAI?h1j9-mBI@#T+WM5ZH#wN3M{%#7Q0tn4-YEEU^
zZT-KViv2c4BrXPIbo1nGRDLI%m^Q|9`~%L!U5@{4r|oSvg4dmiN$1qRfXp2KJ5Jj>
za~=PC`<w-b_c;@4@x<@nQ0}yCU;@2^%i?#KaFxv62{q3+)6fn>klq9}ljTg??=;Ql
z1?gQ2<B0MXyX(x~5F`Pg;~!#Jk@-}glJd>x%-?T=YUZ+*rPF9^n5vI==8rfNhn$IV
z$6s^{>76-mJ97t|d9SiP*>A9U*FLAE>v(5Q+?m_u%mc6YJPJ<fzh%5LXYxD}fl4~*
zz!lw^KDIL1XWPnbXDMhlsWxY%ysnI_q&{A#(|8~A!|~_knbLb4|I~f+RF8L@dE0E;
zyv9)1m@{XCGdJnXa~=On&YWi){~J{84XXC6GxrT=UV;t4X<I*+$w7zw+4<q4%DWBW
zaMg28TR*R_>~gAJ))uv3y;Hf{X&dnI+wD{p{Z@sZ@-1*Vniow}Xe_OSaCKE@&F`H#
zQ|AK6<<3*DSAyBka&<<xD%P_8cp4E>p#KeL4j$DK&fN7H{CR(-JgV6O0Ku=Dm=<T=
z23ciH>vx(o9qGxFNSlyTA!kl@mhw4OZP`s0iBdw%{5pdAl(8pd0i;fFIyBC%Mb5<C
zJoob4!xMk>6Wv8l6?3WT4Zh!FPQAy3_HV#f(}H&XObEsZ$Ky}IVccW$V-kW1rqK-%
z)|Za-i<o*&(=xrGN7*%cT;-@r4*A)u=AuyMoz4bV3aE$4;2(~Zwp2UP9Gimf?tB#U
zT57HfPw9!2#;da_W4@5nM7G$8_;B<WT}dvBoH_3<a^}*Ed9M+ccZChx$otm4PRrKg
z0RVXJRsaxN`nTh$oa)7H$s;2BETEIe!(~(z`qA_h1^C(=vgI2SLH~hBX>0W<2y2P6
zHEOlj%Mn+wLx9el?YvKIvF~)(yq(lu4H-uQEWqYGOYwB+yaaF?_<oM(8`SL$)$MsA
z>F0T`6Zi~$%5PdHwO}I3zL}=>GZHWIj4fg+QunF>KwI%tzJ8HY`7)q<R~21n$}j%b
zBaFf$PQK5XaMXO9eGTptJ8K>!dEP0ux{UZ7s&!-Dx#oKr@5>0g@mZ&B(@Rd<o40A=
z&3;~%h^8$q&roN7!JogThWn|vQqQ68bE&uH(mZsr{TpfAMgc0431t8nk$LolzfZmI
zG@Z-zBqsakWR*D8e&jWqd?)ToWNY#YKhEQJH7S^<xVYjRH8n3L1TweZALuXcFYasY
z?J_@{9X!*Ukk5lPJKetZgs$&>rZ3)K+xuc%k4K!JxAb-HbOX-MHCfk`uWG5jvA^~e
z%kWRDvDEdg?_c)_osYm~wI*pwMAvkWLeazu*YDMq*Vo#=E@t7HI}Dtmd2ky6Gf5FO
zf5R2qk&-xm9iYeG#N|NYOE2<YR@(d$Ux!$+5K!c<yg$t8+r+(KeY<ecFko&6>(rfK
zeb4mQ4)#5h3O-QRXM?-?UFV0Fk_nTVAorH@`fCf31J;op8Ca;KBb#vMI2mm0>+0*I
zE7o<}YTqM*z%z}AU=P*wm?A<Y+vvn~0~ThrYhaApDY`VUT@+DM@Y0L)M5F}c_wBZE
z94;o=AlsVl6t;=tD6;08FZK3y^{=ZVrPqqaDDSC;(7wf~)_pe>Xj+FcR+gIPG@YP9
zU$=%-`x}2{(q=R=p-R%Hea!Ic@f1c&6LQGZziyDfjAZjLPwD(Ka103}qzLssJ|Q~$
zHdf!#fBiH4>#`_C&^bKEKr6yRSAV7d`riI^`5vSc?#4hW!h`%||Mjo*uPgK*#jO~H
z3|+8V5f!;zHP_NNjAWb&^=;JKb9z&&fB2f-Of1_oZ#uZ8Cj5>>U-r$jeOWJd0$W?x
zw{b_;j*UB7cJOfr^INmP{C}z6%s7}VKF1%<cZx&&vLFYwvN+H8*XHjJP8u_5yb0wr
zZ5G|~@BHascLx>N-zb%{F`#yIzRikFTmw<oUpsw&uyibh+SK%EAo^>|_6NgbBhBDW
zGLf_Q2dl<Ls^v{5n8=0ugWnkwnRt`p#*kCS-n;&dLRLfyVL(?sbO+7kd4HXK-m};~
zS1+{BX1Y-Ejb%KY;&s!_<1q~m`yTu8KF5EMH%`->yP<kEy60_4okK;-ceoSnw>h$!
zfa7hz03<!9b@%Na0}tl$<5-Ri;3bbh@eS~c5wM=$v+kzHOkj6P$yYkOL6?iUxPK5O
z=g`I6>L`4~KUkVvw}sQzh7)M4Xh%SY1=>)H8y=jme*Z7FRS}q+!5m_^B@6=X>MOba
zV0@6xp`-dV&fxjPp6<osYiE2gzvd=_;ra&sHkhzN5q+dC_%x|?w1;ncQFw~P;uRMM
zr#t@1=MsU2dSp`9QYb6-_&Ht9oQ=*L`mH!v26zZ?V9T62r~<_zlRB1i3Gy7&mgaRj
z^M-MDuWdL+-m|IX^ARf96saT)*Em&-j}Vx*hCs;3>a&#PLZZKIqn-I%fLQ1>LjRay
z)VdBet=4+S`<w0!9&gsV8qrDO<}3i=YHNwpL<HRzuT~JvsGtnnv8H-7V4pLGv(=nd
zXHExGBOkEPxy@SgBr;#Lgccui=F#YR*fME?Y;uq99y>wyZDwfwxG?4f`GfW5of%c|
zF3Qd(Y^&no?khdN4!4B>An0^6fqs`xA9Meo-;L&Vw@t^cKX;AeKhE)A!P35x-w9mA
z==jYfcKl{albf00JiQt3_f~-4TM>S5h4{^i0Y7LViQ&g}J5J*iRw2D-q$E7AS<IjN
zg%fx_w1%fAD4<IjoaGwtrqy>59>xV<(>)KEH(e%+C}#XUN>Jw9**>%rU9!#Lk`^g-
zj9;z%<mVY>IY_-5pt-Ko{m)477~{pn$gv|cneD7%d}AHZ0@JNyaSVj?4t;SQzyGnl
z+?m}9*UDM-3TT2lHa`M1b<_$<4ZDK8h2+n>>dU??Gwhs(wlUZ-A{p!sJuWu;Ideg>
zRXgNdNIQoKySm%Pn+LiwXEyf|pgFMzlrmr=&Ew2QZBkA{FW8hR6;BAa9)Z6C^X!eX
zCV}TEj=I;*=1)x-f3D{&U;M2?{#=vKpSkM&$RK}&OKQ7;f=;~gkQg6W{28X20$SXj
zsSsR*7Tk3O#9P4WZ*gxh{3H2vfrIj>;!W^;1p|q)CnxZqDO`?UIH9+=P4)}!C{bsh
zfJSMtWkSW|EH>JM3)e*r2hOQ3#wFfm_y(<BzKH81jGNNf(?iUl;`U}t+Oz6P_BRY4
zxAe2gZ&(MjPZPDWVdqF@WI>WEpAIy%@5u;U@|o!2p&hDAJi6Dd9X#x@cxVCN*Xvu1
z^TWxHmF$0--mWvC?sIHDYErLZpD$af1w^w~)~*4(-F?i99x&1KiKgqi#kIMc7#&Bo
zZg1z^ux38z0T4ROFXq+|Lkf>cd76zz1nJlA(C*H&nTQp%-aW9wz$#&zdx=e`{M+5n
zD1T1xZSM2HxP_x}E$%7yV;J_)wSsPQ9|dM;2aR6-)?pPssO;IP+T5QKqi=YfZveW%
zy;a%ue9Dvy5zyvt;2m&ySbwjmKiJP}+ua3xl4TKDs)JyOw26!LREqQTCsXvTz?<`4
z%~MX(3&#s{wz>ac1D&Qe0sw1qzd;CUot@6KI0QG!*g0If?C+(n?KPhOBIeHY(irY&
zt2-_A853vp6E>fidzym%GX_xYbmp|VYisTBsCK<sQSQ2cqBG1Zus|F6wz_{lpA>*L
z11hlAG;h%|v}9bGvxn;h82#EcP9uzaEeY(7Q(VoFTWHk}zNqj~-YdF{CipW1r?|Dz
z?UpIV=4JU}PfD5-c!Igd(k$;1&x-oydX~emQCk(>V)(G-*sZ}U>dta6pvF|jtg^UU
zq%WqcR&JZdHRiT_&ki5eWEqb00JIL<-TlQT@v!3JhHZH#(C$uxHIGe~Y~e#g-r_D-
zT&q6Cw){D5R0%EaLc&wy{CiCv?N)I&Yzu}tQZ=M;E>-eXB)7{V<}O!OVwazznE!6e
zA-{Y+VO0L!I^G@O-%6+PS6)xIfG+T6Y`Sx`?PXz*RM7W5uu-n~7(RADI9%NrPj{oo
zMQ%qKJvNpji6*~+!mX@CU~Y%scCMNibD!jkWvniUyVu;}O)X)!H6C2d^xuySoLOWs
zcZP+t4B_R(q`Ud=`5>>#7Iy+L?gBnxTWqmCeE8<k9)3hYhB53C>MdWG!R>A@-|o4l
zIKv!1U0K3<ai3PiiM9ax_Ypqn-$#;HY3dr*<;X~$c(AlHmgNq7(##5Bi<rBW4@R)f
zy_r<0QC@3Wwl)>@4V&RwFZzqeHJt!U3ksyRoAw0<_@kZ1uRX`F-N&ze$gdsAuf54%
zI~$r|fRQmux)Ko?`RTOS&F8|@xEV199(rLmmc*Bzu+RBMNAe_uN;yzF%roxLdw+Qw
z41gF}X3+B=VGE=(8~MS9q>G1no7{4_s7HuzNICyT9vfL1aM-%xux)qd^r=41+#Y8h
zBnOV6kh`8%#=@;W8xzt?*~gYS>xS#w|DIWFcO!PMC1)f*J5y%fPit<cH!tmLXP}J>
zKP2c(97uk-p}l@I&8ynKG$f$eOR+_zZkk})%|2s4#nBy5N_H`4G#|5@DWN7#jNB7i
zqX`yqC7jL83Z)+nwg3lI#tFD~gV`Wnc-<7E{mi8GpgWmV7K*Ze2Mk$Fn7bC%aqubF
zd0XIWu63GvSc!&V)1jC7v2tgcTQl+IlMRROA5A2T<p!-+XT`xx<}27(qrE4Sc`P~&
z$KJXr!D*EB6imGpX1&sbaCiBOi`5@{5yl8>G~%XO$%CsdGsl2Y2JaRIbE{^uGq>HD
z*D}hb#(TMrATwSFkYXMap~LH>ZF=_5e3;bv1t*aqOM~|b5hJcKi<~}OAQ8}By5WI@
z%$e#LWuY()1nX2YiRQ)G6ilT>-$K>x0B^78O9e_llk-dsH2@xl-LmZO@~(SD>UjcR
zRO)?C(KFyA*GsxPakClC9;dBmE`!;_!G*d|<q44a6AwF8V1^;5ZHUMPL&WT%mTQvd
zl3#X$Q!FQu>^(fyPDJVxY7Mp-1n3dI7LT*c>W{FpS<f+=kQVwI`=F!bz27PmISLvm
zo?9q#6x2}62{Uzl0rQ!j5{KC@Qw%YHo7a#l-`RIlOP(+X=SWUBC(cI??86?h4`Hm%
z>D}vmgTT2UZ<Z#OBrvaAQQ5pORDVczBh}|M_Sbxc3+(KTGuRsT*0*jt#4^>KtkW_r
zN?w*y#T{IU7AxMqf7)8#s?kgXEj_1Xgt-WJl9kt+oLAo}D~WV88VWl(shD+p&~0-K
z*@@nTS-A(@$Gm_J2H)RnvWV_XPRPvik2F}ss6WO9wN?1P06pww0q>$aDhFunW`(n#
z``h$lZl2`j+Vw*_qX*qNUIFxijgO^Lz$;!5H-Lam1&sVA%<YCNA5=xmGVXSo?llWk
zjMqEO8=Q1j@<7e0HzVW~vmVYX10f+%n77gXq8zSunApZM@6Ag!SPYbN<K*LJ>3ta|
zt;Jg(Wj=#8XK#T|ym(QB6`jfP?+%xCEUi*-hirNHs34Pq9-CSAugr6v{JS#^0!{&Q
zLH)2ecBMM9pL$mH623s;c})fyZ8y#3gpOuR1G6lj(u`t$a3M~Y)9_m}zpmGn%wEX9
z5CXHD#`yD!l#8$fEy%mbWVyIUt?1!b@OcyPRwpITnS7!?SWnEwiTg=Ywa>8P12p?e
zDr5!(K0LC51$)VUkT4kN#WicpiacLUP*=~%#>I)rD7!;1EMhgRoj-7ZfQ>o%S<VD|
zYPYH#Or;<z*{|i~*TV8^iTS@ZMvgo7_-OT??FsU>aig2244|4C7ZP%W326WM{p(&4
zo!#&6U)O71it!o@gZN!O;56>i`(WxF&iY0DwF|{zFYjl!k0#(d%&uq-E_9b*F^22j
z{&g&92svYn2d7?Np_!u4s~4aNc|EGsIDhVcNM-duq@w#DQufX&N04aT%3-T+CO^`5
zD>trpJ$Z7B6J!_O3s_80+}di(6J@juCQj*QtK2^+UJvtaWM%RMbg+Rxy0Faj&i8#J
zk9H6B_CI9W4CCAI1Dl#FDFuFkzIM9K-SPhG%lp?Y<V$jaZ`&u>#0236SgOu}!Y=M^
zXK$0C`sK|h<pSCl=t))wB-E-mo^P>!y*W_2)%npcn2{CH#ybEF6!&0SfF~ODhXN8y
z`9lkz1g6e7WVdSJao<(V6SD$;q(ie%>)Re^*f$Fs#4>#RR5<I<*P-KdGhO-Cz#q$i
z2^Me7EP3Uv-aU1FrSaM;ZHp~ee!s_$&kkRVcjW9Z@i&nqgD2?0k@8~TSInl0t8b%T
zxQeLbp@01k=`FE=SA3oXinlpG`sIndV;uFP_jsXwYXAt~exLR|z-#|Q3NV%nFnKO(
zKIsguQDMne&_C!+vuSaWH&=jnVk`etH`kKto;?%_N96OVZg<8t^Ts&fp$^>UqF)#f
zkHjD@fQw9$K5KkdcxY>6%0|q<7gOG%_QvHrRJ=aDmP_ccKlt6cQDKQU@tFkOfR#5j
z_wry8=nGb~Cc#BWMij>+aP3o*KtV@N0<M@FGYLMIITR~yG?U;C>V(JMXrokFylHSc
zul)}xAn~_k@jqwe|0!eSuNW&w$(~!PG5;EW6K_zTj4}V(OT8NP9O}ZTXYtU#{)hCI
zSkJ3&Ike;cVvaZN7v`FA7xS>(*Rd$t=;y8fA$=$0)#4b#&W)h)lQihMP7SS8jitE^
zeiviDC2$dZ(L1>m4u8p>r{q|A$U~FR^S>{~kn8Htis<S=x{V<p=AokXiI~DjFjC?t
zE5|T$G;|D7i@&!M6}XK%;(eXH8<8IJ*1Jctu-R%%l#ApflQF~Jw7Qb8il$~o31lHp
z1V`WI0m;h(6>8ukG^x*Nc!(N+4^C#*><RR|S^as5lr3)n9_5O~!O}M8N9r8Sh2}d*
z7A$U2&)>x>D1pC;?~sSgTAlkk!2)OH2L9w>fqnAxk3Ecs1^R>(EEd=i_){5~28(x$
zDR1Q+-elMV8elTSfZ5;3>O-=V9s0Z`!x#CR*hh#r8Gu|d$4rKMZd0Q`0X*~%6rkE|
z<W-YlC|KO?{OARObl1X<J_B->=?LEepJ~wpyn+Oj=BK0y4DFy}rh^0my5g^*BP{o=
z77c6()OBe_;NtoZD47ShnknJk5W7Ek5oG_JZA=cFYj8iP&_GvsB%VS81mD-ioY)qb
zvJJzV#gr&Cz(W<#r{;uMz+iz!acnXXf!PgupOpxCN1}JHM!1_K8voz%EN@!f%Y*S(
zsA30rGX5@)^!O{xjDH<3A3FXz5Sj7Mr_;RgKizDR3P@Z+9{)d#|2JRS&VNLN>Wu-a
zu)i^3`Xc+%8JY=~@Ye{T5i8~+Uxrx8PkfC{Gh=30G;vQ3)fAfGp?{zW)mv71qch_z
zBFxMvH`BSf5D?s12~F?@noyFj5O>Up0itLzh=SV+g(zZXR&)gF1}vf=%tI7$CWU;7
zq$h<%6df6ef<6_Z;Gx0?d8!-4%-5vo<C!rj5}G8)-8^?CoyG|a#!uyl2AgA~)x}}u
z(R(_0?SDuCiQmKHKURt|n(CzpnYJq+S*dGZ_ZYYOy5|FL6g|P*on*UiEg6E`9x=J=
zZ(<&~r@%e$Ddlkw`XVw5MH{D^ob^{K5c$m1+CnKoXc(QQdUAodX}X0c!s5=IiJG%-
zKFbK4e;$`CTDlVDt9b3>PR}0+ss(IFZeX&;N)-VH<T2_mB`nt%E#VT(G&W+CP(4*@
z5({mLd%kTzjVs150-vVG6cH{t9Le3`Gz#6MXp+TVg5{$Lz^4igPr_DPl)p&RIuGo&
zF<=TcV7~y&Dqo-sjTVIwgwYm;md!46Xr=QJBN?sg;9>3lxW48B6B^2G=f(&Wqv;YO
z&KGICzp;319^NL>YBmwDMqhT;XH(MoSYOu;v<!B1@!TZ|eYc4I#CUS3KWI)ccOndZ
zd?VJ|u~6xO$fOQTuL^q%qhyB~ODEo8>eqZ1k2Ho+7#PN=1#s?ZO?RPC(i)SX@c|y`
z1~oM+6#peSd_r$y1O0+xMn3hhZJIQ;O-2{SX0tXkn+w)GqHO4w4cog=E%#I>)GN71
z<Pb**2NfN*(r3}kq5T_obnZx~4|IxKlRVLCC+P3d8Vj&bq^*z=X~K}u!NxEc<>pPQ
zEvYFpNZa=tr=09!-=8krRmWf9E~_Cipfbe;8A$%btV!I?asRSe#Tduy2Il4%l@FRr
zA69qp$|~k>;?HQ;A1g%}i^5A0;<f)F1tcCo*rk=(M-dRJ`^`e`2<C2MAwRa3JlPZ<
zF$L&vVig6Xz*7r3=0RUXep<*TbNx+xnas_}5B;c7F9Vz0Yd$MTtoTxQ(aufD6K5-r
zQF)?i6-UqeRXERk*4XFjJM6Q$&ORF#^F$Q7&^#WSt%v_zPN8s5VKi`yO>`5FsplaQ
zv24|6jWPo&m&K8Vp(g!;-`1fIcLHL8@K1i7w}&RREGgyayBJY1zu@u;3xo9|F=y#3
z7w0LMN8$XTvtm+g34B_tqPEoNiD0#koIpMHVGPtTp2X&VdKk+*9XA7PGBw|@=S?t|
zz`cWI#)Tj{R0jSufin)59R-?irG0fJBRW=oA-TwS6X*-!ooG@#P`^!!bPUL8$;$)v
zZ8~CR1}~Xb9vvFmX*fd%+%tO(?-kB$d-Q;t$Cvog(V=8c$w)wsuImKIuhZ>**vb(A
zg&X9?`GjRjREztVwJne&hs_Px`z)-4d4gS?hHZ7Dzyj0d4z?g5+)1fFeZka$JEx7c
zCTUC_3vC_)%2b)mPG_>-edXW0OnyTqWHHBNfe{BomY=d>WFW18AE)2C0oa(k!V{3w
zmPy@CLygczapM|webed(^qA5TYFMWL?kL;teE(}eF#A@E1_MNow17Sq#;h3I-e@0c
zE=&HdBDbabbiu|fta*%It$m>83c?$;Ws`@5@3t5P*kT@M@;k+k4Oj@*LU6dQxVTYa
zsrudlm~tAlaKjcZRI=UEAAzbMmn`N8mCWH0#z9R<Z^igVg+X-00y*7*x?zt0lL;WJ
zNFle+PqP9-&lT1Wjw1@z=yYN(9UG&HQNVNnnAsQUfjMDGpXyYmuX8O|g<WZUN|R&q
z_D}h;;3aOY9w#|dXneDh!&v<#;jo<$6wG-(=*;Uj@%_#mq|$R<f}bTBgjA6_-O7hj
zvOFXso87SalqkX7@e4Brk-dJC+!XR@MOu|58MJh|XA%Gc(5yt*ve_MPQ}Y>f|237o
z&3*epla4(v5=&e|4Fv!LZUfA29?z0z8BPmAblL0x3)pb<pgXf<b(rcod4~X~GBa!f
zVf0UPzKOGnIi}O-358L&g2yqdq>HwDUEt5Yl>qvtLtO!KD^%KZ8~r@!DSVNse-&u^
z)R{A^PNdIXu(g){m)c`&Hwfx-3(Th$xqG6q>gYgH;*R{rG<uC)a2wsX^lfwr)LmWf
zPV;Sgx_XVGOsY<simfrSCOLy@=Dh%!LFsurd6LlT2mR854JbegM?bdT>~8qpNa^{d
zc1_3cp>B_T<u`bpzVYz9-^2TUZy)e``-0!>6YRO#KGH(H44$Kr2Q<84?-NQh{L#R0
zuN!ZrkBCUxqle>fo>u1kVTX}chloL*A+3PB#j+`k*B|<crv5+2ayn|RX*jfU$rl>h
zd=0OjgIVp$tmvMtZsTxu5HZM%_ZTAt7&R}JbmGq|6o)%jHv+&x-!K=1IydZ1o-MF#
z9$4?t3z$!anzK7iK>memHHVj9qrSF0R(48ze~j0rx$rdQO*$q6!PC52{(*a(?q<jk
zT~XJAs;h2?3+8a-81_}qYB;!ZNg3x?oNzy>8gG5Qv8B40iey*WiUh}jY#PZS)Gf(%
z-AG{Tu&*UBr5k?o4KeDFb4{zj&-cKyhPvY}_0F4Y>piaC!XQsI^@FD!lUpAAX+Z}f
z1PRq2xB#jM2BcLvpT->dIpwW3!nRdC)w5tt7rgLESvKb9>50JPyVFtMM^I4Ng$SX8
zyHh~M%che7s`t~7!BobV<?uKA5rLaJ@`c?%Cj3p^a<mt7eulhaLIesU`-irWaVR3H
zSs8OhuZCW+){{^UaGynvMF!os9Yovb2;rLP+u=5x1>^Smf&NP^ITJz&&8ElScl{f8
z8OR6EtK-S6<5z>S+aOrv5$KJzp=f(3{?>Hs&^=T?azhy{%VF#j7EPcakD3&yBo_J;
zs7C*!X^D7Z(A#u$&f^~rk|)KNeoUP;fty3wf}Z4kxgXNG`Vq%J^Px`|v?#=P@;_=;
zZFYbCFM7`W9Wlu%y!>z!<aQIa*?q0afYh0oP403N+<|y;7J6foK!IyS7UL~qK%^>9
z7sQgRB%+(v@r(4z6Rdph;Bx}U57RBlBbODp&%Ud*5JcYQ)=^B|Az#fo2t3X+WvP>D
zrT44;lNnfIfvL(-;pt(^u%G^?k1<3ik<k78)oJT##ZQ-YGxJ7^hUrLO)*smJglFCK
zNh69absA*grTKj&wP5)M-$m@29pr;Kf{kwdfh}LVr3}3|19o++{=mx{Pc3t96{jGz
z5{?I&sW*;!hVTqjsR_M;9f5Dn;ewmZd;VnmtU_#9IeD3l2Uha5s=OP_cO~WtRV~C5
zc6AJE@4qA1)?^<6M0y2OnL;MnOiUpK<~@J1ecD1M*mzSwo_QZzK&p+~N_Lkmy-+38
zAK3Yqhs&0IA=Ng=rWzMdHn5a#`wyC}Wtu~9LKgp4n7r&9WW7Qb^q9azEzpSU&hr4f
zm5)&K+(9?F`S3`?!11IHva<5tz^o(m-@qTfj*$ULzM6n$iA&B%i;VbcJ5MZRCbI0S
z3dR%9H#R4g1&)13#5a*&mCRfam=(}{3xozXvd7VbxI$5tRF!!qbB&D=WFk!SGY(bC
zppy*petWLToPsLz{=>c_Hk`<>O0ZO-09<5o%n_OA=j}2H7O3XxYYB=aeCy-AmrNM5
zs_e*U0oh*}TYzA}js@PpSMt2t>&*-trTM&2^LZgMyxKtt@&+VAjN$X9P*<|A49z?=
zB{A!!DKqa~^TkV-PE)hnO+O)TrPs5s<|851wV5L$Z>@B0wWGNpmN=O(>X7an>J5_3
zpB(mjnVcs7#nzcNRZcEVhvyf~u<yGFFDkL`TS#xdi|zMr;xGoP+C^Vz-e%X67k#3B
z$}0edaBOrma`^?1nQ|6T{sQ$2Fa`9f`lK?R_zrtLbE(7KxhXZ5B1$C@yy<Sn)6aNU
zwKBo({_5BX_A<rr^G`k57LT1%6|*FNhW)O@tjs_2R1>%0J;E^~tHOS(a;A;<EBydr
zvgJZuqF_B$;+J3aAAe)!4o%FTx}SIA-=X?%^Lvw@%2A!Pm#HZm__ZbOW%U4<u2ii_
zSe34n{kD~=H*sStW#f-ssmU3Y`rD6KDOO*05ZHu|%Bf`!Oi8t@vgkhh-b$sD^aMZu
zjJpWq{cU=M-m5g<v=oVa!G2oFBsB|y*5?=fqfO6bs2ZdvUgb%TRb_wAgfGw}p*I(F
zB<d`ZDf*O608nMoC++)~!p|fuvv7SMt8mB09Z|Rnt;#+GJ)J6?9>}}g<SWuOO^7XI
zi$4~9@SHZEO#0xzai!?7=!1r|e}>=y?1cd~dUtfA$G=Kw%AT|x1ukeh!VqQp=X(lI
zNEM~ArI)0lvtS?J*Ez1Dd7LkGH~feb;UZ*@K*-AB9{FWoBt9pM!}NrXBl7Kphea<>
zFb3-4GfXzAgY(BY*rf{{#yL$ap}o&(+`?bH6H|+X9K1o`O@}VK9O~til#iLWR+@qy
zAbPFulB}%aj)vjI%W@zv6SAyM)l!GkE$Mc_1MP-M4nIY#YxuJG8BX0;jT_qFPP_o(
zK4x{Rcw7&`6~hSv!W3Lk1?3~LV_d4{BTfY-CfvsG1P#@{9JFbcoS-TtNBu@CuqM}B
zxkp=Kp{FgZ9H$+GhytPB(Bl3RTu+Nyr?jQjO-4ex;vzA_QlmGWf&W1C04{;X8J9NC
zy9AFw$yyTw{d++4?~?Zeq~~>G4L3+se;L*f1k;{b<;{Vbx_AlN0?z$=0}T=wbmCAM
z?i~KiabFhPld1}6t)%Bk^>BGH?v8d(haW|m$#J@ZA~a<<#69yk+m!Q7^fbhBGk!SI
zl#|_5{*&~2%?acO^~{nk_?1~z`FVPN7}c)bGro*umD%4H_%W$=L#?w8AsA!d{b!2F
z{%RUNV>>kV!-d)p3*CQu?{JF#n>|YZ={zF!z#m>^Q0<DAsE#hto)jT?)q}siY}quc
zljr<^b2rq?=}R8H3}uN}<CcJPmrf`(m!QIyJ#aQiF((Ca>9Ps+2Yy`8IP0d%qb&`4
zeZ?)wN@bH(>fDNa5QPs8Dr~38Z#8cDZlM$dA0WLP#Xw<3#&LA3Kk)lKn=f;IpoOUT
ze>Cw`9nl#3)>hankfbNo?{hwlTHX0u1aX6fKob!4Nr<8A_@)Rc3bOMN!Y{vQwuO2b
zsG^YfZlV{w2*^f(%rL<V0J-)Vr3RE-D)W4Vqa#%e#x`S<xFn9+B_+QC!^i@0isB{v
z1p+8K1(=#v(x)}{vp>8}{XKdREQCOrmFo2K&%L#5*?H=%L9{8wNFq)4TC!X=hq2E4
zciyyXi1fZ}+O}ECK2d+*KYlqlYgwgYA0QT#jnP@&V+etnOee9Ue!3^gZ9G|7(=T;y
zl{}&ZDo!UwMqsv5U1#!~*0Bs*f%!6EE~vC2-8bEte83w*QtYL#1%HJt#mrbrE4a)+
zi#%EY9cbwc;EFzL;mig#E#v+CjQ3Auy#I~&Zu401B6&lw<`<o8!WWRwwa=&wnnhWa
zc|Sf&L*lG@1E!PdlY|>XiH;#yPK?@TLcIYv*8X&%?}+`WHSfRnr~l3Or+5Ev*q_qp
zclXgD*-m91;<K{ey=++_D<FlwUuWIV<ahb^{zeFU1W{o!U)LaKU9eRAx$Jd>0H25h
z#Kuwr@TslHF);*#dA_QrhBIt_-rYc@5cRtt3r<P}t<Derkwion)S2i?P8%z_8)7-)
z#Eq+u%Xc}Xz=a|n(1ornxCXF>0SEMoqYRF6&3UI?AZ(RC5u#GZPELh>(VheRUWA5?
zK|p7Jic}EM*%z3njw*_;#3e()D?A0i%iyo8aTF4FE5dfG<A7_n#SH#n3fY=onq<3(
zW1;DuPpEqeDPnB*>^OZaQm2ci9@Rx>s*BbFnd&0#Wu}X6YE$?8!bE*&_pAVHZ1)V8
ze0cX%kV@S%$2>o*dn|o1hF&oINkb4UI%0!L_1DN-x0fw5tf4!~aGwYP5^#PN3#{s{
zzEJzZai(N%e`J5k%DUqcr$PJ;;p7)j8^y`CbU_TRTym<?euA_q*KIad<V}RAg5Q~h
z)4G?QCBTRHB0IAI{L033)Esw9f#QB);;tp`YUUZFg!VJ`PXt=ugaIIsTfOAke>)o7
zIxfkGw!{zSkY(Ny6Ssg%AjZKB9cTJ{L3s{w`FYoxII)!~^R71U`4fH2I1}&{0+_Ml
z#+dK01=dV9-vRs0W>%>U(jy=)eo~uNe%>EX)zq?qDPn<vIo5u)>LA2i=6UKA4p{$n
zp8DVUJXQaH%YNmZM|^vbrO(O!!bJRe-hX-eM3RY(Jo~db*+l>u3~ubvj`%h%WlnS+
z|7wmE$9kUHGvTw->7`pgD(|X+`6Baa9O7|rZ2Zj=qx%|OKF3{z88S#CL&CMF;m{-_
z-@3%-tdf|U0B6Z}5OX<??{9e3`J=Ws1X;;Njfb37w+lcfh?B`k`|9dbXk_d%QK%bY
zGRS=s$-tW#5`tdm>2{Qd;;u8L<H;;$!l+Pe{obr(z~r_Wt6t^yCFQo{19I!e%U|Qj
z6IoBelL$lq;`vV*z^l<YH&bAiu^)b9c^TKou3U22k@B)nsb-I!tZi>XaGZ=d<HP63
zj8@XJ1IWq(zF2TdToN-6%PB#fmq3<jp!!$YAhQ<}mfD$)iT}7EY%Kme?%4S6uaGyr
z$4DZt`A^B4rlsXg=cVLL>)<aT+L4^;m;YepO<(vv&-o)p)^zV^^tlQK>=pwy^G*}9
z$vw#gf2gb}e59-ikI&rDk+SN6kuyPeG$NVz)fus4sA1R_YUs;y{-rf%tAtO-Q|_w%
zYMj>{EnI>jJ<-(XsHnvMKnj+*g2j)YE&ju7g#4NQ@%Ca%<{swICZ}K+E+WW5`2H6H
z=nUw=VHr`unQ3$T2(xmX%69Sm-Q}~?HDg`1%}&vGoUaAUk25R=m1OQ*-NK&B5%}tu
z2Q^wlProX436~KX7@2`{<6d(*$GL>AJt~iOLjS<2g0aQlo32jr#BhEF5z#ezBdcLg
z_Mri|^mFn-Hduk2cZ&I*hAlk@?rAMhDrfNQ;(0R9y)~b@xtPj|(?6KZ(Hr#@TUaZ0
z0Fj?oZJ8&&PhAN&Fso!gwHoRfiW@V!%5)WLzG`I4yH2Vu$E2h$EDMw7FZ<Fg&$=)Q
z7F!2WPHG%!sg%S5b%!npIhUcL)lre#9eCn6kWjF=FL^E;w&dAqU|4`A-u6bIJ}x-5
zS$9K4HwK2b28LQqg_h})dl~4inhFC!js7;XMj`1>=^vSH3vmzJ6VPY;Q;mAC7_c?s
zg2lb)jr~all^5?wo}IeP$f>KCvYi-jU`$QqznqH%k{6bA%B*2%TVSZo)aGV=+MB9s
zA_nH=ld8Xk1x|muf6}#)NAS%4!6`WGSyiWk4vORs!i_ckgIP^-O1jqcYX>o2n*;T&
zrpD1eop=WI=O7c}hFH08Q*>`}SHr=-ugx9W?tbBs!z0Oj8I*SCiGWOI_nPO8oA80M
znMqJ!za?Q4XT?bGu~3sAwgLoA3l8zVi%A1#q-rz29ZVicc%I{lJ3J#ZP@J6oA*u0W
z<)+Cs9}(fSeKjZFOxftR?R6i0`0z-g;XT7e*<?8^3p6E>K`bEu1<J3RZ_2O)EMW-b
zRQ3XnV2WQbOx!{8J;c;LPYa{t0bk9TdN~j(k-o#Fx*-#v{P3IABf3ax#U8B>c<$Wj
zjHMaVrFtTkW@jM^uRa^TZ#-MppvlwmpH#ZJfa$R^d6Ky~IhifaV4ZJpraJn2Qz%>g
z(iR1`9Jy=~TYsz5F`9Gos&iCqQRm^bK4$$J;?1XYEs-Lky{b!^&~}iOUF~}LtgBty
zF9qO8w|fvLR;=6p>(}?!4oLgKbxp`{|MkEi!$mt{n+fSQ3wpEbH`zzlaL{%a96Aiy
zzQ(9YP%k!z+I-~us)5m%$hhya{tcr;HmU=9zvvLq>OE`h)A-(zE>)fV4lbth3#t5U
z1|96XCiJvc7yr=voBIH~eBDFB9Vzz0T62C!+_Hwf!)jr`BsWSb$S|alx%37uQSf%c
zNJnT2*PeE8+rxCszRiudKagS#Y8Wxf>gJXM6dkVVl{5Q0b%7JtKuQBAkkeE12}&@6
z9WFm`L%D6voiX%9S;;`=v>5ZdX0mcu-YP`DiGHC4wF^;q3NAJ}Po{n7JlUt$esrGr
zrt{QILY526J!6T||E^rx{<>UR>Bd2nH~7uv&YccgB1b~3b}ApRibOS+|8->~Zg13;
zKE3Kw;r6(}?R31e>Rz=p<*~$RG=ie^odqbkf}yyNp!#OLI`{SEgJrqeWN4Odu#LZ(
z51QlZr~R|S4V%hXR!D}10?k+Y!fCk<cZhR^Yd=z@V96^8QxK$Z*J1F*iYcvuy2Cey
zoy%X0@T<r@loGETo)ya77+8B8%Co`Z!Q@mBWYV8Pg+k~X$3muj49AqBB6<xA>Y5yT
z4dV3CeZw@ioyK~5hrSy{O{Z|aq;owLQ~J1d!1jt~Pm>R#;6B~`v&?-!FYB{EBrB?h
zjcPH%p&e|2qZ>}elx?072ui|6w>#KFgSic8d)=WMX)Do}Zwlw`9c@K8x9d-;JX?@I
zU7b1-r0zvMJPS{XY(`X?Z4pR$o2#Y5k$i6MKHYAT)7egC2syMRFw`PYXO#@E6l6~?
zPUDZ&UKG*vj|r{zvIlap@-K-{E*M8@gt@DVOFy*Ty{r*78(G-4m!@!G*VsLuboaNg
z@0avjX<0X&(poV^+w6@Y=kl%mTJdE#+F%4`kO5|Z`;x_BZ*$hQj%o4f;aQ}}Y%=zK
zTBi9NZ3?+N!_SH+EcdlV_mmeS&v}^!)H*|bEJwHH*9LDUKaPWk6Fvr6Ja2}>gVcGa
z>C?Dg>U3{`;3W*)DOXHg?)aNL#pdf4jg8p5Ov_wenczqHJKf7{Lg`=IfF1x$jNhh|
z^B2WzbRQ>%GK{LW2{^%~9pJ;N*uDc<3q;J;Vx#+KzHNe-+xIP75rE|du*>bR0m@qe
z9qxQva+mvC4>Z-dd(+vpxIeaWroPe#{XXB)P%REl2airS8GYPVG~F48YeuWFmv^ct
zjdD|q-RZbi_jBYGI+r^~xW|Zlr#wPOcgzfiCJisSSmE3s_Hp)$GLT$ZXnZhKQ$#j2
zc#}H}+svxH#-n@O6Mv;~L$KAB_-{yn0qS%YwU{t_+ud}}T>LyX@z1ahbuTrKjZD^t
zP8Q<`a_P0w*e~u#PSo{J{ozT6?Y^FE?pXH?(myjb@xFJ3dkcj}asBaEZ2|KhIQ-XV
zQcoj|f6CNhK?+7XD_9>jZpi?hfU6t^q0K$d`?!Jw{}5E&hQnFW;YB5b%g>~3?g@&u
zp5qVgRH}C8OGC*M7GZB08sfOVpXsj+i>xi}FaI4l3`x2v`QgpyLuGZ|e1_<!nErG^
zUoAfYUmG1s2d3%r6Crjy$ro?wi!es@0in1IL4&oNdvn12y;ufj10m<>h$}0zLAE+>
zO>>^!65{rcoc;trJ;{@dieh|~T$W;((|-|XlS0|?q~1mkSG;AM-<ip%Y(`>fRRmEX
zkP)0r4`keXgaT&-oy{|Jf`vZl4xJn9jaW;9NwK9|QsT)}rBO<j&=J@0L&Xv=dQdOJ
z72GXU(zg6;&^01{jxyEHXy1-B#+OeBm$pVGb=3Yb`BVgE!|#)iRg`ksWW4s*$=`Uj
zw)ef1>BL%g#Q1(?N5=S;dmkF#5smNutmxpPl3_c(pHQqF-!lzhYJAao{_yeDB$}ep
zog{G%KhNLNHSy%f7}?_)PTLEdX4CV*Z|1|<N6iNk<!U~_1(%vwYEGmE=@|22rkM|)
z|DgGBLVtqUaAImU9Ahs0XUBiZiIy2|NBR9`!pE3*AAJrydgL5flYClp;AhFT-W<3+
z`CH9b_!UQuzB}*5^mu;RyfO#9`?!<Sgd9g#>Jc0UGd_69=bo*2xi4P*2_vCviNAgt
z2GNW$YTjt1v(0BgNVWuXjQ5F}6A?e5z;G@6it^@@vI3=@%Sy=r4jor`_n?4q0hgTy
z*mofy0&==ghehs|>X328ub>VEm6vW=d2{kQXH_rRbCXWIWJ`Qk?(&T5bQawKQ^?o(
z-2;#M{5{HY>n`0jy_T{t$`<fxqj&E(=af@Rn_yU`Zasmm11jTGI1lB;@$dSRpSmOH
z>jZ+(6^;#E{ufAs8aFw=Ji5gT$tI-wODH3#`Zs+kvxKZKHIK_B1EZ->hDVC{lD`yD
z`#OAXoFAx<@ixLO*5$b^Xd$751PU;YmB4SosJ+v?am&hWra4>P@@N`tbiSj10b8a6
zwhWgMR!=nxCS)!|yAT45)29}aH!OUO85T~_apY4BO9jKiwVcZ?@z@RCp+CiA$(NRh
zKhpe_5!@NzpBi@>)fb1G!+gRb=qNAUzH)K0%2_3Sv1_;`lA%F1deZV7+8$y+=wE*i
z?s&Prn4~ous4ebQ4aliu`b*cBE5T68_E1?Dh$v=2KAAi};@e`zWBUs3e^lV|zi?e2
z<MH)!EcI+iHX&$O!KyX?>d=T=`bF>lqpO<7olFK?Lv{hmXVrsne;A6-rho@^^&rYs
z7sBeqEexHhF|i6HRSZgm1Ex}}++-TG)vchX({NgE=6)@^;>?bujVH#wz)@ST-Lh%!
zPl!$NQs0iw7YEHQQ>OipZR?Fdv`5PTGFsD#M>WP)k6+V^jdSgQ^LWH%XBe;m>}Ss7
zHC!q?cMvuZpm_KXMTbI@HZPr_(IX@X$AQb%`<+#{(GzfxO8cDK`*~%MBgI<{e>5ru
zCu8*+Dd`TC?5Pl8j`1W0@`;5I>>R)1(?y&Ipm!={$MBjQ;*4+@E34bAvj}!Hn=yLt
ztcx$sFf9#Y3*X5-)qy9-3qK;Asz>8;ljFJ_atM*Ss?FYPO-{P1jf^(dab9Dd7`h(9
zf2)_#A8ke(O*>YemiRn*-J$CFBEFbz7N>bDrd4n?aq+egcWE~4%vwGW;sVUvJ=K59
z8Dq#7hCGZO7=>QBg&Q45`(k+xXU<5pxB3EE{(?=H=iT7}3$?x-vhH%Yf-1K1G~Jz>
zy7cx7sOs$KOqB4T%U9$Fa(gPG_*T*l!e<kxx!j2kqtXzOIFT@K0jKY$uYbd(pHf^J
zF_&kHdW9aF&ifjM`nOO75FEi+MN=*KdPWca*NsnKuFrruQPEV>%W*kGM~og@D<(*L
z5q^i*;!7`+NeXQ0Axm0A47Z6T@1`khLMV=#d7$}%@|~zU89pth&57wzNY^22#1d&7
zSw5ix8v8-#@pj`*spiDw8pwam*}G7wzQEKDavuVWISZlW3M*lCi;a~2Ne{IP1ECN!
zOmq+z#?rvUUeQ^_y+z#f_!fMa*OVRp4vRQM?M1Hc9a-GZnHrn35d}QrJYM^!hW6Wn
zK$Za6k%nw@Ps(T;1Qi_xQB^Z+Z|R&KAXTb99MLe`2{m5^PHTfm<L*4{hjP2ax!cN1
zM^>Ji{IYXSS(Y3^adBoRm#-7L;zGF&FUClxGh7T~x;JY%7fi-rIXkQVl{QLM)u(`H
zXFAQwXUd~+MUF`JahuG-Rxi@6>&%AI?xkmEqQ^1i6T4(ErG*P{dkYI<q;X_LB=>MA
z{_6CKDX~y42#y;JBRapHu5)bi6s!p=O7?L6uE`PAH9v+^;}011)`s@wN9R{aetz;R
zq`SW}%sl*n91^!JO;2}AKU?d(6bBM~SUX_3k8l^~4pcM;yWQV&6zji!FlBC4X_$w?
zuSef@ha_;&UA5IH3&oAvOIGbg1P&Y1BgqNfMZ~7$pK%ymg&jGq)t|#z2TD3m4rz<L
zVO)LURYuHg;^-)D=lw~hGd$L}VkXmBHK!W?LXa{ue`M0EIPm1RfvAt?9l9bb+7Wk8
z^L1Mqrar!J+>BY|D#f6@Zvrhj;6n4PgxE#F^I8tQ=m}L}q$(fK9CKfG+Fs6bs*1vZ
zp~?AGJx=X)+In}RE@Y$SdJ!GY{K-K@N)&WHKWTyLr>LskQpq{rlvIT~(aPu0N7~Ah
zBCE1bHR1Sz%`O^4<%PbUBJ(W$EhmzqxN80C!+5IeTGVyjIq~XG+pgQZ-!yDoz4SI&
z`YUgmaAcpIB16Ke?1zAaQjCAJ4r{RaX0J5Q5ACpT14f7agC57~ux~2z*c}!&B^}*i
zGfa3TG(ZYpLr)hP{o^C;aXfM(pH<sYJDnqnb61A(qcJQkFO27ORbT1+A<n$p{f@D=
z7#B}m0=~11X|%^BjdOk=KOQ!yP`IUj4?0D&qAlEgiex}j5;k<r*@@!-gNDogck&Y9
zCy7L%z&0XbsE=Rwja)M?CzktSnwSoJynENYDo=KWq1+x(HwYCg^KP_NDX>pt1(f~w
zCah9NEQB)GN_VZ5qGXGKa6~$4`BSelFtT2$ocd+^F0&~NLu4G{pE-*#-noLP3bUF@
z@7um#ZsP`slWENx2!E8%8w?T}x%?_$r<f$gO!nKXQ9P=A37HHENtH6P%0AtMSHeh0
zA6E*~1C<&t`J;Fr`_75mj*z$i+inRij<)Z#{wh+3sL?@BAzn<X-~(`I=Z6r%V{?iX
z)hX1w7Cgeg5o6Wi?R>K8=&As>kG1OP!>VH<EL~x7{$bd#BgKi$%Bd*bA*+swSar1c
z5^`vwJG|e|s-tgQiXmaGI=n(<)zOmZrY=sS)YXkuM_1x$UM+=StU7Wd+{BRhHGyMw
zWw#`LB0#Th6h38BN^Z;j6uEor;v>4>*}0$XZ)a%hYbl=W5IosKa$Au*gz;~ivF6ws
z-uk++=HO=R;8wQC?dck;(Y+OHT83z(#FRBh%llb#bT<rO&C!zT<1ER6@vS4FWIRRC
z=j&8cdqJcT%JMEIv(cQx82Rp2Bp&63eSw_LYPs~QXwK`|%VG*R`QthhpQnGh;>-EL
zG+uN)y5SWE{;1W*<q<VgwFIHiwJM!e8ja)`nvwUCg-&A<u@?rTTLOR7LPV&nmB?u^
zo?t2VnS-tag>M#Pn8oPT+APNFR1I*recHu%tqJ?!#dw*4v5WCi`#xqdewMJz#c03n
zV*H$qJH}$<h&Z|!&$L+|wHU{n@XA)xd^qZ<0T|>sCt-Sq1r49Fpm}{<${Z-`lCZBk
zxvZkJWf^ueM@8$l?C#`zn0D0>jvigsZssepn?XtwcJA*EG#EFGh};ncFsoXS_iRno
zfSX%N;$Tj6>4L@GT%tZ5c^AbbvpGqSUXup5G4N!(Yo9alNlHn<!zRb3KgMnRAo}Cg
zu4B_5+Xpo+qCYS~Ow%9eR=yAY;UkpobmnhOnvY6<tO8n8L7jQxyV);Z41@>tK^0`k
zb{<@Dn4&+v0~p)s5<O1c?zC+`n*J#GmdQ%~pR33&0gdsx$da!r&77C`#OlOYnLvI}
zL~7#|6_TGf-6rM?1F>R=mZB*psB)L0C#CZi@nQ%Y)i68T!nC@fvyMT$h(5IL5<VLJ
z@-znBl=u<omwSNx==94{n{UC5=J}x=UI`c-{<nG@tHbA*td8pNfYN+uho55;XLfkL
z39=oYlg@i=hrj)%x~H-=b59-Rua0hoqC8@$)%KC;pI?$Ycn<nUPTP;5f4-Xz`at^U
ztAGjbE+Vi09Q`BQmi-x9m4eTkr%?()!};1S=n^cFjVZXap!wxbJ=4I5FsYn+noU<U
z^cT$zzZ^01^UwSk;hCsb-=rT%(Ltl%6R}~h+DRHr&I?d(spRQ*A#$LF@+ZG#@|`21
z2ij`^hO(6?rD#i#n+*JB5bw;#OyK+hKC`>|BpR@)qGxQCprI<MYL)1vsWB5@N!BI{
zE_#%8lbiz>3uTJ12G<$*?<3Pw>z_G-p88tf`_ofaU)54%R^0Jl_OMyL{}t_FC+MhQ
zmiGV2_OQp`CtTQS_VX5Vt3!&Pumx8phM#aMv8hAxk^F@Jj!}}`&r_}xb%VqR#OxDk
ze!@Wx*WxG0ttngE%u7w06$hU%{Dc<6Prz*TG#L1B!0KB(ZUX#*%Is5tWz#A+**q)R
zzp>=J7JE={Gd^NBKSUX9F5`gqb!2WYTb;J8;wQiy$e;WUP*lX@L=3Qbi_I`~w-V3c
zdg28e_;Hf2RPJImz^~9J!ByEYlQ=)`DVvFjCLF4uGC8{SZ*cFxL_Pzz7^Z`_U#I%n
z-$)-Hli%<STaekW;SY)5aAco){Dzr8vR}7+lnyPhxfV<?&kya;gYZP@(BpyrfDU~d
zsQ2m6T}u3+9s0CMj17&=<X9c5effXhe*9GmV;5mRUY_23)BK2UrGq|jKfcu4k5479
zzhXb$`I@Opp7)$=pOxZ4u<u=~J<{yQJf#TAFMn#QNn?*cPuq8?3#54wzauPjPu4eS
zfw4y*FJAU{;zwYgSAeN*B~S4?q%fL4^<PaMbJ#!^;LgKrn%Y>Yi>aGje6WdDO<oBc
z=z)Ei?9JuXQ>#r<KPNJIm#KW7<g)mEmh8tkfyr1OX7A0AH;?g8HD|*S`|Zm;|Fz$a
z<yrji=6|B(|BC$<cHDIFPp7**e>7XH=h^NLsMD=xJG`lw9X4<7D_X7n>}>f3RlKv6
z^fVl(z3Fs}apuZI7u<?}fsZ2rL~R0NSO5wxG=K|woM{D9d0qB#0_Eu-?^ApwCy`h7
zB;GJsP{fiPMV&+dvb~St0cL{YFtJTwDevV9ew}R(lo_=YCv2&y<y+|grE0m4cQQ1!
zJXy7rm8@z>{j4{=g69l~so%4_j@EA@U$%Zv@HVD?4=TVPr;3l`rsubO+5A!r30pry
zrM-{;y`?a!Zp^!lRH`N@tl%Gc2k-RMA9(M0I{Os-Zp<Z8$SPG;q6@A!U<*K3(+a-B
z`?8M{Duk7{lrJ&6^0TXWBVM*Bbf)62G9eg!Qr+K?Y4()_98uq6@MBlu<6x}))3e9I
zXSmzDgCR(XN+q?EGBbyXN6_b9D;apEue}?~=)ne@0Md_x2${c&CeDlvyZM|mXmpzL
zI`n~#+rT9-%}3swMZcUUnd?zb?{wqvX7`CoE|z|Q8X)^>CaD{Wh_2b>mg$*N3d4Kf
zC^HzPFzJ?~s+i&juZ&=aGpT1OmD%L}9R(-9XVk_#DZ*j&U|S-Sx@x~lAtBYz(;kD#
zjP}^p@K8UBUrSmlkTgp#tP5@?n(rkuN4^29{8nD#tGQ2kk0)>PczYKW9l4ltuz=d+
zzQY@#I}{qNK$(($VGU&eg#fl7I>xx=Q$MG#+A>pal-_VBtYyfI|Gmdgv@3=kOYwGn
z8^xfw#13iyd!I5=rP8Idt#rw0_yzg1Ec3oV3t1~H_X&}A?Si&G_?CV}#!vMJUXlO3
zhA803Rc^b@XC`s>5VcLXd<e)KX04ky=CW9y7>!srZ#Mx)SZ_ksZ}kV{_|9qgwJBSf
z58(XHX?W1f{0=Yko0U0E{!9f|^TFyi6&$t|OgYQDnkXj!I7v$K-W$-GIJP&tzYtGN
zj5oVI_Fc8)_aWZwtbA?RV#x5=*z%t=+1T<~;_vV1uEv&ywN_=`ckMf5$VYH=XMFg5
zvM%L!&G_&OWn<5n^5I9*v;WTK7^4Ral6icmX(hB;Wx?;vd;Vnmv>pl{w(+Vh{Fkb{
z|Hpif^-{=WTtl#Js|wj|6M2Qm1U<jtN*iVhy28BYPqt56&=+mIDdaNqKDH2>dkUB8
zsrkE5`_sZB`CCW$+w;%N%9?%YQhAi%o~(w;m?+dJZ;tH>YBwR$o6s!|#_is+B@leE
zgs$SSoisX8>44N^)ijvAoq94%lhs~^h`1_4@IsJ^&@}Np<@}I#i<2YnPUYk-+g8D}
zCRS1qLl<)&T$vua81;*YCRQ>TJ^@;_9ZBSE$B!A${G!urR`{N%EIP$h!~Z%};pd+*
z-c}2`+B$#JxANhKH(lcZZXa;S2MoWg=r=n|JoIzbKKeio;K*0>bk*dYCaw}XdqHdB
z8LtOVG#Sbj!h}e7;tw{oXqC;zRH@Fss|V86swRvormLlIig@2Doo?gaw@MWz&Q?h~
z*t;)*1xly{h3%#Qe*URHC6M-uk=9SA&amIsYv0`_Zmicn8*kDdb-o~d(GN&t`z3#B
zgGqmsD?#-y(|Ca=cd4Xd^Cy1;*o1I&X5|jPn5ta<jKk*LR_wU<shHx`2rvEnR_=8R
zL(k_=ebwamQ7Xsfm!neIg`*tgW1VMKX)`&8rpV$9G~%AZ0q6bXvH!(CG}7S_<dXl3
z`_p?A7R~?p{6nMfX(=954@1!x+yhu<f_vXZk7?Nbv{{`u1mAUk?33okh8W%wJ_dh~
zxVq60x!0R6O3Uhx9+QHyj_dGXjOZCk#_l~EKu@Bg{$;zK9u<{{5t?#jyu?6^5>k)x
zEkf$#aa#ZRdGkmKa?$3H5_q(L7x?8*{&k<h5!zQK|GRn5FS1V|^2(xL+OVniS>+Oj
zGDq6c5zLv&KVzJWwYqpILb}4EP$E?Y|4LFwzBAbF3jWO&gNxOP{HkDz$eV6~wss@$
zFnS?Zw<HcwWyn3)o~DL?u~V4cRP3PvlJl!7DknR#Evm5DYOjzSBtbkrOsiDGm&hK`
zN~K!%l5qrgHN4OXC)4PH$51f`+z=Lzn)m$4_Gt-=hip6;xhn5h=6x(-k@zarOi`LA
zrF-8}ngw3(Uvaz&smzX%LE?6HYz^X8KGKvX)j3Yb);2-NBS(tp)U6UEHAH8s{i%`D
z)(a)!-$h&bRTW(Xu==9RJWW4n-#oG(%+_MN8RR{AH%A<2J_qXw$I&C%|Hda7)8fkP
ze>Ly<MfPdE{@!ilIU`mT{M5V~SrwJ5?6R4{)@@CEfkt>bcDHU|4vU^u5s4`ot-Hyl
zfB)8Hw(ME})v`slaJ5>a{9&z2wQ2LV(Kc-~@A;GM(~?x}Hr}+U)x669-FQDrwaGds
zj=rF^FL&4PRvY(6kwL1W*`ZT`p|`Y@X4(AI(UULcT}>f;>gR2^md?}*?E3&|p)V>E
zJXvPqacUWHOuzaWWi>G)t9<jGUu2)geOS>+HePF_AjiC$;eb6U8Q;}0TyjJC-Ftuy
zH$}<QD^B94%uQgj%Sn@}I!|>0zx>Jn^1SIXgAML7@A*acX|chbHf*YWR#E*lHlV4g
zW*BS$0kZ;Va#v&1Na2TsQ5Ay}eq?g1dWPA`Pfo$bK`k%{ft<O8I!0q!5^!!zt#7dT
zr3l<~tzUg^wAQ=Ldw!99+FI|hVN>n%18aR`b^A#w{Pi+VRhy=KSal&Q8-Y%ut6cCs
zUYz-GsU|qi{FdaI#C^x+^s(f4LdBS>6pSDHY~2Gs!5oRwhjP1LeDI0IItce$2jQhN
z?WR!!zF|P~F1KCGI@N(?F`?$b;@o<&nF$N%U{>cngwygPQOy`M^C;ESVtj%py#UHJ
z=UQQX2+IP^;G)SUu99zaLSRZ%7X8e^i<2&x0Sf#ZO|?ns@XE;r8SfL)@A*Y}_TA)@
zYu|C^X)%(|ezSVU`XPUGtLka}kWU51PA=<*{CVQo2$^8-<A?k%dV~$$F7=rEl_hqm
z(?j`lwRNfm{PMFuX>yVK@5=0RO=$)#neQ`goE&M>+NwVTKhv>chk&0s-oC%f`!FzZ
zU`Urg<Iol}0<@+|XQ*Ln_!>|0u>P!HCZ06xohb(v`7>WIVO1vItr_o|)9+P(QGMI(
zx2a!i#{1LuU2+XP)#&_|KlOKnQ3kHk7vO+n!CU-rcYc(s^LC41BJX4%7zXx}$*++~
zUYp6-JL74BsTNfPCO=Q!dGk#f^Vz&k`6TC@c=Bu=#R4Yul#eA(A_XMW{G!j85dV5s
z28w$V#JS?^U@S}*dMm`PkHtFCFShiVoLvkWFBbU^icrI*qIvEk?ggL_uD0d_9~eL3
zG}3>4cmFIx9?^-!)%nC8M;g{IPOm=r1%dg2d4aisIhp5@P*eseVNYAqXozCc>FGKA
z(bDgjKcMM`qmZ=}%s;Ck>V5q6e!q21!+*-}cMo-O8fC)o`TdUZI#xsUi@wBf2s~2S
z@>9Y_&HO*?bP`Ov`^Lm)Cte!x_l=6^`Xd~E6Zt+4zbkU__CpKxFQp>-K@PvePgz*Z
zyPmdhD2uMMZv!hUMxB6%qOTjW{eI3a`<xX)BgKSw+Z~?L`{m}7aB7^Gks7hAOFXCG
zcte2sy6Y1BT#UoJcyd{!ba2@jnSoE(qPV>!w<9?}(ip3bgq?MGjgbTJuvKK_a@hM@
z0$5C8_=Fvm_2JM>`&(05z-Wn-Y$e;2E+fuL2Bt@Hdp$))+l)}u2}S24+gK4C*6FJy
zG-Yep_hO{<jinfY^jX!*<hYQpHTe$}rTe6CIU1Oniz`F9t;w&3F!Bq_(p~kme#))B
zWpBz)`O8+_vK4j9zLcq;YKb~!-ye-L_|{PT<>?i<8;zUteySMC-5!d5JQSUm!;wcG
z%5iIQjd5&ZRO~-!y)MM+J-uEVkd~#_>#M&%a=kuhLZr@p#CnClS7`M2-LL#2#lIff
zci2dL#J@J{*{o)B?@~P4G1UDl)HPPt<g@?T;}v&Od=vT}Q!iYCOG9JXImY}W+Lina
zG#YO9YEE#P0tUpnt(@mtO;*_tHBZdtnw+6{R#sV7w5NKoAy)4xd34F(A{wvT<=eWu
z`J~mFG1$uTtb31MmmW%?uiUu|J!Wotina#gFP|Q4{%4?$<I3^~&vygOza!h@0`;uk
zy5mZ=;F+UzQ_#7Ji{S5#J6G*3-s9^uFojuxX6`=39<^jkDc7Cdi&KcJ4tWsGkN>~y
zy$gI))wTFP6DE*A@B|Es3MJOqGK!Y8)*6L2182e+oB?gYYKztuO})4EabZUAUI@WS
zB&WwgTE*Ij*4}DMTYIZ*LD8Z!0rR3_03QfG0zQ~w5Cd2Un3Df@?Q`alfRBFq`F;MM
z--FMG%sFSj)?Rz<wbx#2?X^Wfi2Z{0NZ(PlNt^iwN#t5D6-dD%Afu^LSLLCq=c}~`
zT6AsZL2c$y?-6O>X_w36^2dHH`6&N95WGWSC*2?WO9e1<26z)!GgI&=_YU%`K2uJc
z`93wa`Vw8I`Vu=&@fRn2iCv?(&XNw7aW`$^os;$A*As7!EIydnJ)-!HrO(rKw=PZl
zW6OD@>3gLCkj6P<>U)VsIsl&leqE(LcMp*}B=1i_H+cAyDnbmCs*Qps5WzK)pe(Ud
z^ScuS#B#UmR9G#e@qiRj^>&bl3+o<;^Sgz5Px8Clbnj-V_ipe;y?>S>5*wvT+Ln3=
z3MYAY4p;S(SL!Xb>!nDpUX{;=w<N#bBD-FSoUq<u`Sp72dMT2tHxJ&S`Sljq^-|=7
z^%m#X3mpp{D3Yr;58k4@dcl>#14T|)?~q)*S5#A}<j+-_2khWnrC%%e#pYL^u)4y$
z>Pq$4HRZXw@&NSY>bkVZANyKq<sqm<Xc$V_>W_K4$=u<P$aIfC_Kl+a9NWq9XkLy>
z3#h}Ra!7eqPs~G5CshZNU4gnqoeJS9@hv{>=Lz6s!ip47)xm{my4g|Qp{?oA-R+xG
z(XL~Ou2bA?h2TQYkHvFwpV*0)7T({EjFiqZSe#J)5Fh-w7#KN)pgRn#dr4#jvXzqH
zk>?Vr6m1|xNhD##uDBc6#mcnsJDfqplz2g;_DM#LPwkO2)ss3e&k1(OeN?nr1>c9f
z=Dq7nq=qrqgr}9dA{P;=^L%Yw14XHS#Wcn6+$yz*^Y5F(@1{qKw6~)TmB#h7N&gdj
z%F?I$%?@v~nK<-{G_f`1FWxM_T}zwg&_(vh1pO~{9cp%mi~Mr(*G~*i^-FX;QHPat
zzWwgzsWA`LZWhL&o3rD7FZbn<8Fo?=D{B<M^w>`n|B6>~YItL{c5iF!F)6K0+plZW
zwk39#nTt0NEs)ALyM?X5$~f=|q1@Xl(-t7e_mVcPttK|+S*cM@I1{PLo!EV{xmcnj
z5N}zS47@PghT=9wfH(~vGi@9716MmmMw*K`6-tppRe6Cb(qT9DfK);D*ZJRRcSVYf
zFc){KB7@Z`;La6MEFK1{O@rg)7b!Itzo3c?kyh$C5l-iGtw^jQyOqRl&0Gw4g0^<I
zD#Bd3TR563A}vr{T2L_3N@Dj(=HgfT6)Bch%AF#@G$<}DWQveEv3t0=xGUGnP-zAJ
zmTiUN`K@H?PwXx+7r&(d8z!wlhpLFQA{@1UD-M!}nTv^_0Fq0j6}Vlt6^fs@m7(V1
zy{gD?X$7X2ZH3||Zl%~<+^ve7B(1pfTA}!fTPZRZzpsjDv;tmptx){Ltqd_2_xL&J
zm)KP*46(9ZXC03{C536@1MS{~Hm%#|-LL33v2(B)>b0|v&|}{!uiOFA#}-r*q({4V
zJuL_++F9Q$v}KEtvAR;E1HI~bJ$7q3Sq}NMdz-asJwERdMdvi_v9q4+i``n}K)~5|
zZQ8N?=9v*Y2bm$}V@u+lGCj6{t0!rGlO9`AM76|QQV?|ez55xb{ce`|0+n}^FSew>
zU->Q|_@xxUlJ{8~1eMkAeplr@MIr(qLDUuawW-I5k*RA_y9x4dhT!&yHxC`6R>TRB
z!s{y!rS%+xTG0pq_iZqb5yX-^BlYr~oCVX}M||EM|7m<|^O?vm548xR(aq;KzsKSK
z0-t$g-pDDjNhkTMjxBgP@`kUfXa3{qZB}T*uu$8u(BE_`)Ts{(y}<u%zT$R%;%xo~
zg<iEHZ@D*d5Z=AtitKf7qD?FG{-97d1$un$b}Q7&BH-TWb8q*#59ougcKO{~^+7k%
zi`V?cE#Xt5J$>O}W`d2G8@V(+*cW})T?t&N%_&`bB<YUsI+oaVvU~H=gv-_Cobr^2
zl<G>)<7I7S@BR>focDh|z#bPROxFLi$4&a*_<pO++|mAjzCA9tzx$87GyA(!-^uOo
zK8b%)Amg7TaZto4^QXA{p2$C`R$PyiRVL%4BzjX+>))eD8h4$3j!CE*#h+u;J7^(9
zX}nMUX74Z*4f*grd_zEUey{3EO`yVzDT%!mfMi>=?MW1n7GJRo_P3g3S`4d}t{k;U
z{fcXp(z>e_7pj8d%5ddy$p;kJ7(_dFl_+X4#mOa=N}VacatsNzWa;qBRNiYOh6Gx8
zadcFUn5Dy)kdU=u*`I+=R4?hV8RJib>Pg0#iR7WGwgD!s4EU?*xFBqu`t1+?TD}SB
z_OEo~lYpPOYg1WmYQCvdxqh+QWOdw`wyT`BeNNld-w%C~F74aDAK&&Wceq~AH$s)W
zMl{EuGXqbaY(IcM+jCcWd6wI5b=<P7?*5!0^jiJp`CrOdggNL1NTtIsR5%rbmE47F
z#}|_UcyEc^yQPpXA;;{qd!N1M?XMV5Qqt9fPDA3@u|K&(KCm5NGcv328B}IcZL9iK
zcdia!&$IL(B^nDm9;vD*HanU89B4%m6-rVF+)9|LTmwOA;DC0=G{{@&%2Hop`*B;5
zsCsKur8|btup1n8h20=(`O@KEwV&yeL~Z_hJT;gKBtgc9kE*lcqbEI+@#KHTG>X|u
z*(Jo`<?P2)BceesJ#V;ro`YHV%Cmo~8YtyjGa-NbJ@fnrr;L2hl$Yn#>U$=Nffyjw
zq!u$7R=lgw_RBFn^}L7ov42M)X}?QIgDcl7RD&%%1hU~3Ms?enm~+>3F<NpQfwOv7
zVgsDBc@@_-+)Br(c+_a}rT$I5WLXKlQau}WuBzlJ33ff|vw6>F<vowfdp;xY`Be2>
zdY=7jpRG9APN!E_o~PwK56gQVlJ`8we#R_&rC>!yLTspD;Y!HjD)}zIquxZX#Iqbq
zWHwwWv~laDm0RfNJ<Z%(vsWdTjuF2#`X*K)xyJPxn9&@u(qrmVh<W8ug1sSF8CyUJ
zGOu?iK@fJ7og||@c8RJ?Vp^0zA+rh>*jWY1FvK}8)M~f1iBUrUDg1YpIdkYzfWHzR
zKAtF#io!m8zV<t>@sKP=<7A3B{!L$a@c+qE11$*mfS*rpLC6{qIPm}f$9<vS{=dS%
z33;hn^ySs!W6x=V?&N7dIN`aCi({AnAbMm8VIY-dMw{B9v|d~HG&YAng)~t37}f<W
z+Wx(Vx15Pg!Hug+h&?G)^1nsA&Y4oxIafh7vp($nMde4dHcDEX=CtO?v_|Ee!}yT%
z5=)PKfgSz)OJbJ~XMMyKC9fM!U@c?o9)qr+yt=Y*A3Ac@RKLqO%+;%Qm_Vm~u^)&n
zaOvJAHQOJlsFz=fwx5Zof8Sl49#!WA788e}ht+lB*%%RAlW(f#=)sbhF=BGxR|JHF
zgUL3db-m~djaFg^^RqQ+2l*zr$~J<*#e<sOEuoJkzCEGSiFlU?UxXcXCSWFqmZ(z+
z4?3qAdiW)q-xWCgl5u!z@XQYgT#k9`SkR1csMFsGgL;%zGx?*R34?mnj=;5agY+g7
z2`&>1i4n@)H*&3Vnx<O>qmw{%-MMbvOt<FOov>T2{kxS38$(n>g4$_1^=vcF>?UYm
zkQ<VnUYTp?)dj;;uj2G3PH!;i@}H}3>5_5y<=~lz4HQepnFr}yl3sN&I@c=j2hvxb
z{q~840Gb?%HpuX9$Q&=J)t0R5Vl?<&-N|pzB)sLzj3?n-k~am8_4!c4hzVzi>+D|s
zB$5SIa9OWz&58D!u}3M<*nV4WOXKrAxkDUpZ2){^F|MaUl#6bbdrR~5rMl($vF~sv
zVNqjJ0(&5;hlKW{#=r5Vn<YOcMLqlKyWDz{s+OB@+(y;r$a+F7-uBIw#!XIB;hFuK
zQTkizzuT!_vgPV;v+KWG>X&Dye#w-rUpMdn3-9zITvpkx>TB_wM0&y<tlB*9U@&$I
zSEn?tlB%rlFY67N@B16yjhxPJMk5@E?sd=mLX9=yH>8C38<xs#>Cs-IYiqSDrdax)
zdjrvyK5V21L+0*~_plaS492WRY5EI|g3+K|>b9De#^-o-2f$_^+Ucr{udqt)IJ{X~
zvr@iCce&j}7;N0YvsrcrD3vD+Y)vsqmODEFRq+V-Dyosy#;buQ>Y>m<Kg*=HE*|Y3
z=X<Q&H$LHu?=0}ekDzOM`jrqdD;r)y^71#dFC06?D*JOFdaMXE#i?J5B00E1=7H2Q
zas<r-lBV7M13o%AB<^9ft4B8vM0bf#C_!8spP(cMg=WO0uIBe=#Kx@t`8Yng(_mcU
zsFWu1=>?CVn}a_P$Do_beo(6&Kt4Lq#@muIOa2Bem};UY!1dQJ1}|AHmFt!bT?1GD
zx>g81C_TGwHmqDlLvpQBB&F_x4|3OabSHX7E~ZxS!L@JcWG39SO>Vt<(=cOFAvd4^
zCD5+#o*pYx&>HSNSYISa5(Wl9mOF?yD0(?KRl9jkv|D~EqExr{4E`KELu+~A3;e%<
z5O@>$e*?Wh$U1-r$d)8m$RIi1e2iy2Vs3tk_g)IUea68l+LDUfdEBiYue%*=#(RQQ
ziO5f!zJ@R46w>y5e3^-@yJ{@`Zq%XcnZdrTX<zZy8uRC>@5I*y=Y5gw4vwsoCA;55
zZTyOFYtmGiP&PJTgblP!F@q1U3N^l^HT>S8fRTY{Z;^efDP-<U-J*tlmwcSJAZYFs
zWa{QFXRPf5VKZVSzX?PWjC0w;_rVMUg1H^eKx^Y%f~eq66u!!Sk{#cvjPFlLS`z#z
zeO})as@fKLF;Mk4t)ZMY^ZP6O#2H_G<wI(4_ohC81RZ$%=1zFP5E;*B!K6L9y17FQ
zFmZGPhqp7hfT#vnf%qYVD;s(i`2XeOOPJfpPv~p-BA)`Y?zQ~>N?+feV$Hg%*JolM
zkzw-}Cu>YS_K?qf5lr_*UbRk@VKrwzG(A?b`XO0R-KiSu&ecNxfmof}i0(cXNW4`r
zJ?2?0eG15G;D0C(8{;ve>pgfQWf}I08uzTV@)e%-o?E;93c`I&w>)d@0L<m#(#kD?
z!~0<qks1!(jjM*+`|NipQ{qp{r7N5)3SR~{>I=F%#MMOJcc;Is())joc%A%_-8ELj
z>W2V0sQob>Ft-E}yUJ^<Ics}yqk$S0wBk{N{+^b@-_3zryMkhhilrF&@9u?Z-R(D@
z4Y}VAdDAr}U!?s&;)C*#cUz71(8@>bM!Njwn<4l5pm+Nev+V9b0xych(ei-z1!hb^
zu<GT=!%Y5lHa7S84z;)==k{-F%#TzvdqdtgYs@h}%4;QLZeU8T^@O}#4AffB6w~vx
zX8wlVFgTGHI#L;zu2jRXSSoaDOf=-~)UAgaWz0hE4Z3+<6u|eE>()Ju0&&Q_J>=e{
zn`Kc#J(q*U0;8%mk`TbO#%WZ|#JF9ze(qGTp8RCKT{5S}lbqSsU4EG{SxibsELbsm
z-e_ZKO1(7}8|SG9mAD{jcscZ1eC1V+|A_4m_Qa}c<Oz|2^W+J+&#08|wYs*XQA}bY
zV03@Q7BEE6=qF$d_i@pKIz*WhFLWy`@&$PCb83_I{&h;ZC2oC#xMkUEKHJkRVs@{w
z%I@NB7FPB9C7Un$Ci28q7R48MV;t@xWu-j(>USYetdva564vt$ktgC(|7(1c`fYha
zC{WhgEs8#Ms|0ysv(zHlSSYAp7G05*z^KR*F?sf}?&?i3$t3bbpsF*nUg|ufzx>nU
zIYp(T5D|G|VV^Zi<cJ=kxSzt$ia<2UH2c#KmkYvOh9I&}w}OI+_Q*(?Uo}?nDdu9U
z1Y!;!fU-i~-uaaZIg2SIt5SCIO8zO@nzA8Nn#u;VbO2P_ynU(Jl22Q=*%v)9&bPYU
zKmJ8u{B4%}e-!w%r=K%pA{`O_ST|R0lRh^6;SK4Ny>jd3YLPLthQF&N;oXI&)L11?
z1)_Z{3#g}%29BlfCMjfopg!JyCm)0C0T2WH<_8RqV#Tn5L_n6+3n<&d;xJ*I%=Li#
z-K-Gc#4}gx|8jf%U!GkbSovqgTuK0lIRZd?<b^<0t8UpqYiktLT0>~SdI7jU6Vv(D
zoi*m2_dhC)5|KTUOjVFE3+ORl^c@8#?(MQ>uzC;}ru1P!ja=Y!cn2T@`m;y`B?@#{
zEYx_ML}0HMF}1#37h^8`>jHt969`1SO0YO?jNC`xBO?a%KK(TSuY1M$irgy$nNJ?@
zX9pM7oIfKmye6y5yZ++mYRpGg3vQgEL=hK}HL}HLKC4^9>@q%ctEFfK8AE3$Kz0!w
z-bHlSi0IJxDB4b~p$4=fz81|VF!=fuYFv=awm<}h^+F76ld~u$Y(c52(J(s*q|Lg#
zOx9(nr13!|I_$$-n*LUP55VYqeYJiO#9CfN!g>)2D?O2V*mECviDx9O^vgW&0~KjR
zty{L7A#z38|M2*tdYtt?VDVXzyj}=a?FswT3jcdGViSH(t~Zh3-aAykPLStXco$#(
zaRzr_w&Q$I+D@%oj=<_}-T)9=5-INc>0_1+7>Mvx5!0X#OKm-J9jILaF1PMtGxZD5
z|GJ=mA1L%|#(p1Rxy|tXj}Z2s<+m^Ll69)eYtDW|XzmevS)XG4e4SuE6uX%?+<%bG
zLm>J#t9uu#d)Yc5b_Kj_d1pToid|63AbQf}x#p3-YTR>v>ESy(WiO29ZH9~W{g-*`
zyK$IJW-AOKGBrJ7Mdg;m2ko~n+UvL4->db#6*&XnN4cRce|^vY9P!%vfbz)hDOSTe
zS;!3SkF8uGBT+(GuYbw<zA-54du1FskygVu^oQ57XD#dd^V6(Z5A;s8${ye<3H(w+
z-sWj0U&JdYz}g-1Zl;m@|Kc>l4Ywh8ThQA))hv5JV3hUUAYf*6eL<+|HMPD!Y@?O+
zz11DAV9^FQ-Z+c)FFl$`MBTo0C?6W;4>EwwMYKQm)L5RMVmlAI+f*UXPl?k2Bt7Lp
zZ!7&CP~9@Bql>ce_l2ir_K$u`zoXaBE-&QXCTqPKTz9kIoOK5s+r#?*^G4}W$h|S-
z-s(5U+`;9UYW)vXJuB;fE9?Jfv+MtzP6Y|_>*g5N|8#k(NF|3Jq4l8U(9A!I=6ku*
z!fLd)P>Rc2>tq37WfjubEyev(JJb~3V?=lL2wSunq@9z=3<Fl#B<XLJ?fvU>YD&+@
z;c$hTzsxT-M}zo(ADbh7-@K10%xv9)x?HC37K{~X?iyZFwwyoLEiYx$S42=jR?+b1
z4{A4G7kiYyb7Hb3d$(c7!rv;EATt#BZtew|12Vx6%0qYh?m*RxVLuajeIFm{`t3K(
zBlu<^e5`yFe-fR|!`595JD87K@z7+szt@OOcjLeXhYD0Z7lFWLt$V~gvULwa<I^Ip
z%x-CX6>K46%l*8a0~cggb!P)FxiTAg(S1;X?BL~5?cgO{*6biVc!Hm;7SV|vyhu{q
z5}+h2ewC;t_fJ+2*wJU?yL|t-CvG5Da_FIc@|uWeBEN|KM|So7#Iu{ebi8<m+;OT1
zNA`YbfIMR$cOt!o%#9!;awfmIu~z&d5KX)1eXhp3;1^^F?{^d<r?6SD>q9?c!HW`(
zeq?*d+cE#sbYCeP#w$qau5{!?3XDflV8ng#E~J?rQDAi8-KRC|fT{T#;!1&G1)@h#
zU_AU+L1$DvW<uuksXNHQucT?WOB4<#2e(`bq5I9}ebL=YgJGB}g~_Vrse;Nji0~2{
zD7@r4t>l+GZTaQS50_sc<j4!bOO!s1DWsrlka)RBfltY9Zi;!2V)P>VMfRlRQWJ^5
zt<)D8;QFgC-a>t$)&uizfy1u?CD1B)ML~<af?zsOfl)0o)y;EODtND3`7g^W=r4ZA
zJVSrMto<R9S~IGe7a~7(dK#YGUwy%PWa}@kdy3`oZG6TMM|{OEB97RdkIh6Z-4)>S
z6Xf9+97Ne#4Bb4)blsX}e8$<5NZb}g?ne;eh8VeBMTh_$#s>(ie^4X8EwxA?a=ZF?
z`w~6|<%$szPqz2dV@!{Y`337RqkX~sSz&}2i31c?E6~~89DJ%<e#)N8j<-l0Pb+=K
z(+C@_h-^Kg&)BFnh}fB<7UY3^ea0h>KBF%Om*3pxi*_m5v<1xOv{elEMy}=qzF)AM
zBQ#BN;C%16an5f~jrYB3yesad!hcC$g;-wkV|%=Lyza+pz>TV{qR-eEo+Qln^<3kM
zAIK2D0~cM^Yi?EJrxzcbV$NxNBoH%DJ->t&Nyd6xMyDadPs|a1SbLS&8HnBH=rrCG
zokk37A@!_Br}0R@y`J^m!@0u@e{s+GA@YvsGxi|w{I{*o_+g&B6FAJ>bM5*14E65l
zGYr(@tf3iw1~(FIRqy@v8JW)_@2LDD@BBRG$UEBt^egcW^3I|kBJUgyR(&A)j6)*t
zv=5MXbnCB5zChmT@mtsZtk-9i{mgIvBjo;j$h+5X@+F|8j9%oO-MaM`CGU{C+i$)f
za`y(kyL@KZ&jN{kjy~fhs2E+r8%o|;nU!}E=ri)$(yfZ0s%G|uyf|-G{4}o>HhEJl
z&=~Z}Q2kK!8TaPvGw!ven)YyY?FzpYX7_4MiU!=Ti$24aXWj>JTc6>GGeP$ULHC<J
zb4*mQnNepn`>=LvjfRp}E<l~}SEu}8@*~Yi-qbmyW>&lY=hf`>?)3LQ`FdA3@t<7p
zu4KJiw5&I1ZkNk>&gORjeH)6*zJkp~w<i6VOyPH(HIMB)@+0dVBZz=6_5kQ2<b8d9
zx!TSTqfBL7w(soT!3ZXhwt3yD_u0Mc=<9u=u$SHYvzgsH>)qS1I^9&31orLEuuy3Y
zC*zmPo?_uxR3$$XKF8W7LY@}wP;6ye>bHsqZnJsd&-m!%$g)DtLn)5aCU<qnwp}U`
z-F?OVwoZ318?)nhq3WOPrh>n-^}E08#}6M-{O}RA`3hB~6hG8$D+r8TiJ|P`?LN#D
zE~)B69}`vU!cLt%CJNtpUnHFpKQ_6tS~2bnw7HF?Qs=)Fa<sh_0KWkSIl%!Qox^~I
zFgJ!P6o0hW?+VuMf0;kpN&pr_VUQW!MMva5*~E`Nare`+gmI#?x5qVulyUWp6hj3A
zWdkWXA`>6`lyB=^e=%<G*EK%mlrZ3=96sQ-HsPe39OPPqD7qD`=Mg34rcD1sY`N6-
zJ&`e$G;#x=O)Cw}V7PvrjD~CBNF#cbCG>xIX1kZVjU?Ij$;aClsgIjw2{pODBA;xy
z-Q&kXHb!jB%KOGq#+~MnWY!d5%YTYqp0w%Z$t=BK2q}9?%pokT_WF4w@}l?@HJl@q
zk=1y~`dP9pLmziGid?2hB&iHOaw0V!uvU8oWv^mWh;0u5z8}LRyMwVw3eJH0J(SG@
zNF=kK$U;BoS8Bbl_|?BkABYJRzp>X(9<Tciecgbpuq*Nt`kEPkdv1g;5TbYk{Q=_-
z-^V1&7^|V&<1ap{oA=nAS7ZOYGxl4oA!^V~mBvbXze12Z1v|h0p-}9<&>^f7>t+B8
z0k;IoYI;8d>N33eD5*lhSVaL)dD5rZ^AY>NW2~ne;9>h%PesZ?fACn|dW!x)V*PO|
zVn%;}MOj`i5dCD((HDfoFx5|gaEY4l{Xa)O<K&n1RKNehfc8fYuR6+u??1+3`dqLo
zxu8Ro2k+8GcsBadKRguD{@5|qTJ(r03m&nR1#HQuntTyufsyDd4|tDI;~!Q@jrp2_
zNBU_Bo<&peUgY;;2DCAUreM80d^%fuu%I*rkD)2p%aW9?R`8Re+V4a;@H>tNWt9WJ
zlij>12T)tksR1?ojv5@Rzz(!WSpsK0)f+@VfMT=LTGaSZ(B0}Y7d7;XszJAAHLeO_
zV{sq#n`I3d!+@v;+XPOnafVt+#V`Qx47t$?$fovoWfk~5X_*=RS!<>0pLM@bgCUEC
zwNmWU^Cwist#!hjQ_awYW2hDdpOZn0zRdT^xVr2^yc<yb_EYk0w~O;__i=m|`Clvj
zc}#2`1n))<u=PF_TVadXO1Gf`*shh{6MI4>?;?5EeW(U@swim(#EeQH?<HeIL-2iD
zL%@m|`5*4z(;7tFXJR$uj#Jm1L#M5O+oM|z%1*+@UiSYxeZ`w~v*ZpKCx?TO<=PCm
z^NZ>4$;mP44-BIttEkS^CiILN;!d@};^Cf{XlekljsKm1RU)v>%E7iJeKIN@!L+FM
z_Micfbw0q3KPj54OhOU?>w%Bo11ljY7oXCw+(GNAqM$W0XiZ1^s#lcbk%5H59iPd_
zS$HOKaH2z<o~YHnk4{#+n^k<kiQ?)q(eQQ{t^UpeF%EHY441=q!K-l!O7gh}d}1^5
zcgj7et%LYKod1*g{{>^&4yP^wNaCNHooDyJ7r27xe>681NIbZ+1Z`iR8C+H*GWP+*
z-*S^nYgmvSdA$Y!Xy~*ixfdz{X4>cNb1tQH{9O9iKjWXSe;V}{)ijk2{Ur5|+INzI
zKaYZZ>gZr_St(8<kpn)ngD#BCgCFzIn4$irF~u1tl6~S`a)x-9)C&%|o2jHoZz>s@
zP5+4gjk<~UL$R{F_SM1bz_J2D(nb#Y%#AcZF5d>^qkh-LB?XalY|>gEc~=z?=J>_R
z_7$}6Db|}jPW!LS+n4^7s3dow<N-!R%{3*!U&3j2F`AJcXhoouTW}qElkx4=;%@tc
zJs!2)TEhNdzh_?+Js>P}8%_pEH>?7~`f8ESY~w!UZktjXhPz$dWt*_+BjnJBHlDjF
z-NuN^ivq0zL<R~4N*+9iwq+o)+dsT515xHZ1CeT<HR$lREJ(S^c=|B--XiGLiQ)6Q
zjnh6FK5dOVOW&+DzVc2E<v!|;98~kqd|P|GfBKo7wPbkA9XTNJXU(@Qci#M={Fzdo
z<V<;HeztzGW|AK4pME^P%RaO}XS$6u|GEAYeN2CfKc+v$AJZSwKej(Qms6a0e2U#h
z@jus}i67IS%8%(!<;V1g^pEXNn1ClI?oXxLsQl;pQ{L%2<aDXqnZ{X~7y3G${_v=C
zNbtP@1x`$l<hM!kg!La!p8@hK6r3=BQ24`?BC})ZE{8kRawT0L##y5kne}6+T0eqk
zxs9`YMaJPyYJ^z?O}r3!&#^4kzcp^$Uv2sIqE4>*6jvH;S{#s>h41$3;Xr)UR&_eL
z9fa)bmtFCT{P~&9{t5BHrMI}q1O*y}kQ3qiczj%eKKO+Au!@7$<wc<?cJAv#r)>>r
zQ<_8C6mDoe0cx`R6aI7p{M7tY_^FBiQ}|Jp!@^ED{`vHh!4C!g3H)3*<YVxYkeK7A
z5$EL-;wL-k4t?}{x16<55Gv`w-!Gku?}d(y*r*3M+hfE$dF#0nCyZsKTm~39D9hb|
zbx!KLV??$(Re$ZW+y_a|d$rro`(VR!0{#yq$MY9M=1)K7BIV7_JF*?J-)om;KG^Ts
zSG#@I*UXm>YyTc%ZXe&iAb|D(<D=GlZB2oix@JO&HepZG(8{=jB56;1yuc>LOoqZ*
zGm}HoEh+w(JCo|kCT7R4KoJ|_v)w?Uk<B9I1C}df8U5s!Q5!s}Kh3s$7;@x8Y>+I?
z;Q~AcUhecQ<$#6D6&XeMf@Yw|7UeSI4bd1@fUXx9=JX=2am*yBX`20WdCq;S^yA#O
zjF?_Qg?}?Fqo)t~z6%lVa`DpUSRGRSyfHZS%R@9+!7X==CzzeK;4Q=ZH~YJL!&UkI
z@mGKVc1UaiwFT$#chG{XB>vMlZOzaob{z>r&Tb<^BI6d}j1(;Bo6;0?^>KEM%wJh>
z4GIaug6u2}#f<KNw_PhOkU(dpo}t<Z4+VIbB2Vh_YA3IUyuIYrt&zG}s#|44*~AuM
zSsgmXq!BAv(2E0#tCu$H>U=o-M0aX4xqcRXLO0u8s`v(`q|MQtgHU@8nqP=5JY5rr
z?&^KI8nH6y-NXmk&uQcJ&v$Ag^ocAd`scgki4bi1=ey;pTO05BJkU)P8-o#TsSZ_b
zk35H#EqqBJ@h1L$8*zU<ot;G~D$~(4T`EB{DtF|>w-r;V;<TyMLALd!2-uN#>9k(Z
zO|NxVH(kgMwR#}Fw8FP?uK63FDwGck;n|CS&4YXZ+Z}u?pYN$`Py1|dn=aY1CTg{7
zIZ}2@Tz0~7EYlcqU7}R;l*(Vdv=j)-adeOD!G$F}&vz(3Cag<Px#&A6mx$f9YfvyY
zX5xUlvRgT&?_huJk-dV)sM-`c5UA>oXzB4-ti~B=8wALWY>u);SihUfhRN0<fC2O%
zy;c2_t7&h4o4%-CzGU~(GvDszMs<B}UN7V6OYM#Mhx9VnT&BMxRDVY}{q2<g#y_;b
zl^@$*j8Ad;+cKcPZT6t#@5WSr2iZHZ<_LZ@Z9=2N@`hOAgDu@#PnR<XG%}N`N=8~+
zCe|&5mM^jm%g(Q%;G>M0vSwC6pWeiVlKIdy%hi|C$R!g^Th>Iu6HGR*zg{aX8Or?|
zkevO{#Y3=w3r9jwJ~O}%v3qd0@RMLablTLJdW>c41e4MlGjxh|0sm(e^vVo1#}rL5
zFW~<yS8r;uEPYkYT9g1<2rY&*3%$#MA(^e*a)K`p#|FA3z>hb9O}=#AzvDTKF9F^w
z9-E;uY2D$;f#{pZ@WnG)Te@+FQuGJI_`FZ^dL~lo=ev1gmNGNDE{#n(*@(8HyKF8n
zqJ8ejOW2l5!z1u3W}bEiy<2FU?9$yw?OvnnfbVPqN*k^Rvw*J1GL$jsCDy}G(lC^-
z!BAdN4CSa|C|lBg0L)`3GT%NaKWTRO$=1koc!6-QOMCcBHmn^%_ZIBJu#^%AIAODt
ztUtyS_{m7&CnJR2$Yg$(9<7jplde5T*YKaHr&D&2M_IoVzeefe_=|dqmC{A`c1DJY
zRs`uWlFTfqnfzy9niBh!@OHN@3Wnhs-PK;ns}?hum*meUaCsN~LOlGbZ21CzLwi_b
zfsl!$)L$uW7=AC|BQ30=(0?8iRP76Ukf20%MdNc59DN?}sQO0st1tCKvIo)Sd7HI6
zBtnu{E9TAPZ@KXP_VgD;jU3(C<y=8dY#2GDPz!$^p`YHJVbJ9v81!Czhr{}z=F#DE
z#4#QJ5V)c{=<XE!UE1myM)l0O1Y&nb<h@|kmdMcbDD=Lnzp6)0FJ=A@nEnc1f}Jab
z`VYU7&pcH5`blnA_$0xTn6uo?k$vfNai$G<6S)3DUku%t0#+NhzhOuCWE4*Y_NoV7
z`<f#=wP90QJS^^6oZ9>r>N*8vnjI@t{UvG~<fKS913_g1krDK^aYHzL%f~nE1yApj
z0X%P76HlSorHE`TLHFxn`oEq@JMUHcF78laj?g6f(j|iKA!72xVmGzLGgP3-u5&s5
z|6Q7bb7>1$U6Cs0C@MwNYeHCx8=I4Aq-Buddb&szx|_pUQj_qz1>e@q_~vA^%MmOR
zN)m9x9txNWlyL-$;?%qJ$jR#n76~O-;7wabq@FVO6bl)|^b}(s5Wzxs_u9?aHD+1C
zK-mK8SDtJ!{W#gews&RtL1k9HsO-wf7nK?LqH=(I5kHZ9ahj4Zx;{p}*p@F}xH(cd
zU<GpK*Sx`3r~ZRL3i(qvCx86kygtLfu1*bZKIZrw2)?dP9ZK|ne`mn^O9S3(2b8~J
zz<bSr_X`KS-#g&_jsfqt4tO8f-b(}0TL!$Z8Swt=0q<*`?cd)ETl&A>JK+7L)@-`O
zV;V08hH}oBCeOPW=M2u$MmLPNSpf4tKmECHesucSsUMSm=|`vEfB8qJpT}Kj9|hm=
zt3NvZ>O~)&9&7yQ^w;kE==9hRKRW%!pL}%sYk&FZ^x;o`bo#rA0qLpl?az0|`CIB|
z8~eXo{on2R^Ae$(Y$4cwzju0;UhMhB?Roj>?+kc<X~28SfcHB#WXt!buXW!Z06+4#
z+?Z@rXyu{k<SlzxAHuUZ6K!r($JL)4&4=WMuOUOQDqd)gHq3=ZMr`t*$jCu%9KQNS
zokB!i!zyf5pQe@?=Ged5sePm7l9Vn4t$lqq-Q&k9aa<gGS04RGCtso3{+_vs@IhbW
zxo_0ERZ{Wro1``t?WvZV9hRpup8gab$s&Ik)^v17?P0Hu{s6s;+2JEc%CIiyb38oQ
zFfS`j4>8P9=Tb%TB<V$L_~De)-A>(=7&z5b%)(=z_Rj<rjvi$T@?WgXR2>`st@|jR
zxn3bU`8QO9!x1(rsr0{9r6mgB$?JGA8vC?{x5#2xV_)NQ(E8$q{NPEDw;wdDB>+ms
zr^sk&eOnPGe0?ur-Flll{K8#^H4PQU{=Uxii^&Ji#SFcVe9_4h?51~0?XlsXRZai!
zH`3JPDR$H0YiPFCZuS{c(kCf-%4siL-LI{bwDnf5tyiLxJCf9mkQ*D`&Qss0yQ!nK
z@G+k0t}FfTBs{7TZkNix$?GrG>wI3V!WhqpK#{2oo|KUx8fA~yf0QPdUCtK{BjYmt
zp3z!(CmG~lYoXj(EdQwOYdrRiTFs_OiPj8L`Ny62XCrB-v3R7So=So^Wt%Ml2zgV`
zdUzr!$z!ts&Sm<q#qUG1EPcmyEn~a7iD#p=Q4Vhjp|&<k<dT2zBwjGsup1e8gr?Q2
z_-So?#K{)BLqbTJ{_BFV^Jd)(7Dm*r(4KBfuA-G_<3r>^z{d??%~ZVIw1%Gz6`Y(M
z{<0O5_K2@q4Tev$R!Xgxtd#t9ry17DdLBqDC-E_3ZcM&ouXHL*|KT`jwKXR<5Qg9m
zV8N-<h^>=u1k6|DY}|?vzM|UGgg0J;N~pQZ7d`q7ZP`k2@q~w5Gw04)$<c~EzP??)
zr-_o`N==acb1Xoh#zVgP+uYyxY4@}cj^c<fx~V{It~o=fHU5RH^)ZvbrJ(Ime&t{C
z8JS+zWpIa3T`(4t@4hEcu(^_}NokDN4bvVE)zzA@2l-|;{+z#fP6(Hw*2s748i|0I
z`nB_Eru~TtuTI(dASrE`Nn&f`3JS}=Cjc0FStswQo1Ai|)+-cOQ|_DgC#_*W8IXHZ
z)A^ug+(kV24##DfwZ?Ph#qw0(+EZi>;hf~j($NOAv`$+>7le$Z0&Fn^<y>=W^yn9~
zh9{^sdh|lAQTEM&m~RkRE4ToR_1FkiXih1W4p`;1Fi5?D5J-CL0vQF4`|3whg!K>%
zgy+yf_zlW?SABD5{n27=*#{)?6~R3IqzsUzH<Qzj->Wy%k8s#JwQ<YB39+&t#Y!%Z
zCOS<m{qJ`7J?U@T_(PqVzQTSi;PFyBmoDJi<6M9aL5*{dFM4Q@f;oM5UI)@+oPjue
zzYtet96vVOo-c?9;Y4D_p~1%GATvEEV7?JFxu>3&`iF%`I9_<HAiRLTgChSK0L!V>
zg+f3w4eBLLYmjT8BwcIl;YsD0HdvxWNS@z1GbN^GikcC1W1X4uTUR+)Y1~aIV{YR^
z<Zkg4obAk()FO#BEDh>3C=bLGxq)^HwT92hm*_FPgeLH$JswY$^DBgSMwMa+k&`X|
zb*2KqCO4sEflO#b>cKDM7Cu4pJez77@OX<H9hI-Km5=fhj5XHtvvwhWQqniOE+Hol
zT`J6I4TBh3FzKmiqNZ5r2B(l3=A^fXl3&dtBYm@t6m|7dK7K}8dHB(m|4J}oa}x(g
z%lhLewUl?ef@oX0-O<!4rqh6Lt2~jxzSlez>A}+Z9piVblYSZY{HB-Ez2sXb0puS*
zpj|kv9ao9g*hNPCK<hjeDxkHfC-4a~H`~GQ*d~K~u8c?!W0l~~ZddmbEm{L+YPFaA
z+g|f;dnLYO@uP<JOy~)gliP+3mxgVyWm77(XfEQ*M^0V3%SB-cu}_rjV!WHQMmdQ|
zjwLSFD?4MpK8Aa8-z7xnIdjM2ID;0~9^brHU2w3OXgu!CwPpx8$6vbR#!_ju9KJQ4
zY~?hpHAKPNYulD4JVfsy(?l{~wByE!sU>_5SS1xZyi%r1AWa4>e;02GWx5p;!tlG>
zovurmnZ6}@F&=n?5!mkMA#rq^Uwb^^TiSgLTZ!L|)ucz3TrGMrBQvnynVJbh)3}rL
zC#8dDt&~<Uw(zVqcJTSNZ8@To9yEOwtUh+`Z)GXx^t`;3ud3D>C-dZxZR*QB3xQfI
zS5TWw((rjQ{zz3uZ0tckO0**46VY~)6ikjd3lg}9C%Z^4^Ak>H$vK-Q%`Fs5ep<56
z;57%EPkS8NaAuNCU;Spn5-Lv_(t?_mpNKFo8BUq9Y?&;jf1<)OgsNW#gI4I;<mCYw
z0O|eT?{a!SS0RVqV7}Cvs_9H}*rzFS2~U<{Mn29FgFMfIQe>K+QEvL&vd0W}N8c`?
z6w{r$joJfq;ZRpnMjmn;O6s#YlsrLB@zfW1SbH`DlAIdM3K^+;*-i*bzr{B^Q5~Gg
zmk_n5PT@~J2{<Dk(PY#k#m<PQhc~Geo7cx^prSlx%xD@~;%l1XZkk?@5)g155a@*e
z)gO&SxEB3p{|y|ZQ>-twj#B-;I2AkKBp(|hGT8^IBnR^BJ}kL3+XqQ_o`mEF(+2jz
z%iu}!qa?qwQ>NB~OvMLlWjbpO+iCT+ZQA4QOA~H;K6W!7dv@H|o!Uwgsx$5BEYwD#
z=PUH!7RsNHV`mUhPsya4=`8JDM7zd)GF%ugQ|%<lb1l!(V|i|Jr?_^)_1JmGVKC4%
zRM0rxT~gCDrNH5t-i~N9mZipe$|NskaMBBs9=e?yH?ukU1^NCh*~4hBG0nKSrqy3m
z5Z`g5%Vs9&iMh0D(u~619XD3*SbUk~ztXTmmvOVrAcGTew84xLjxc~@|7aAzGm_H9
z*?;frv*{IOxyaD{4jbn0SMtwSvTwXdxlUp;<5&=<)MBCTfSIh^l6;%FV%3ybGfKIJ
z13!H&_-13ft{HFY-mbN>_GvTQ%o!!zxMCctDfUEkG^M<!M;dc$Dp<hFqcs)o=uIW=
zc^6nUMfUn%WX%|V$&89R_9^T)%h{!FS<7En@*)~bZ!+8bjc+YEIrRXao{%PZ)s_qM
z3Yh!Sr5Sl8+FRf^_bytfJ$|ZyOUNcwK47+TSf%dUel#_GVmR?}@DSH~H+Ir-IRvaQ
z=FX@PX&mrGwhvUj5q<=H?AUH=Mv)`Y7g<+~zvPOFx*fo2%kklM*%tiJ0L&J!f{(iN
zJzjV5aeW(^>09Kad`zU<?Viq{3TZmMmi^F0{RYYDUp9VQxzahQE3%&VS=A*z%P6ht
zFgI$!?W_RCcJH>#IQUFM24bcf2xLPw5T`ly<wK#yW8!fzA2%MWpk)~keBOtpzoW(i
z|H`Y(9SEE0Pv?-S_JcWma*WTdR~-zWhl1PlrH{v_Pn!AH@Oi8z51*O+Wj=r|2cKet
zehHsVs|HI+yfMy&AaP$be(K?7aUckPsy13z?g|sJAnsfH```WUcN|FLHmB5?#CpU3
zo-y}TA==DD+Yr}qsqRjO!M;S1G2aYY?uIS5jY8e8HGRO;Te@or#LIn3BpBu!^1U&|
zcip<RlrzM26U}Yj9^Ksy{hW>1%_J;G4fCgo$<19<$u`;SIo#>q=5u3|I1D9oj_Qp_
zX|ztPAa8_+7@T@&8N?_G0e;VX#e2lvW~!HK6w2c?6&}nnBR+};nhU`bNeXTh@k%AP
zokheJ(&l~6w(ks?C~f3X^^(2mGRPk087Z-|YSDwtLg?nP^Ei;IWtN}8viyX{Hi3{<
zcY2iVpXSUjKJ}?NR`tfMU)9!3>pPwtUd>If4yKpjA$h(ZHU|pQ&t&vD^4Xp{Bb_v<
zHV@pobB-hE+$2oolYhG1F!wq-h^+o9KSN%v+VbHH;&C;<l9}G&)*N8B=?>6O5ho50
zzQB{u*}A{K1)gH*lYjLLUD~JSi|no9fy28JdkVN7Am;gz&l~sEw@uWWh6o;mc);PE
za(I^=cxsT;7d=v}-La0{m;|HnZVNxfOfL;TVbknm!819u&@(8qs%6Loy9Rgq=h^=C
zyFW|#JpK&P4{k<Ek0u7id|yE%IJDnyRWmI_eCN`fHa>Byj+^OGpc?v^$w5IXMDA|}
ze*>pUXpNdC0du!FO|uxz@;7as5%WAZ1g!W72NvCl1AWkBJKCTy#aSEwnay1DGZA&i
zm*kqM`VTI~>6@4aQ@86)<D`d3_*4~n!EuvJ52>%^P^!t%##(0BTXh%cW{*s<E@sI1
zepBqG*K$)#=jJJQm*Hk4A>WboAu^o)7KMkj*mHua!o!1AeUYL-Y>C^)SEg`@$$eEl
zK5vU+i?D<i<`QMY!)dHol^+_7AM=?lynmT0ZmW7irr=pMMU&MeJO>`2Ex(Fc>NgK%
zC%-IXn_snoW7_+azE!F%wX19z*D}p5Gqpfi$ZdS|MCK!#y3-Z;?5>(UbZ-51WLNjC
z$MgKIEFo{o5%Qxxhmf1?_C+5yU_OJ6TQB(J^ZA-gjn4?!S1Ewc$_Mygg4dO)og*)5
zV$ZSft&@I(JFO9|dS7ZIe{xMa`f@{7*J{>;9VnisKsE8(hPT#~GEiu|)L$&t>Rw8Y
zkC-~fpV-wLunX;73nPUQZ%_Ui21%S5-SY3{1`*li)%W#9MpFrlqYriI=@i-D;_p5W
zE|NaaFpmbz{mC0)2<fjYz5)eAPJ)4sbn=y_(YvV<=T?+!Yqa{EZxkh(hG}bNy6wkH
z(L~NHaGsGxL*3qu(e;DO?OeB++@Q7)N0N`6LJ&z<sN61sntsJ6?e7WuD%?x@+RDT6
zeLW-B*Lit;P2H|asqQ`vlG3N=uwT2v=H)eCvDfW>9Cs<@j^nsFUjA%8X{Vq4Ux34U
z*(jJtk~bh(=ixA`?HB%?mCr5{3c4(xf));qjPxmGH#fm3BGS#8QWa#_j|tu;A{;hC
zuV#tpCa6gvHu9=(=`lq?r$-m}x*W`g&jqhLTl`&$hU(Z${$r7dFuJ#Uu`Y}u@@av$
z>0+>aMiwD6AgZrA1<TV0`IR(K%5^qSp`RdJ5aL@PJ3Uv`@gGu$P90PWz_(pzDZ&0~
z?zBOozrv~MlM-cD9#MXdZHZKVYMG7D%beAhR{8<+W6+R3S;-?deSBu}ar9BQ<|AmM
zy&rAlIqYTVKeNx_Ql^FM=i|2XDvH^Y=UwPCdvX*Sni~)OTibVQYiq?{C9&r#fy9wd
zPm6g*zz_UxbnuB{t{fV<;AQKY3DFPwA|<UgqH=dVC4Z{6X*0J$(|T-bfzGn7)(8<b
zA%qf}Gz9mnnEG_anlZtgQA#wyc9Gf483VRSXUWAv<<WM(+ABp$3~R74_lk<9l2RCj
zbxN{e60|e7Rf$70O5CsD`NVj!(<GvFsK+o5Bwe6i=vX!y%4DazT*_XzP-s^+(bYT7
zk^OkLZq4p7tl8c2(&c+fG*9|jS0{HY#vu2SK`aK}(huZgcqSo@wZ=Q>D-K7+2UzqQ
z4=wypU(;4!bYm%3MGf^GUhkqe;ec+wo_MFwxAaYsB+;AW0Ou1M85)tT9Ob^+<2&;}
z`iiCRz%1p4)#8`XV9O<%L*=?mYH%uwJT4DZ5gFF%=SS*Fj{_W6HK#kj#y9d}7ubR>
z4gi-nH$Nk{)9rHA%U6^(gqmjRT@*Bf6%%!y#`6F-AO6fn*|7UNnU9|2DJR<mx)3~3
zrHtj1>!~Qcdcb~pykM?8DAA@R?6l9^<g<JwEFX0vyxSI!4aVvqh!XnLm;N#zHD;cC
zWBAj<_#@9;>30_UYHwTJ7$263_9cVW5-%dVyzf|Yn$l7DT8BtA&hATFE|E{kSZW8A
zRI;B4aUXcNU$4BQ{wR9zACV>YwF0$)Axv2ZDugq+9_vZzjuzZ3=heKOW-}^EiNWsU
zsE0PClh}{Zqs8;8I3*&1T6}BKR&&bF-==#zkew*u-HeErmCx`K)A18Ktm9o}ay&Z@
z-Q}jw3OfBoyC-Z!X?)2(zMRGCA1Toumo2v1pA^|y!b9oNV68z6NlXZGh0n2d1!x{b
zSD-E5MN&pqiA;B<`FSY@532%0AE`$1*$`K+)v{&D6#OlpG6l89AIh5}8l{%=vi3aw
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

diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index ab7c02ca..c9434d63 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -538,6 +538,7 @@ void testDefaultOpenNoName1() {
             final List<byte[]> dbiNames = env.getDbiNames();
             assertThat(dbiNames).hasSize(2);
             assertThat(dbiNames.get(0)).isEqualTo("abc".getBytes(Env.DEFAULT_NAME_CHARSET));
+            assertThat(dbiNames.get(1)).isEqualTo("def".getBytes(Env.DEFAULT_NAME_CHARSET));
           }
         });
   }
@@ -550,11 +551,14 @@ void testDefaultOpenNoName2() {
             final EnvInfo info = env.info();
             assertThat(info.maxReaders).isEqualTo(MAX_READERS_DEFAULT);
             final Dbi<ByteBuffer> db = env.openDbi((byte[]) null, MDB_CREATE);
+            db.put(bb("abc"), allocateDirect(1));
+            db.put(bb("def"), allocateDirect(1));
 
             // As this is the unnamed database it returns all keys in the unnamed db
             final List<byte[]> dbiNames = env.getDbiNames();
-            assertThat(dbiNames).hasSize(1);
-            assertThat(dbiNames.get(0)).isEqualTo(new byte[0]);
+            assertThat(dbiNames).hasSize(2);
+            assertThat(dbiNames.get(0)).isEqualTo("abc".getBytes(Env.DEFAULT_NAME_CHARSET));
+            assertThat(dbiNames.get(1)).isEqualTo("def".getBytes(Env.DEFAULT_NAME_CHARSET));
           }
         });
   }

From 18013fb8bef56e3f9c2dc45e2ebc3b5e55ebdf02 Mon Sep 17 00:00:00 2001
From: stroomdev66 <stroomdev66@gmail.com>
Date: Fri, 7 Nov 2025 11:49:16 +0000
Subject: [PATCH 275/322] Merged new comparator code

---
 src/main/java/org/lmdbjava/Env.java           | 64 ++++++++++++++---
 .../java/org/lmdbjava/FileUtil.java           |  8 +--
 .../java/org/lmdbjava/CursorParamTest.java    |  4 +-
 src/test/java/org/lmdbjava/CursorTest.java    |  4 +-
 src/test/java/org/lmdbjava/DbiTest.java       |  9 ++-
 src/test/java/org/lmdbjava/EnvTest.java       | 69 +++++++++----------
 .../org/lmdbjava/GarbageCollectionTest.java   |  3 +-
 src/test/java/org/lmdbjava/TutorialTest.java  | 12 ++--
 src/test/java/org/lmdbjava/TxnTest.java       |  8 ++-
 src/test/java/org/lmdbjava/VerifierTest.java  |  3 +-
 10 files changed, 117 insertions(+), 67 deletions(-)
 rename src/{test => main}/java/org/lmdbjava/FileUtil.java (94%)

diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 480ee8b7..43a52d5b 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -29,6 +29,7 @@
 import java.nio.ByteBuffer;
 import java.nio.charset.Charset;
 import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -147,7 +148,30 @@ public void close() {
    *
    * @param path writable destination path as described above
    */
+  @Deprecated // Use java.nio.Path
   public void copy(final File path) {
+    requireNonNull(path);
+    copy(path.toPath(), CopyFlagSet.EMPTY);
+  }
+
+  /**
+   * Copies an LMDB environment to the specified destination path.
+   *
+   * <p>This function may be used to make a backup of an existing environment. No lockfile is
+   * created, since it gets recreated at need.
+   *
+   * <p>If this environment was created using {@link EnvFlags#MDB_NOSUBDIR}, the destination path
+   * must be a directory that exists but contains no files. If {@link EnvFlags#MDB_NOSUBDIR} was
+   * used, the destination path must not exist, but it must be possible to create a file at the
+   * provided path.
+   *
+   * <p>Note: This call can trigger significant file size growth if run in parallel with write
+   * transactions, because it employs a read-only transaction. See long-lived transactions under
+   * "Caveats" in the LMDB native documentation.
+   *
+   * @param path writable destination path as described above
+   */
+  public void copy(final Path path) {
     copy(path, CopyFlagSet.EMPTY);
   }
 
@@ -169,10 +193,34 @@ public void copy(final File path) {
    * @param path writable destination path as described above
    * @param flags special options for this copy
    */
+  @Deprecated // Use java.nio.Path
   public void copy(final File path, final CopyFlagSet flags) {
+    requireNonNull(path);
+    copy(path.toPath(), flags);
+  }
+
+  /**
+   * Copies an LMDB environment to the specified destination path.
+   *
+   * <p>This function may be used to make a backup of an existing environment. No lockfile is
+   * created, since it gets recreated at need.
+   *
+   * <p>If this environment was created using {@link EnvFlags#MDB_NOSUBDIR}, the destination path
+   * must be a directory that exists but contains no files. If {@link EnvFlags#MDB_NOSUBDIR} was
+   * used, the destination path must not exist, but it must be possible to create a file at the
+   * provided path.
+   *
+   * <p>Note: This call can trigger significant file size growth if run in parallel with write
+   * transactions, because it employs a read-only transaction. See long-lived transactions under
+   * "Caveats" in the LMDB native documentation.
+   *
+   * @param path writable destination path as described above
+   * @param flags special options for this copy
+   */
+  public void copy(final Path path, final CopyFlagSet flags) {
     requireNonNull(path);
     validatePath(path);
-    checkRc(LIB.mdb_env_copy2(ptr, path.getAbsolutePath(), flags.getMask()));
+    checkRc(LIB.mdb_env_copy2(ptr, path.toAbsolutePath().toString(), flags.getMask()));
   }
 
   /**
@@ -524,22 +572,22 @@ void checkNotClosed() {
     }
   }
 
-  private void validateDirectoryEmpty(final File path) {
-    if (!path.exists()) {
+  private void validateDirectoryEmpty(final Path path) {
+    if (!Files.exists(path)) {
       throw new InvalidCopyDestination("Path does not exist");
     }
-    if (!path.isDirectory()) {
+    if (!Files.isDirectory(path)) {
       throw new InvalidCopyDestination("Path must be a directory");
     }
-    final String[] files = path.list();
-    if (files != null && files.length > 0) {
+    final long fileCount = FileUtil.count(path);
+    if (fileCount > 0) {
       throw new InvalidCopyDestination("Path must contain no files");
     }
   }
 
-  private void validatePath(final File path) {
+  private void validatePath(final Path path) {
     if (noSubDir) {
-      if (path.exists()) {
+      if (Files.exists(path)) {
         throw new InvalidCopyDestination("Path must not exist for MDB_NOSUBDIR");
       }
       return;
diff --git a/src/test/java/org/lmdbjava/FileUtil.java b/src/main/java/org/lmdbjava/FileUtil.java
similarity index 94%
rename from src/test/java/org/lmdbjava/FileUtil.java
rename to src/main/java/org/lmdbjava/FileUtil.java
index cc7ed635..476f0436 100644
--- a/src/test/java/org/lmdbjava/FileUtil.java
+++ b/src/main/java/org/lmdbjava/FileUtil.java
@@ -31,7 +31,7 @@ final class FileUtil {
 
   private FileUtil() {}
 
-  public static long size(final Path path) {
+  static long size(final Path path) {
     try {
       return Files.size(path);
     } catch (final IOException e) {
@@ -39,7 +39,7 @@ public static long size(final Path path) {
     }
   }
 
-  public static void deleteFile(final Path path) {
+  static void deleteFile(final Path path) {
     try {
       Files.delete(path);
     } catch (final IOException e) {
@@ -47,7 +47,7 @@ public static void deleteFile(final Path path) {
     }
   }
 
-  public static void deleteDir(final Path path) {
+  static void deleteDir(final Path path) {
     if (path != null && Files.isDirectory(path)) {
       recursiveDelete(path);
       deleteIfExists(path);
@@ -102,7 +102,7 @@ private static void deleteIfExists(final Path path) {
     }
   }
 
-  public static long count(final Path path) {
+  static long count(final Path path) {
     try (final Stream<Path> stream = Files.list(path)) {
       return stream.count();
     } catch (final IOException e) {
diff --git a/src/test/java/org/lmdbjava/CursorParamTest.java b/src/test/java/org/lmdbjava/CursorParamTest.java
index e228e968..ed43bf5b 100644
--- a/src/test/java/org/lmdbjava/CursorParamTest.java
+++ b/src/test/java/org/lmdbjava/CursorParamTest.java
@@ -170,7 +170,9 @@ private Env<T> env(final Path tmp) {
           .setMapSize(MEBIBYTES.toBytes(1))
           .setMaxReaders(1)
           .setMaxDbs(1)
-          .open(tmp.resolve("db").toFile(), POSIX_MODE, MDB_NOSUBDIR);
+          .setFilePermissions(POSIX_MODE)
+          .setEnvFlags(MDB_NOSUBDIR)
+          .open(tmp.resolve("db"));
     }
   }
 
diff --git a/src/test/java/org/lmdbjava/CursorTest.java b/src/test/java/org/lmdbjava/CursorTest.java
index 530b2e80..509f03dc 100644
--- a/src/test/java/org/lmdbjava/CursorTest.java
+++ b/src/test/java/org/lmdbjava/CursorTest.java
@@ -66,7 +66,9 @@ void beforeEach() {
             .setMapSize(MEBIBYTES.toBytes(1))
             .setMaxReaders(1)
             .setMaxDbs(1)
-            .open(file.toFile(), POSIX_MODE, MDB_NOSUBDIR);
+            .setFilePermissions(POSIX_MODE)
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(file);
   }
 
   @AfterEach
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 632d51b5..fdf55d89 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -85,14 +85,16 @@ void beforeEach() {
             .setMapSize(MEBIBYTES.toBytes(64))
             .setMaxReaders(2)
             .setMaxDbs(2)
-            .open(file.toFile(), MDB_NOSUBDIR);
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(file);
     final Path fileBa = tempDir.createTempFile();
     envBa =
         create(PROXY_BA)
             .setMapSize(MEBIBYTES.toBytes(64))
             .setMaxReaders(2)
             .setMaxDbs(2)
-            .open(fileBa.toFile(), MDB_NOSUBDIR);
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(fileBa);
   }
 
   @AfterEach
@@ -382,7 +384,8 @@ void putCommitGetByteArray() {
             .setMapSize(MEBIBYTES.toBytes(64))
             .setMaxReaders(1)
             .setMaxDbs(2)
-            .open(file.toFile(), MDB_NOSUBDIR)) {
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(file)) {
       final Dbi<byte[]> db = envBa.openDbi(DB_1, MDB_CREATE);
       try (Txn<byte[]> txn = envBa.txnWrite()) {
         db.put(txn, ba(5), ba(5));
diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index 6c24c406..c81bbde7 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -25,7 +25,6 @@
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
 import static org.lmdbjava.Env.Builder.MAX_READERS_DEFAULT;
 import static org.lmdbjava.Env.create;
-import static org.lmdbjava.Env.open;
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
 import static org.lmdbjava.EnvFlags.MDB_RDONLY_ENV;
 import static org.lmdbjava.TestUtils.DB_1;
@@ -69,7 +68,8 @@ void byteUnit() {
         create()
             .setMaxReaders(1)
             .setMapSize(MEBIBYTES.toBytes(1))
-            .open(file.toFile(), MDB_NOSUBDIR)) {
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(file)) {
       final EnvInfo info = env.info();
       assertThat(info.mapSize).isEqualTo(MEBIBYTES.toBytes(1));
     }
@@ -81,7 +81,7 @@ void cannotChangeMapSizeAfterOpen() {
             () -> {
               final Path file = tempDir.createTempFile();
               final Builder<ByteBuffer> builder = create().setMaxReaders(1);
-              try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
+              try (Env<ByteBuffer> env = builder.setEnvFlags(MDB_NOSUBDIR).open(file)) {
                 builder.setMapSize(1);
               }
             })
@@ -94,7 +94,7 @@ void cannotChangeMaxDbsAfterOpen() {
             () -> {
               final Path file = tempDir.createTempFile();
               final Builder<ByteBuffer> builder = create().setMaxReaders(1);
-              try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
+              try (Env<ByteBuffer> env = builder.setEnvFlags(MDB_NOSUBDIR).open(file)) {
                 builder.setMaxDbs(1);
               }
             })
@@ -107,7 +107,7 @@ void cannotChangeMaxReadersAfterOpen() {
             () -> {
               final Path file = tempDir.createTempFile();
               final Builder<ByteBuffer> builder = create().setMaxReaders(1);
-              try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
+              try (Env<ByteBuffer> env = builder.setEnvFlags(MDB_NOSUBDIR).open(file)) {
                 builder.setMaxReaders(1);
               }
             })
@@ -120,7 +120,7 @@ void cannotInfoOnceClosed() {
             () -> {
               final Path file = tempDir.createTempFile();
               final Env<ByteBuffer> env =
-                  create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
+                  create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR).open(file);
               env.close();
               env.info();
             })
@@ -133,8 +133,8 @@ void cannotOpenTwice() {
             () -> {
               final Path file = tempDir.createTempFile();
               final Builder<ByteBuffer> builder = create().setMaxReaders(1);
-              builder.open(file.toFile(), MDB_NOSUBDIR).close();
-              builder.open(file.toFile(), MDB_NOSUBDIR);
+              builder.setEnvFlags(MDB_NOSUBDIR).open(file).close();
+              builder.setEnvFlags(MDB_NOSUBDIR).open(file);
             })
         .isInstanceOf(AlreadyOpenException.class);
   }
@@ -157,7 +157,7 @@ void cannotStatOnceClosed() {
             () -> {
               final Path file = tempDir.createTempFile();
               final Env<ByteBuffer> env =
-                  create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
+                  create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR).open(file);
               env.close();
               env.stat();
             })
@@ -170,7 +170,7 @@ void cannotSyncOnceClosed() {
             () -> {
               final Path file = tempDir.createTempFile();
               final Env<ByteBuffer> env =
-                  create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
+                  create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR).open(file);
               env.close();
               env.sync(false);
             })
@@ -184,8 +184,8 @@ void copyDirectoryBased() {
     assertThat(Files.isDirectory(dest)).isTrue();
     assertThat(FileUtil.count(dest)).isEqualTo(0);
     final Path src = tempDir.createTempDir();
-    try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src.toFile())) {
-      env.copy(dest.toFile(), MDB_CP_COMPACT);
+    try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src)) {
+      env.copy(dest, MDB_CP_COMPACT);
       assertThat(FileUtil.count(dest)).isEqualTo(1);
     }
   }
@@ -197,8 +197,8 @@ void copyDirectoryRejectsFileDestination() {
               final Path dest = tempDir.createTempDir();
               FileUtil.deleteDir(dest);
               final Path src = tempDir.createTempDir();
-              try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src.toFile())) {
-                env.copy(dest.toFile(), MDB_CP_COMPACT);
+              try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src)) {
+                env.copy(dest, MDB_CP_COMPACT);
               }
             })
         .isInstanceOf(InvalidCopyDestination.class);
@@ -212,8 +212,8 @@ void copyDirectoryRejectsMissingDestination() {
               try {
                 Files.delete(dest);
                 final Path src = tempDir.createTempDir();
-                try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src.toFile())) {
-                  env.copy(dest.toFile(), MDB_CP_COMPACT);
+                try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src)) {
+                  env.copy(dest, MDB_CP_COMPACT);
                 }
               } catch (final IOException e) {
                 throw new UncheckedIOException(e);
@@ -232,8 +232,8 @@ void copyDirectoryRejectsNonEmptyDestination() {
                 Files.createDirectory(subDir);
                 assertThat(Files.isDirectory(subDir)).isTrue();
                 final Path src = tempDir.createTempDir();
-                try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src.toFile())) {
-                  env.copy(dest.toFile(), MDB_CP_COMPACT);
+                try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src)) {
+                  env.copy(dest, MDB_CP_COMPACT);
                 }
               } catch (final IOException e) {
                 throw new UncheckedIOException(e);
@@ -247,8 +247,8 @@ void copyFileBased() {
     final Path dest = tempDir.createTempFile();
     assertThat(Files.exists(dest)).isFalse();
     final Path src = tempDir.createTempFile();
-    try (Env<ByteBuffer> env = create().setMaxReaders(1).open(src.toFile(), MDB_NOSUBDIR)) {
-      env.copy(dest.toFile(), MDB_CP_COMPACT);
+    try (Env<ByteBuffer> env = create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR).open(src)) {
+      env.copy(dest, MDB_CP_COMPACT);
     }
     assertThat(FileUtil.size(dest)).isGreaterThan(0L);
   }
@@ -262,8 +262,8 @@ void copyFileRejectsExistingDestination() {
               assertThat(Files.exists(dest)).isTrue();
               final Path src = tempDir.createTempFile();
               try (Env<ByteBuffer> env =
-                  create().setMaxReaders(1).open(src.toFile(), MDB_NOSUBDIR)) {
-                env.copy(dest.toFile(), MDB_CP_COMPACT);
+                  create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR).open(src)) {
+                env.copy(dest, MDB_CP_COMPACT);
               }
             })
         .isInstanceOf(InvalidCopyDestination.class);
@@ -272,7 +272,7 @@ void copyFileRejectsExistingDestination() {
   @Test
   void createAsDirectory() {
     final Path dest = tempDir.createTempDir();
-    final Env<ByteBuffer> env = create().setMaxReaders(1).open(dest.toFile());
+    final Env<ByteBuffer> env = create().setMaxReaders(1).open(dest);
     assertThat(Files.isDirectory(dest)).isTrue();
     env.sync(false);
     env.close();
@@ -288,7 +288,8 @@ void createAsFile() {
             .setMapSize(MEBIBYTES.toBytes(1))
             .setMaxDbs(1)
             .setMaxReaders(1)
-            .open(file.toFile(), MDB_NOSUBDIR)) {
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(file)) {
       env.sync(true);
       assertThat(Files.isRegularFile(file)).isTrue();
     }
@@ -300,7 +301,7 @@ void detectTransactionThreadViolation() {
             () -> {
               final Path file = tempDir.createTempFile();
               try (Env<ByteBuffer> env =
-                  create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR)) {
+                  create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR).open(file)) {
                 env.txnRead();
                 env.txnRead();
               }
@@ -312,7 +313,7 @@ void detectTransactionThreadViolation() {
   void info() {
     final Path file = tempDir.createTempFile();
     try (Env<ByteBuffer> env =
-        create().setMaxReaders(4).setMapSize(123_456).open(file.toFile(), MDB_NOSUBDIR)) {
+        create().setMaxReaders(4).setMapSize(123_456).setEnvFlags(MDB_NOSUBDIR).open(file)) {
       final EnvInfo info = env.info();
       assertThat(info).isNotNull();
       assertThat(info.lastPageNumber).isEqualTo(1L);
@@ -340,7 +341,7 @@ void mapFull() {
                       .setMaxReaders(1)
                       .setMapSize(MEBIBYTES.toBytes(8))
                       .setMaxDbs(1)
-                      .open(dir.toFile())) {
+                      .open(dir)) {
                 final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
                 for (; ; ) {
                   rnd.nextBytes(k);
@@ -357,11 +358,11 @@ void mapFull() {
   @Test
   void readOnlySupported() {
     final Path dir = tempDir.createTempDir();
-    try (Env<ByteBuffer> rwEnv = create().setMaxReaders(1).open(dir.toFile())) {
+    try (Env<ByteBuffer> rwEnv = create().setMaxReaders(1).open(dir)) {
       final Dbi<ByteBuffer> rwDb = rwEnv.openDbi(DB_1, MDB_CREATE);
       rwDb.put(bb(1), bb(42));
     }
-    try (Env<ByteBuffer> roEnv = create().setMaxReaders(1).open(dir.toFile(), MDB_RDONLY_ENV)) {
+    try (Env<ByteBuffer> roEnv = create().setMaxReaders(1).setEnvFlags(MDB_RDONLY_ENV).open(dir)) {
       final Dbi<ByteBuffer> roDb = roEnv.openDbi(DB_1);
       try (Txn<ByteBuffer> roTxn = roEnv.txnRead()) {
         assertThat(roDb.get(roTxn, bb(1))).isNotNull();
@@ -377,11 +378,7 @@ void setMapSize() {
     final ByteBuffer val = allocateDirect(1_024);
     final Random rnd = new Random();
     try (Env<ByteBuffer> env =
-        create()
-            .setMaxReaders(1)
-            .setMapSize(KIBIBYTES.toBytes(256))
-            .setMaxDbs(1)
-            .open(dir.toFile())) {
+        create().setMaxReaders(1).setMapSize(KIBIBYTES.toBytes(256)).setMaxDbs(1).open(dir)) {
       final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
 
       db.put(bb(1), bb(42));
@@ -426,7 +423,7 @@ void setMapSize() {
   @Test
   void stats() {
     final Path file = tempDir.createTempFile();
-    try (Env<ByteBuffer> env = create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR)) {
+    try (Env<ByteBuffer> env = create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR).open(file)) {
       final Stat stat = env.stat();
       assertThat(stat).isNotNull();
       assertThat(stat.branchPages).isEqualTo(0L);
@@ -442,7 +439,7 @@ void stats() {
   @Test
   void testDefaultOpen() {
     final Path dir = tempDir.createTempDir();
-    try (Env<ByteBuffer> env = open(dir.toFile(), 10)) {
+    try (Env<ByteBuffer> env = Env.create().setMapSize(MEBIBYTES.toBytes(10)).open(dir)) {
       final EnvInfo info = env.info();
       assertThat(info.maxReaders).isEqualTo(MAX_READERS_DEFAULT);
       final Dbi<ByteBuffer> db = env.openDbi("test", MDB_CREATE);
diff --git a/src/test/java/org/lmdbjava/GarbageCollectionTest.java b/src/test/java/org/lmdbjava/GarbageCollectionTest.java
index 36273559..0d2ba389 100644
--- a/src/test/java/org/lmdbjava/GarbageCollectionTest.java
+++ b/src/test/java/org/lmdbjava/GarbageCollectionTest.java
@@ -38,8 +38,7 @@ public class GarbageCollectionTest {
   void buffersNotGarbageCollectedTest() {
     try (final TempDir tempDir = new TempDir()) {
       final Path dir = tempDir.createTempDir();
-      try (Env<ByteBuffer> env =
-          create().setMapSize(2_085_760_999).setMaxDbs(1).open(dir.toFile())) {
+      try (Env<ByteBuffer> env = create().setMapSize(2_085_760_999).setMaxDbs(1).open(dir)) {
         final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
 
         try (Txn<ByteBuffer> txn = env.txnWrite()) {
diff --git a/src/test/java/org/lmdbjava/TutorialTest.java b/src/test/java/org/lmdbjava/TutorialTest.java
index 6af2599b..03c7991c 100644
--- a/src/test/java/org/lmdbjava/TutorialTest.java
+++ b/src/test/java/org/lmdbjava/TutorialTest.java
@@ -89,7 +89,7 @@ void tutorial1() {
             // Now let's open the Env. The same path can be concurrently opened and
             // used in different processes, but do not open the same path twice in
             // the same process at the same time.
-            .open(dir.toFile());
+            .open(dir);
 
     // We need a Dbi for each DB. A Dbi roughly equates to a sorted map. The
     // MDB_CREATE flag causes the DB to be created if it doesn't already exist.
@@ -400,10 +400,7 @@ void tutorial6() {
     final Path dir = tempDir.createTempDir();
     // Note we need to specify the Verifier's DBI_COUNT for the Env.
     final Env<ByteBuffer> env =
-        create(PROXY_OPTIMAL)
-            .setMapSize(10_485_760)
-            .setMaxDbs(Verifier.DBI_COUNT)
-            .open(dir.toFile());
+        create(PROXY_OPTIMAL).setMapSize(10_485_760).setMaxDbs(Verifier.DBI_COUNT).open(dir);
 
     // Create a Verifier (it's a Callable<Long> for those needing full control).
     final Verifier v = new Verifier(env);
@@ -422,8 +419,7 @@ void tutorial7() {
     // The critical difference is we pass the PROXY_DB field to Env.create().
     // There's also a PROXY_SAFE if you want to stop ByteBuffer's Unsafe use.
     // Aside from that and a different type argument, it's the same as usual...
-    final Env<DirectBuffer> env =
-        create(PROXY_DB).setMapSize(10_485_760).setMaxDbs(1).open(dir.toFile());
+    final Env<DirectBuffer> env = create(PROXY_DB).setMapSize(10_485_760).setMaxDbs(1).open(dir);
 
     final Dbi<DirectBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
 
@@ -477,6 +473,6 @@ void tutorial7() {
   // or reverse ordered keys, using Env.DISABLE_CHECKS_PROP etc), but you now
   // know enough to tackle the JavaDocs with confidence. Have fun!
   private Env<ByteBuffer> createSimpleEnv(final Path path) {
-    return create().setMapSize(10_485_760).setMaxDbs(1).setMaxReaders(1).open(path.toFile());
+    return create().setMapSize(10_485_760).setMaxDbs(1).setMaxReaders(1).open(path);
   }
 }
diff --git a/src/test/java/org/lmdbjava/TxnTest.java b/src/test/java/org/lmdbjava/TxnTest.java
index ebb06137..3b0c81fd 100644
--- a/src/test/java/org/lmdbjava/TxnTest.java
+++ b/src/test/java/org/lmdbjava/TxnTest.java
@@ -70,7 +70,9 @@ void beforeEach() {
             .setMapSize(KIBIBYTES.toBytes(256))
             .setMaxReaders(1)
             .setMaxDbs(2)
-            .open(file.toFile(), POSIX_MODE, MDB_NOSUBDIR);
+            .setFilePermissions(POSIX_MODE)
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(file);
   }
 
   @AfterEach
@@ -129,7 +131,7 @@ void rangeSearch() {
   void readOnlyTxnAllowedInReadOnlyEnv() {
     env.openDbi(DB_1, MDB_CREATE);
     try (Env<ByteBuffer> roEnv =
-        create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR, MDB_RDONLY_ENV)) {
+        create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR, MDB_RDONLY_ENV).open(file)) {
       assertThat(roEnv.txnRead()).isNotNull();
     }
   }
@@ -141,7 +143,7 @@ void readWriteTxnDeniedInReadOnlyEnv() {
               env.openDbi(DB_1, MDB_CREATE);
               env.close();
               try (Env<ByteBuffer> roEnv =
-                  create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR, MDB_RDONLY_ENV)) {
+                  create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR, MDB_RDONLY_ENV).open(file)) {
                 roEnv.txnWrite(); // error
               }
             })
diff --git a/src/test/java/org/lmdbjava/VerifierTest.java b/src/test/java/org/lmdbjava/VerifierTest.java
index 9d127cf8..df682450 100644
--- a/src/test/java/org/lmdbjava/VerifierTest.java
+++ b/src/test/java/org/lmdbjava/VerifierTest.java
@@ -38,7 +38,8 @@ void verification() {
               .setMaxReaders(1)
               .setMaxDbs(Verifier.DBI_COUNT)
               .setMapSize(MEBIBYTES.toBytes(10))
-              .open(file.toFile(), MDB_NOSUBDIR)) {
+              .setEnvFlags(MDB_NOSUBDIR)
+              .open(file)) {
         final Verifier v = new Verifier(env);
         final int seconds = Integer.getInteger("verificationSeconds", 2);
         assertThat(v.runFor(seconds, TimeUnit.SECONDS)).isGreaterThan(1L);

From d616de4ca4f5b35fd0e03793c632715a4620eaa7 Mon Sep 17 00:00:00 2001
From: stroomdev66 <stroomdev66@gmail.com>
Date: Fri, 7 Nov 2025 15:52:06 +0000
Subject: [PATCH 276/322] Add new line

---
 src/main/java/org/lmdbjava/ByteBufferProxy.java | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
index 3c80b995..cf75562c 100644
--- a/src/main/java/org/lmdbjava/ByteBufferProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -119,6 +119,7 @@ abstract static class AbstractByteBufferProxy extends BufferProxy<ByteBuffer> {
     public static int compareBuff(final ByteBuffer o1, final ByteBuffer o2) {
       requireNonNull(o1);
       requireNonNull(o2);
+
       final int minLength = Math.min(o1.limit(), o2.limit());
       final int minWords = minLength / Long.BYTES;
 

From 48aa0fdebaf57c6cd35f9ab600136c6b2a6edcae Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 7 Nov 2025 16:50:21 +0000
Subject: [PATCH 277/322] Fix javadoc warnings and class visibility, fix
 licence warnings

---
 pom.xml                                       |   1 +
 .../java/org/lmdbjava/AbstractFlagSet.java    |  25 ++--
 src/main/java/org/lmdbjava/ByteUnit.java      |   7 +-
 src/main/java/org/lmdbjava/CopyFlagSet.java   |  55 +++++---
 .../java/org/lmdbjava/CopyFlagSetEmpty.java   |  20 +++
 .../java/org/lmdbjava/CopyFlagSetImpl.java    |  27 ++++
 src/main/java/org/lmdbjava/CopyFlags.java     |   4 +-
 src/main/java/org/lmdbjava/Dbi.java           |   7 +-
 src/main/java/org/lmdbjava/DbiBuilder.java    | 119 ++++++++++--------
 src/main/java/org/lmdbjava/DbiFlagSet.java    |  45 ++++---
 .../java/org/lmdbjava/DbiFlagSetEmpty.java    |  20 +++
 .../java/org/lmdbjava/DbiFlagSetImpl.java     |  27 ++++
 src/main/java/org/lmdbjava/DbiFlags.java      |   2 -
 src/main/java/org/lmdbjava/Env.java           |  14 ++-
 src/main/java/org/lmdbjava/EnvFlagSet.java    |  48 ++++---
 .../java/org/lmdbjava/EnvFlagSetEmpty.java    |  20 +++
 .../java/org/lmdbjava/EnvFlagSetImpl.java     |  27 ++++
 src/main/java/org/lmdbjava/FlagSet.java       |  27 +++-
 src/main/java/org/lmdbjava/MaskedFlag.java    |  12 +-
 src/main/java/org/lmdbjava/PutFlagSet.java    |  44 ++++---
 .../java/org/lmdbjava/PutFlagSetEmpty.java    |  20 +++
 .../java/org/lmdbjava/PutFlagSetImpl.java     |  27 ++++
 src/main/java/org/lmdbjava/TxnFlagSet.java    |  60 +++++----
 .../java/org/lmdbjava/TxnFlagSetEmpty.java    |  20 +++
 .../java/org/lmdbjava/TxnFlagSetImpl.java     |  27 ++++
 .../org/lmdbjava/AbstractFlagSetTest.java     |  21 ++++
 src/test/java/org/lmdbjava/ByteUnitTest.java  |  11 ++
 .../java/org/lmdbjava/CopyFlagSetTest.java    |   2 +-
 .../org/lmdbjava/CursorIterablePerfTest.java  |   2 +-
 .../org/lmdbjava/CursorIterableRangeTest.java |   8 +-
 .../java/org/lmdbjava/DbiBuilderTest.java     |   5 +-
 .../java/org/lmdbjava/DbiFlagSetTest.java     |   2 +-
 .../java/org/lmdbjava/EnvFlagSetTest.java     |   2 +-
 .../org/lmdbjava/GarbageCollectionTest.java   |   2 +-
 .../java/org/lmdbjava/PutFlagSetTest.java     |   2 +-
 src/test/java/org/lmdbjava/TempDir.java       |   2 +-
 .../java/org/lmdbjava/TxnFlagSetTest.java     |   2 +-
 37 files changed, 571 insertions(+), 195 deletions(-)
 create mode 100644 src/main/java/org/lmdbjava/CopyFlagSetEmpty.java
 create mode 100644 src/main/java/org/lmdbjava/CopyFlagSetImpl.java
 create mode 100644 src/main/java/org/lmdbjava/DbiFlagSetEmpty.java
 create mode 100644 src/main/java/org/lmdbjava/DbiFlagSetImpl.java
 create mode 100644 src/main/java/org/lmdbjava/EnvFlagSetEmpty.java
 create mode 100644 src/main/java/org/lmdbjava/EnvFlagSetImpl.java
 create mode 100644 src/main/java/org/lmdbjava/PutFlagSetEmpty.java
 create mode 100644 src/main/java/org/lmdbjava/PutFlagSetImpl.java
 create mode 100644 src/main/java/org/lmdbjava/TxnFlagSetEmpty.java
 create mode 100644 src/main/java/org/lmdbjava/TxnFlagSetImpl.java

diff --git a/pom.xml b/pom.xml
index 11dbdeb5..7c204a77 100644
--- a/pom.xml
+++ b/pom.xml
@@ -139,6 +139,7 @@
               <excludes>
                 <exclude>LICENSE.txt</exclude>
                 <exclude>**/*.md</exclude>
+                <exclude>**/*.csv</exclude>
                 <exclude>lmdb/**</exclude>
                 <exclude>licenses/**</exclude>
               </excludes>
diff --git a/src/main/java/org/lmdbjava/AbstractFlagSet.java b/src/main/java/org/lmdbjava/AbstractFlagSet.java
index 655369e1..cff79ef1 100644
--- a/src/main/java/org/lmdbjava/AbstractFlagSet.java
+++ b/src/main/java/org/lmdbjava/AbstractFlagSet.java
@@ -24,8 +24,10 @@
 import java.util.function.Function;
 import java.util.function.Supplier;
 
-/** Encapsulates an immutable set of flags and the associated bit mask for the flags in the set. */
-public abstract class AbstractFlagSet<T extends Enum<T> & MaskedFlag> implements FlagSet<T> {
+/** Encapsulates an immutable set of flags and the associated bit mask for the flags in the set.
+ * @param <T> The type of the flags in this set. Must extend {@link MaskedFlag} and {@link Enum<T>}.
+ * */
+abstract class AbstractFlagSet<T extends Enum<T> & MaskedFlag> implements FlagSet<T> {
 
   private final Set<T> flags;
   private final int mask;
@@ -36,25 +38,16 @@ protected AbstractFlagSet(final EnumSet<T> flags) {
     this.flags = Collections.unmodifiableSet(Objects.requireNonNull(flags));
   }
 
-  /**
-   * @return THe combined bit mask for all flags in the set.
-   */
   @Override
   public int getMask() {
     return mask;
   }
 
-  /**
-   * @return All flags in the set.
-   */
   @Override
   public Set<T> getFlags() {
     return flags;
   }
 
-  /**
-   * @return True if flag has been set, i.e. is contained in this set.
-   */
   @Override
   public boolean isSet(final T flag) {
     // Probably cheaper to compare the masks than to use EnumSet.contains()
@@ -163,11 +156,6 @@ public String toString() {
       return FlagSet.asString(this);
     }
 
-    @Override
-    public boolean equals(Object object) {
-      return FlagSet.equals(this, object);
-    }
-
     @Override
     public int hashCode() {
       return Objects.hash(flag, getFlags());
@@ -239,7 +227,7 @@ public int hashCode() {
    * @param <E> The type of flag to be held in the {@link AbstractFlagSet}
    * @param <S> The type of the {@link AbstractFlagSet} implementation.
    */
-  public static class Builder<E extends Enum<E> & MaskedFlag, S extends FlagSet<E>> {
+  public static final class Builder<E extends Enum<E> & MaskedFlag, S extends FlagSet<E>> {
 
     final Class<E> type;
     final EnumSet<E> enumSet;
@@ -247,7 +235,7 @@ public static class Builder<E extends Enum<E> & MaskedFlag, S extends FlagSet<E>
     final Function<E, S> singletonSetConstructor;
     final Supplier<S> emptySetSupplier;
 
-    protected Builder(
+    Builder(
         final Class<E> type,
         final Function<EnumSet<E>, S> constructor,
         final Function<E, S> singletonSetConstructor,
@@ -279,6 +267,7 @@ public Builder<E, S> setFlags(final Collection<E> flags) {
     }
 
     /**
+     * Replaces any flags already set in the builder with the passed flags.
      * @param flags The flags to set in the builder.
      * @return this builder instance.
      */
diff --git a/src/main/java/org/lmdbjava/ByteUnit.java b/src/main/java/org/lmdbjava/ByteUnit.java
index ed4b1ca8..c03eea9d 100644
--- a/src/main/java/org/lmdbjava/ByteUnit.java
+++ b/src/main/java/org/lmdbjava/ByteUnit.java
@@ -17,12 +17,14 @@
 
 /** Simple {@link Enum} for converting various IEC and SI byte units down a number of bytes. */
 public enum ByteUnit {
+
+  /** IEC/SI byte unit for bytes. */
   BYTES(1L),
 
   /** IEC byte unit for 1024 bytes. */
-  KIBIBYTES(1024L),
+  KIBIBYTES(1_024L),
   /** IEC byte unit for 1024^2 bytes. */
-  MEBIBYTES(1_0485_76L),
+  MEBIBYTES(1_048_576L),
   /** IEC byte unit for 1024^3 bytes. */
   GIBIBYTES(1_073_741_824L),
   /** IEC byte unit for 1024^4 bytes. */
@@ -59,6 +61,7 @@ public long toBytes(final long value) {
   }
 
   /**
+   * Gets factor to apply when converting this unit into bytes.
    * @return The factor to apply when converting this unit into bytes.
    */
   public long getFactor() {
diff --git a/src/main/java/org/lmdbjava/CopyFlagSet.java b/src/main/java/org/lmdbjava/CopyFlagSet.java
index cea2fce9..56c875c4 100644
--- a/src/main/java/org/lmdbjava/CopyFlagSet.java
+++ b/src/main/java/org/lmdbjava/CopyFlagSet.java
@@ -15,45 +15,60 @@
  */
 package org.lmdbjava;
 
+import java.nio.file.Path;
 import java.util.Collection;
-import java.util.EnumSet;
 import java.util.Objects;
 
+/** An immutable set of flags for use when performing a {@link Env#copy(Path, CopyFlagSet)}. */
 public interface CopyFlagSet extends FlagSet<CopyFlags> {
 
+  /**
+   * An immutable empty {@link CopyFlagSet}.
+   */
   CopyFlagSet EMPTY = CopyFlagSetImpl.EMPTY;
 
+  /**
+   * Gets the immutable empty {@link CopyFlagSet} instance.
+   * @return The immutable empty {@link CopyFlagSet} instance.
+   */
   static CopyFlagSet empty() {
     return CopyFlagSetImpl.EMPTY;
   }
 
-  static CopyFlagSet of(final CopyFlags dbiFlag) {
-    Objects.requireNonNull(dbiFlag);
-    return dbiFlag;
+  /**
+   * Creates an immutable {@link CopyFlagSet} containing copyFlag.
+   * @param copyFlag The flag to include in the {@link CopyFlagSet}
+   * @return An immutable {@link CopyFlagSet} containing just copyFlag.
+   */
+  static CopyFlagSet of(final CopyFlags copyFlag) {
+    Objects.requireNonNull(copyFlag);
+    return copyFlag;
   }
 
-  static CopyFlagSet of(final CopyFlags... CopyFlags) {
-    return builder().setFlags(CopyFlags).build();
+  /**
+   * Creates an immutable {@link CopyFlagSet} containing copyFlags.
+   * @param copyFlags The flags to include in the {@link CopyFlagSet}.
+   * @return An immutable {@link CopyFlagSet} containing copyFlags.
+   */
+  static CopyFlagSet of(final CopyFlags... copyFlags) {
+    return builder().setFlags(copyFlags).build();
   }
 
-  static CopyFlagSet of(final Collection<CopyFlags> CopyFlags) {
-    return builder().setFlags(CopyFlags).build();
+  /**
+   * Creates an immutable {@link CopyFlagSet} containing copyFlags.
+   * @param copyFlags The flags to include in the {@link CopyFlagSet}.
+   * @return An immutable {@link CopyFlagSet} containing copyFlags.
+   */
+  static CopyFlagSet of(final Collection<CopyFlags> copyFlags) {
+    return builder().setFlags(copyFlags).build();
   }
 
+  /**
+   * Create a builder for building an {@link CopyFlagSet}.
+   * @return A builder instance for building an {@link CopyFlagSet}.
+   */
   static AbstractFlagSet.Builder<CopyFlags, CopyFlagSet> builder() {
     return new AbstractFlagSet.Builder<>(
         CopyFlags.class, CopyFlagSetImpl::new, copyFlag -> copyFlag, () -> CopyFlagSetImpl.EMPTY);
   }
-
-  class CopyFlagSetImpl extends AbstractFlagSet<CopyFlags> implements CopyFlagSet {
-
-    static final CopyFlagSet EMPTY = new EmptyCopyFlagSet();
-
-    private CopyFlagSetImpl(final EnumSet<CopyFlags> flags) {
-      super(flags);
-    }
-  }
-
-  class EmptyCopyFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<CopyFlags>
-      implements CopyFlagSet {}
 }
diff --git a/src/main/java/org/lmdbjava/CopyFlagSetEmpty.java b/src/main/java/org/lmdbjava/CopyFlagSetEmpty.java
new file mode 100644
index 00000000..3227b9e9
--- /dev/null
+++ b/src/main/java/org/lmdbjava/CopyFlagSetEmpty.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+class CopyFlagSetEmpty extends AbstractFlagSet.AbstractEmptyFlagSet<CopyFlags>
+    implements CopyFlagSet {
+}
diff --git a/src/main/java/org/lmdbjava/CopyFlagSetImpl.java b/src/main/java/org/lmdbjava/CopyFlagSetImpl.java
new file mode 100644
index 00000000..a566fc2a
--- /dev/null
+++ b/src/main/java/org/lmdbjava/CopyFlagSetImpl.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import java.util.EnumSet;
+
+class CopyFlagSetImpl extends AbstractFlagSet<CopyFlags> implements CopyFlagSet {
+
+  static final CopyFlagSet EMPTY = new CopyFlagSetEmpty();
+
+  CopyFlagSetImpl(final EnumSet<CopyFlags> flags) {
+    super(flags);
+  }
+}
diff --git a/src/main/java/org/lmdbjava/CopyFlags.java b/src/main/java/org/lmdbjava/CopyFlags.java
index b45dc87c..d2d7b0e2 100644
--- a/src/main/java/org/lmdbjava/CopyFlags.java
+++ b/src/main/java/org/lmdbjava/CopyFlags.java
@@ -15,11 +15,11 @@
  */
 package org.lmdbjava;
 
-import java.io.File;
+import java.nio.file.Path;
 import java.util.EnumSet;
 import java.util.Set;
 
-/** Flags for use when performing a {@link Env#copy(File, CopyFlagSet)}. */
+/** Flags for use when performing a {@link Env#copy(Path, CopyFlagSet)}. */
 public enum CopyFlags implements MaskedFlag, CopyFlagSet {
 
   /** Compacting copy: Omit free space from copy, and renumber all pages sequentially. */
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index 88d1bb53..3a387960 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -271,12 +271,16 @@ public T get(final Txn<T> txn, final T key) {
   /**
    * Obtains the name of this database.
    *
-   * @return the name (may be null)
+   * @return The name (it maybe null)
    */
   public byte[] getName() {
     return name == null ? null : Arrays.copyOf(name, name.length);
   }
 
+  /**
+   * Obtains the name of this database, using the {@link Env#DEFAULT_NAME_CHARSET} {@link Charset}.
+   * @return The name of this database, using the {@link Env#DEFAULT_NAME_CHARSET} {@link Charset}.
+   */
   public String getNameAsString() {
     return getNameAsString(Env.DEFAULT_NAME_CHARSET);
   }
@@ -284,6 +288,7 @@ public String getNameAsString() {
   /**
    * Obtains the name of this database, using the supplied {@link Charset}.
    *
+   * @param charset The {@link Charset} to use when converting the DB from a byte[] to a {@link String}.
    * @return The name of the database. If this is the unnamed database an empty string will be
    *     returned.
    * @throws RuntimeException if the name can't be decoded.
diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
index 450fb3c7..df9853ff 100644
--- a/src/main/java/org/lmdbjava/DbiBuilder.java
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -26,7 +26,7 @@
  *
  * @param <T> buffer type
  */
-public class DbiBuilder<T> {
+public final class DbiBuilder<T> {
 
   private final Env<T> env;
   private final BufferProxy<T> proxy;
@@ -48,7 +48,7 @@ public class DbiBuilder<T> {
    *     DbiBuilder#withoutDbName()})
    * @return The next builder stage.
    */
-  public DbiBuilderStage2<T> setDbName(final String name) {
+  public Stage2<T> setDbName(final String name) {
     // Null name is allowed so no null check
     final byte[] nameBytes = name == null ? null : name.getBytes(Env.DEFAULT_NAME_CHARSET);
     return setDbName(nameBytes);
@@ -60,10 +60,10 @@ public DbiBuilderStage2<T> setDbName(final String name) {
    * @param name The name of the database in byte form.
    * @return The next builder stage.
    */
-  public DbiBuilderStage2<T> setDbName(final byte[] name) {
+  public Stage2<T> setDbName(final byte[] name) {
     // Null name is allowed so no null check
     this.name = name;
-    return new DbiBuilderStage2<>(this);
+    return new Stage2<>(this);
   }
 
   /**
@@ -78,7 +78,7 @@ public DbiBuilderStage2<T> setDbName(final byte[] name) {
    *
    * @return The next builder stage.
    */
-  public DbiBuilderStage2<T> withoutDbName() {
+  public Stage2<T> withoutDbName() {
     return setDbName((byte[]) null);
   }
 
@@ -87,14 +87,14 @@ public DbiBuilderStage2<T> withoutDbName() {
    *
    * @param <T> buffer type
    */
-  public static class DbiBuilderStage2<T> {
+  public static final class Stage2<T> {
 
     private final DbiBuilder<T> dbiBuilder;
 
     private ComparatorFactory<T> comparatorFactory;
     private ComparatorType comparatorType;
 
-    private DbiBuilderStage2(final DbiBuilder<T> dbiBuilder) {
+    private Stage2(final DbiBuilder<T> dbiBuilder) {
       this.dbiBuilder = dbiBuilder;
     }
 
@@ -109,20 +109,20 @@ private DbiBuilderStage2(final DbiBuilder<T> dbiBuilder) {
      * functionally identical.
      *
      * <p>This option may be slightly more performant than when using {@link
-     * DbiBuilderStage2#withNativeComparator()} which calls down to LMDB for ALL comparison
+     * Stage2#withNativeComparator()} which calls down to LMDB for ALL comparison
      * operations.
      *
      * <p>If you do not intend to use {@link CursorIterable} then it doesn't matter whether you
-     * choose {@link DbiBuilderStage2#withNativeComparator()}, {@link
-     * DbiBuilderStage2#withDefaultComparator()} or {@link
-     * DbiBuilderStage2#withIteratorComparator(ComparatorFactory)} as these comparators will never
+     * choose {@link Stage2#withNativeComparator()}, {@link
+     * Stage2#withDefaultComparator()} or {@link
+     * Stage2#withIteratorComparator(ComparatorFactory)} as these comparators will never
      * be used.
      *
      * @return The next builder stage.
      */
-    public DbiBuilderStage3<T> withDefaultComparator() {
+    public Stage3<T> withDefaultComparator() {
       this.comparatorType = ComparatorType.DEFAULT;
-      return new DbiBuilderStage3<>(this);
+      return new Stage3<>(this);
     }
 
     /**
@@ -131,21 +131,21 @@ public DbiBuilderStage3<T> withDefaultComparator() {
      * keys using the same comparator that is used for insertion order into the db.
      *
      * <p>This option may be slightly less performant than when using {@link
-     * DbiBuilderStage2#withDefaultComparator()} as it needs to call down to LMDB to perform the
+     * Stage2#withDefaultComparator()} as it needs to call down to LMDB to perform the
      * comparisons, however it guarantees that {@link CursorIterable} key comparison matches LMDB
      * key comparison.
      *
      * <p>If you do not intend to use {@link CursorIterable} then it doesn't matter whether you
-     * choose {@link DbiBuilderStage2#withNativeComparator()}, {@link
-     * DbiBuilderStage2#withDefaultComparator()} or {@link
-     * DbiBuilderStage2#withIteratorComparator(ComparatorFactory)} as these comparators will never
+     * choose {@link Stage2#withNativeComparator()}, {@link
+     * Stage2#withDefaultComparator()} or {@link
+     * Stage2#withIteratorComparator(ComparatorFactory)} as these comparators will never
      * be used.
      *
      * @return The next builder stage.
      */
-    public DbiBuilderStage3<T> withNativeComparator() {
+    public Stage3<T> withNativeComparator() {
       this.comparatorType = ComparatorType.NATIVE;
-      return new DbiBuilderStage3<>(this);
+      return new Stage3<>(this);
     }
 
     /**
@@ -167,11 +167,11 @@ public DbiBuilderStage3<T> withNativeComparator() {
      *     the {@link Dbi}. It must not return null.
      * @return The next builder stage.
      */
-    public DbiBuilderStage3<T> withCallbackComparator(
+    public Stage3<T> withCallbackComparator(
         final ComparatorFactory<T> comparatorFactory) {
       this.comparatorFactory = Objects.requireNonNull(comparatorFactory);
       this.comparatorType = ComparatorType.CALLBACK;
-      return new DbiBuilderStage3<>(this);
+      return new Stage3<>(this);
     }
 
     /**
@@ -189,9 +189,9 @@ public DbiBuilderStage3<T> withCallbackComparator(
      * when using {@link CursorIterable}.
      *
      * <p>If you do not intend to use {@link CursorIterable} then it doesn't matter whether you
-     * choose {@link DbiBuilderStage2#withNativeComparator()}, {@link
-     * DbiBuilderStage2#withDefaultComparator()} or {@link
-     * DbiBuilderStage2#withIteratorComparator(ComparatorFactory)} as these comparators will never
+     * choose {@link Stage2#withNativeComparator()}, {@link
+     * Stage2#withDefaultComparator()} or {@link
+     * Stage2#withIteratorComparator(ComparatorFactory)} as these comparators will never
      * be used.
      *
      * @param comparatorFactory The comparator to use with {@link CursorIterable}. {@link
@@ -199,11 +199,11 @@ public DbiBuilderStage3<T> withCallbackComparator(
      *     the {@link Dbi}. It must not return null.
      * @return The next builder stage.
      */
-    public DbiBuilderStage3<T> withIteratorComparator(
+    public Stage3<T> withIteratorComparator(
         final ComparatorFactory<T> comparatorFactory) {
       this.comparatorFactory = Objects.requireNonNull(comparatorFactory);
       this.comparatorType = ComparatorType.ITERATOR;
-      return new DbiBuilderStage3<>(this);
+      return new Stage3<>(this);
     }
   }
 
@@ -212,31 +212,32 @@ public DbiBuilderStage3<T> withIteratorComparator(
    *
    * @param <T> buffer type
    */
-  public static class DbiBuilderStage3<T> {
+  public static final class Stage3<T> {
 
-    private final DbiBuilderStage2<T> dbiBuilderStage2;
+    private final Stage2<T> stage2;
     private final AbstractFlagSet.Builder<DbiFlags, DbiFlagSet> flagSetBuilder =
         DbiFlagSet.builder();
     private Txn<T> txn = null;
 
-    private DbiBuilderStage3(DbiBuilderStage2<T> dbiBuilderStage2) {
-      this.dbiBuilderStage2 = dbiBuilderStage2;
+    private Stage3(Stage2<T> stage2) {
+      this.stage2 = stage2;
     }
 
     /**
      * Apply all the dbi flags supplied in dbiFlags.
      *
      * <p>Clears all flags currently set by previous calls to {@link
-     * DbiBuilderStage3#setDbiFlags(Collection)}, {@link DbiBuilderStage3#setDbiFlags(DbiFlags...)}
-     * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
+     * Stage3#setDbiFlags(Collection)}, {@link Stage3#setDbiFlags(DbiFlags...)}
+     * or {@link Stage3#addDbiFlag(DbiFlags)}.
      *
      * @param dbiFlags to open the database with. A null {@link Collection} will just clear all set
      *     flags. Null items are ignored.
+     * @return This builder instance.
      */
-    public DbiBuilderStage3<T> setDbiFlags(final Collection<DbiFlags> dbiFlags) {
+    public Stage3<T> setDbiFlags(final Collection<DbiFlags> dbiFlags) {
       flagSetBuilder.clear();
       if (dbiFlags != null) {
-        dbiFlags.stream().filter(Objects::nonNull).forEach(dbiFlags::add);
+        dbiFlags.stream().filter(Objects::nonNull).forEach(this.flagSetBuilder::addFlag);
       }
       return this;
     }
@@ -245,13 +246,14 @@ public DbiBuilderStage3<T> setDbiFlags(final Collection<DbiFlags> dbiFlags) {
      * Apply all the dbi flags supplied in dbiFlags.
      *
      * <p>Clears all flags currently set by previous calls to {@link
-     * DbiBuilderStage3#setDbiFlags(Collection)}, {@link DbiBuilderStage3#setDbiFlags(DbiFlags...)}
-     * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
+     * Stage3#setDbiFlags(Collection)}, {@link Stage3#setDbiFlags(DbiFlags...)}
+     * or {@link Stage3#addDbiFlag(DbiFlags)}.
      *
      * @param dbiFlags to open the database with. A null array will just clear all set flags. Null
      *     items are ignored.
+     * @return This builder instance.
      */
-    public DbiBuilderStage3<T> setDbiFlags(final DbiFlags... dbiFlags) {
+    public Stage3<T> setDbiFlags(final DbiFlags... dbiFlags) {
       flagSetBuilder.clear();
       if (dbiFlags != null) {
         Arrays.stream(dbiFlags).filter(Objects::nonNull).forEach(this.flagSetBuilder::addFlag);
@@ -263,12 +265,13 @@ public DbiBuilderStage3<T> setDbiFlags(final DbiFlags... dbiFlags) {
      * Apply all the dbi flags supplied in dbiFlags.
      *
      * <p>Clears all flags currently set by previous calls to {@link
-     * DbiBuilderStage3#setDbiFlags(Collection)}, {@link DbiBuilderStage3#setDbiFlags(DbiFlags...)}
-     * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
+     * Stage3#setDbiFlags(Collection)}, {@link Stage3#setDbiFlags(DbiFlags...)}
+     * or {@link Stage3#addDbiFlag(DbiFlags)}.
      *
      * @param dbiFlagSet to open the database with. A null value will just clear all set flags.
+     * @return This builder instance.
      */
-    public DbiBuilderStage3<T> setDbiFlags(final DbiFlagSet dbiFlagSet) {
+    public Stage3<T> setDbiFlags(final DbiFlagSet dbiFlagSet) {
       flagSetBuilder.clear();
       if (dbiFlagSet != null) {
         this.flagSetBuilder.setFlags(dbiFlagSet.getFlags());
@@ -278,28 +281,28 @@ public DbiBuilderStage3<T> setDbiFlags(final DbiFlagSet dbiFlagSet) {
 
     /**
      * Adds a dbiFlag to those flags already added to this builder by {@link
-     * DbiBuilderStage3#setDbiFlags(DbiFlags...)}, {@link DbiBuilderStage3#setDbiFlags(Collection)}
-     * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
+     * Stage3#setDbiFlags(DbiFlags...)}, {@link Stage3#setDbiFlags(Collection)}
+     * or {@link Stage3#addDbiFlag(DbiFlags)}.
      *
      * @param dbiFlag to add to any existing flags. A null value is a no-op.
      * @return this builder instance.
      */
-    public DbiBuilderStage3<T> addDbiFlag(final DbiFlags dbiFlag) {
+    public Stage3<T> addDbiFlag(final DbiFlags dbiFlag) {
       this.flagSetBuilder.addFlag(dbiFlag);
       return this;
     }
 
     /**
      * Adds a dbiFlag to those flags already added to this builder by {@link
-     * DbiBuilderStage3#setDbiFlags(DbiFlags...)}, {@link DbiBuilderStage3#setDbiFlags(Collection)}
-     * or {@link DbiBuilderStage3#addDbiFlag(DbiFlags)}.
+     * Stage3#setDbiFlags(DbiFlags...)}, {@link Stage3#setDbiFlags(Collection)}
+     * or {@link Stage3#addDbiFlag(DbiFlags)}.
      *
      * @param dbiFlagSet to add to any existing flags. A null value is a no-op.
      * @return this builder instance.
      */
-    public DbiBuilderStage3<T> addDbiFlags(final DbiFlagSet dbiFlagSet) {
+    public Stage3<T> addDbiFlags(final DbiFlagSet dbiFlagSet) {
       if (dbiFlagSet != null) {
-        flagSetBuilder.addFlags(dbiFlagSet.getFlags());
+        this.flagSetBuilder.addFlags(dbiFlagSet.getFlags());
       }
       return this;
     }
@@ -307,7 +310,7 @@ public DbiBuilderStage3<T> addDbiFlags(final DbiFlagSet dbiFlagSet) {
     /**
      * Use the supplied transaction to open the {@link Dbi}.
      *
-     * <p>The caller MUST commit the transaction after calling {@link DbiBuilderStage3#open()}, in
+     * <p>The caller MUST commit the transaction after calling {@link Stage3#open()}, in
      * order to retain the <code>Dbi</code> in the <code>Env</code>.
      *
      * <p>If you don't call this method to supply a {@link Txn}, a {@link Txn} will be opened for
@@ -319,7 +322,7 @@ public DbiBuilderStage3<T> addDbiFlags(final DbiFlagSet dbiFlagSet) {
      *     be a read/write {@link Txn}.
      * @return this builder instance.
      */
-    public DbiBuilderStage3<T> setTxn(final Txn<T> txn) {
+    public Stage3<T> setTxn(final Txn<T> txn) {
       this.txn = Objects.requireNonNull(txn);
       return this;
     }
@@ -333,7 +336,7 @@ public DbiBuilderStage3<T> setTxn(final Txn<T> txn) {
      * @return A newly constructed and opened {@link Dbi}.
      */
     public Dbi<T> open() {
-      final DbiBuilder<T> dbiBuilder = dbiBuilderStage2.dbiBuilder;
+      final DbiBuilder<T> dbiBuilder = stage2.dbiBuilder;
       if (txn != null) {
         return openDbi(txn, dbiBuilder);
       } else {
@@ -363,7 +366,7 @@ private Comparator<T> getComparator(
           break;
         case CALLBACK:
         case ITERATOR:
-          comparator = dbiBuilderStage2.comparatorFactory.create(dbiFlagSet);
+          comparator = stage2.comparatorFactory.create(dbiFlagSet);
           Objects.requireNonNull(comparator, "comparatorFactory returned null");
           break;
         case NATIVE:
@@ -376,7 +379,7 @@ private Comparator<T> getComparator(
 
     private Dbi<T> openDbi(final Txn<T> txn, final DbiBuilder<T> dbiBuilder) {
       final DbiFlagSet dbiFlagSet = flagSetBuilder.build();
-      final ComparatorType comparatorType = dbiBuilderStage2.comparatorType;
+      final ComparatorType comparatorType = stage2.comparatorType;
       final Comparator<T> comparator = getComparator(dbiBuilder, comparatorType, dbiFlagSet);
       final boolean useNativeCallback = comparatorType == ComparatorType.CALLBACK;
       return new Dbi<>(
@@ -408,9 +411,21 @@ private enum ComparatorType {
     ;
   }
 
+  /**
+   * A factory for creating a {@link Comparator} from a {@link DbiFlagSet}
+   * @param <T> The type of buffer that will be compared by the created {@link Comparator}.
+   */
   @FunctionalInterface
   public interface ComparatorFactory<T> {
 
+    /**
+     * Creates a comparator for the supplied {@link DbiFlagSet}. This will only be called once
+     * during the initialisation of the {@link Dbi}.
+     *
+     * @param dbiFlagSet The flags set on the DB that the returned {@link Comparator} will be used by.
+     *                   The flags in the set may impact how the returned {@link Comparator} should behave.
+     * @return A {@link Comparator} applicable to the passed DB flags.
+     */
     Comparator<T> create(final DbiFlagSet dbiFlagSet);
   }
 }
diff --git a/src/main/java/org/lmdbjava/DbiFlagSet.java b/src/main/java/org/lmdbjava/DbiFlagSet.java
index d0b13793..2481f166 100644
--- a/src/main/java/org/lmdbjava/DbiFlagSet.java
+++ b/src/main/java/org/lmdbjava/DbiFlagSet.java
@@ -16,9 +16,9 @@
 package org.lmdbjava;
 
 import java.util.Collection;
-import java.util.EnumSet;
 import java.util.Objects;
 
+/** An immutable set of flags for use when opening a {@link Dbi}. */
 public interface DbiFlagSet extends FlagSet<DbiFlags> {
 
   /** An immutable empty {@link DbiFlagSet}. */
@@ -27,37 +27,48 @@ public interface DbiFlagSet extends FlagSet<DbiFlags> {
   /** The set of {@link DbiFlags} that indicate unsigned integer keys are being used. */
   DbiFlagSet INTEGER_KEY_FLAGS = DbiFlagSet.of(DbiFlags.MDB_INTEGERKEY, DbiFlags.MDB_INTEGERDUP);
 
+  /**
+   * Gets the immutable empty {@link DbiFlagSet} instance.
+   * @return The immutable empty {@link DbiFlagSet} instance.
+   */
   static DbiFlagSet empty() {
     return DbiFlagSetImpl.EMPTY;
   }
 
+  /**
+   * Creates an immutable {@link DbiFlagSet} containing dbiFlag.
+   * @param dbiFlag The flag to include in the {@link DbiFlagSet}
+   * @return An immutable {@link DbiFlagSet} containing just dbiFlag.
+   */
   static DbiFlagSet of(final DbiFlags dbiFlag) {
     Objects.requireNonNull(dbiFlag);
     return dbiFlag;
   }
 
-  static DbiFlagSet of(final DbiFlags... DbiFlags) {
-    return builder().setFlags(DbiFlags).build();
+  /**
+   * Creates an immutable {@link DbiFlagSet} containing dbiFlags.
+   * @param dbiFlags The flags to include in the {@link DbiFlagSet}.
+   * @return An immutable {@link DbiFlagSet} containing dbiFlags.
+   */
+  static DbiFlagSet of(final DbiFlags... dbiFlags) {
+    return builder().setFlags(dbiFlags).build();
   }
 
-  static DbiFlagSet of(final Collection<DbiFlags> DbiFlags) {
-    return builder().setFlags(DbiFlags).build();
+  /**
+   * Creates an immutable {@link DbiFlagSet} containing dbiFlags.
+   * @param dbiFlags The flags to include in the {@link DbiFlagSet}.
+   * @return An immutable {@link DbiFlagSet} containing dbiFlags.
+   */
+  static DbiFlagSet of(final Collection<DbiFlags> dbiFlags) {
+    return builder().setFlags(dbiFlags).build();
   }
 
+  /**
+   * Create a builder for building an {@link DbiFlagSet}.
+   * @return A builder instance for building an {@link DbiFlagSet}.
+   */
   static AbstractFlagSet.Builder<DbiFlags, DbiFlagSet> builder() {
     return new AbstractFlagSet.Builder<>(
         DbiFlags.class, DbiFlagSetImpl::new, dbiFlag -> dbiFlag, () -> DbiFlagSetImpl.EMPTY);
   }
-
-  class DbiFlagSetImpl extends AbstractFlagSet<DbiFlags> implements DbiFlagSet {
-
-    static final DbiFlagSet EMPTY = new EmptyDbiFlagSet();
-
-    private DbiFlagSetImpl(final EnumSet<DbiFlags> flags) {
-      super(flags);
-    }
-  }
-
-  class EmptyDbiFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<DbiFlags>
-      implements DbiFlagSet {}
 }
diff --git a/src/main/java/org/lmdbjava/DbiFlagSetEmpty.java b/src/main/java/org/lmdbjava/DbiFlagSetEmpty.java
new file mode 100644
index 00000000..3b57642c
--- /dev/null
+++ b/src/main/java/org/lmdbjava/DbiFlagSetEmpty.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+class DbiFlagSetEmpty extends AbstractFlagSet.AbstractEmptyFlagSet<DbiFlags>
+    implements DbiFlagSet {
+}
diff --git a/src/main/java/org/lmdbjava/DbiFlagSetImpl.java b/src/main/java/org/lmdbjava/DbiFlagSetImpl.java
new file mode 100644
index 00000000..a43e887f
--- /dev/null
+++ b/src/main/java/org/lmdbjava/DbiFlagSetImpl.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import java.util.EnumSet;
+
+class DbiFlagSetImpl extends AbstractFlagSet<DbiFlags> implements DbiFlagSet {
+
+  static final DbiFlagSet EMPTY = new DbiFlagSetEmpty();
+
+  DbiFlagSetImpl(final EnumSet<DbiFlags> flags) {
+    super(flags);
+  }
+}
diff --git a/src/main/java/org/lmdbjava/DbiFlags.java b/src/main/java/org/lmdbjava/DbiFlags.java
index f8ccbe20..e1e66a31 100644
--- a/src/main/java/org/lmdbjava/DbiFlags.java
+++ b/src/main/java/org/lmdbjava/DbiFlags.java
@@ -34,8 +34,6 @@ public enum DbiFlags implements MaskedFlag, DbiFlagSet {
    * <p>Duplicate keys may be used in the database. Or, from another perspective, keys may have
    * multiple data items, stored in sorted order. By default, keys must be unique and may have only
    * a single data item.
-   *
-   * <p>
    */
   MDB_DUPSORT(0x04),
   /**
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index c2b337ce..b368b4aa 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -54,6 +54,10 @@ public final class Env<T> implements AutoCloseable {
   /** Java system property name that can be set to disable optional checks. */
   public static final String DISABLE_CHECKS_PROP = "lmdbjava.disable.checks";
 
+  /**
+   * The default {@link Charset} used to convert DB names from a byte[] to a String or
+   * to encode a String as a byte[]. Only used if not explicit {@link Charset} is provided.
+   */
   public static final Charset DEFAULT_NAME_CHARSET = StandardCharsets.UTF_8;
 
   /**
@@ -196,9 +200,9 @@ public void copy(final Path path, final CopyFlagSet flags) {
    * @deprecated Use {@link Env#copy(Path, CopyFlagSet)}
    */
   @Deprecated
-  public void copy(final File path, final CopyFlagSet flags) {
+  public void copy(final File path, final CopyFlags... flags) {
     requireNonNull(path);
-    copy(path.toPath(), flags);
+    copy(path.toPath(), CopyFlagSet.of(flags));
   }
 
   /**
@@ -268,7 +272,8 @@ public void setMapSize(final long mapSize) {
   /**
    * Set the size of the data memory map.
    *
-   * @param mapSize the new size, in bytes
+   * @param mapSize new map size in the units of byteUnit.
+   * @param byteUnit The unit that mapSize is in.
    */
   public void setMapSize(final long mapSize, final ByteUnit byteUnit) {
     requireNonNull(byteUnit);
@@ -804,7 +809,8 @@ public Builder<T> setMapSize(final long mapSize) {
     /**
      * Sets the map size in the supplied unit.
      *
-     * @param mapSize new limit in
+     * @param mapSize new map size in the units of byteUnit.
+     * @param byteUnit The unit that mapSize is in.
      * @return the builder
      */
     public Builder<T> setMapSize(final long mapSize, final ByteUnit byteUnit) {
diff --git a/src/main/java/org/lmdbjava/EnvFlagSet.java b/src/main/java/org/lmdbjava/EnvFlagSet.java
index 4ce5eadc..7e5f8cc3 100644
--- a/src/main/java/org/lmdbjava/EnvFlagSet.java
+++ b/src/main/java/org/lmdbjava/EnvFlagSet.java
@@ -16,44 +16,58 @@
 package org.lmdbjava;
 
 import java.util.Collection;
-import java.util.EnumSet;
 import java.util.Objects;
 
+/** An immutable set of flags for use when opening the {@link Env}. */
 public interface EnvFlagSet extends FlagSet<EnvFlags> {
 
+  /**
+   * An immutable empty {@link EnvFlagSet}.
+   */
   EnvFlagSet EMPTY = EnvFlagSetImpl.EMPTY;
 
+  /**
+   * Gets the immutable empty {@link EnvFlagSet} instance.
+   * @return The immutable empty {@link EnvFlagSet} instance.
+   */
   static EnvFlagSet empty() {
     return EnvFlagSetImpl.EMPTY;
   }
 
+  /**
+   * Creates an immutable {@link EnvFlagSet} containing envFlag.
+   * @param envFlag The flag to include in the {@link EnvFlagSet}
+   * @return An immutable {@link EnvFlagSet} containing just envFlag.
+   */
   static EnvFlagSet of(final EnvFlags envFlag) {
     Objects.requireNonNull(envFlag);
     return envFlag;
   }
 
-  static EnvFlagSet of(final EnvFlags... EnvFlags) {
-    return builder().setFlags(EnvFlags).build();
+  /**
+   * Creates an immutable {@link EnvFlagSet} containing envFlags.
+   * @param envFlags The flags to include in the {@link EnvFlagSet}.
+   * @return An immutable {@link EnvFlagSet} containing envFlags.
+   */
+  static EnvFlagSet of(final EnvFlags... envFlags) {
+    return builder().setFlags(envFlags).build();
   }
 
-  static EnvFlagSet of(final Collection<EnvFlags> EnvFlags) {
-    return builder().setFlags(EnvFlags).build();
+  /**
+   * Creates an immutable {@link EnvFlagSet} containing envFlags.
+   * @param envFlags The flags to include in the {@link EnvFlagSet}.
+   * @return An immutable {@link EnvFlagSet} containing envFlags.
+   */
+  static EnvFlagSet of(final Collection<EnvFlags> envFlags) {
+    return builder().setFlags(envFlags).build();
   }
 
+  /**
+   * Create a builder for building an {@link EnvFlagSet}.
+   * @return A builder instance for building an {@link EnvFlagSet}.
+   */
   static AbstractFlagSet.Builder<EnvFlags, EnvFlagSet> builder() {
     return new AbstractFlagSet.Builder<>(
         EnvFlags.class, EnvFlagSetImpl::new, envFlag -> envFlag, () -> EnvFlagSetImpl.EMPTY);
   }
-
-  class EnvFlagSetImpl extends AbstractFlagSet<EnvFlags> implements EnvFlagSet {
-
-    static final EnvFlagSet EMPTY = new EmptyEnvFlagSet();
-
-    private EnvFlagSetImpl(final EnumSet<EnvFlags> flags) {
-      super(flags);
-    }
-  }
-
-  class EmptyEnvFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<EnvFlags>
-      implements EnvFlagSet {}
 }
diff --git a/src/main/java/org/lmdbjava/EnvFlagSetEmpty.java b/src/main/java/org/lmdbjava/EnvFlagSetEmpty.java
new file mode 100644
index 00000000..7cd55edf
--- /dev/null
+++ b/src/main/java/org/lmdbjava/EnvFlagSetEmpty.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+class EnvFlagSetEmpty extends AbstractFlagSet.AbstractEmptyFlagSet<EnvFlags>
+    implements EnvFlagSet {
+}
diff --git a/src/main/java/org/lmdbjava/EnvFlagSetImpl.java b/src/main/java/org/lmdbjava/EnvFlagSetImpl.java
new file mode 100644
index 00000000..ba1bdfef
--- /dev/null
+++ b/src/main/java/org/lmdbjava/EnvFlagSetImpl.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import java.util.EnumSet;
+
+class EnvFlagSetImpl extends AbstractFlagSet<EnvFlags> implements EnvFlagSet {
+
+  static final EnvFlagSet EMPTY = new EnvFlagSetEmpty();
+
+  EnvFlagSetImpl(final EnumSet<EnvFlags> flags) {
+    super(flags);
+  }
+}
diff --git a/src/main/java/org/lmdbjava/FlagSet.java b/src/main/java/org/lmdbjava/FlagSet.java
index e5e1c6a4..de63d9c6 100644
--- a/src/main/java/org/lmdbjava/FlagSet.java
+++ b/src/main/java/org/lmdbjava/FlagSet.java
@@ -25,16 +25,19 @@
  * A set of flags, each with a bit mask value. Flags can be combined in a set such that the set has
  * a combined bit mask value.
  *
- * @param <T>
+ * @param <T> The type of flag in the set, must extend {@link MaskedFlag}.
  */
 public interface FlagSet<T extends MaskedFlag> extends Iterable<T> {
 
   /**
+   * The combined mask for this flagSet.
    * @return The combined mask for this flagSet.
    */
   int getMask();
 
   /**
+   * Combines this {@link FlagSet} with another and returns the combined mask value.
+   * @param other The other {@link FlagSet} to combine with this.
    * @return The result of combining the mask of this {@link FlagSet} with the mask of the other
    *     {@link FlagSet}.
    */
@@ -47,22 +50,28 @@ default int getMaskWith(final FlagSet<T> other) {
   }
 
   /**
+   * Get the set of flags in this {@link FlagSet}.
    * @return The set of flags in this {@link FlagSet}.
    */
   Set<T> getFlags();
 
   /**
+   * Tests if flag is non-null and included in this {@link FlagSet}.
+   * @param flag The flag to test.
    * @return True if flag is non-null and included in this {@link FlagSet}.
    */
   boolean isSet(T flag);
 
   /**
+   * The number of flags in this set.
    * @return The number of flags in this set.
    */
   int size();
 
   /**
-   * @return True if at least one of flags are included in thie {@link FlagSet}
+   * Tests if at least one of flags are included in this {@link FlagSet}
+   * @param flags The flags to test.
+   * @return True if at least one of flags are included in this {@link FlagSet}
    */
   default boolean areAnySet(final FlagSet<T> flags) {
     if (flags == null) {
@@ -78,11 +87,13 @@ default boolean areAnySet(final FlagSet<T> flags) {
   }
 
   /**
+   * Tests if this {@link FlagSet} is empty.
    * @return True if this {@link FlagSet} is empty.
    */
   boolean isEmpty();
 
   /**
+   * Gets an {@link Iterator} (in no particular order) for the flags in this {@link FlagSet}.
    * @return The {@link Iterator} (in no particular order) for the flags in this {@link FlagSet}.
    */
   @Override
@@ -90,7 +101,11 @@ default Iterator<T> iterator() {
     return getFlags().iterator();
   }
 
-  /** Convert this {@link FlagSet} to a string for use in toString methods. */
+  /** Convert this {@link FlagSet} to a string for use in toString methods.
+   * @param flagSet The {@link FlagSet} to convert to a string.
+   * @param <T> The type of the flags in the {@link FlagSet}.
+   * @return The {@link String} representation of the flagSet.
+   * */
   static <T extends MaskedFlag> String asString(final FlagSet<T> flagSet) {
     Objects.requireNonNull(flagSet);
     final String flagsStr =
@@ -101,6 +116,12 @@ static <T extends MaskedFlag> String asString(final FlagSet<T> flagSet) {
     return "FlagSet{" + "flags=[" + flagsStr + "], mask=" + flagSet.getMask() + '}';
   }
 
+  /**
+   * Compares a {@link FlagSet} to another object
+   * @param flagSet The {@link FlagSet} to compare.
+   * @param other THe object to compare against the {@link FlagSet}.
+   * @return True if both arguments implement {@link FlagSet} and contain the same flags.
+   */
   static boolean equals(final FlagSet<?> flagSet, final Object other) {
     if (other instanceof FlagSet) {
       final FlagSet<?> flagSet2 = (FlagSet<?>) other;
diff --git a/src/main/java/org/lmdbjava/MaskedFlag.java b/src/main/java/org/lmdbjava/MaskedFlag.java
index 400f2f30..a45fab97 100644
--- a/src/main/java/org/lmdbjava/MaskedFlag.java
+++ b/src/main/java/org/lmdbjava/MaskedFlag.java
@@ -22,6 +22,9 @@
 /** Indicates an enum that can provide integers for each of its values. */
 public interface MaskedFlag {
 
+  /**
+   * The mask value for an empty mask, i.e. no flags set.
+   */
   int EMPTY_MASK = 0;
 
   /**
@@ -32,6 +35,7 @@ public interface MaskedFlag {
   int getMask();
 
   /**
+   * The name of the flag.
    * @return The name of the flag.
    */
   String name();
@@ -59,8 +63,12 @@ static <M extends MaskedFlag> int mask(final M... flags) {
     }
   }
 
-  /** Combine the two masks into a single mask value, i.e. when combining two {@link FlagSet}s. */
-  static <M extends MaskedFlag> int mask(final int mask1, final int mask2) {
+  /** Combine the two masks into a single mask value, i.e. when combining two {@link FlagSet}s.
+   * @param mask1 The mask to combine with mask2.
+   * @param mask2 The mask to combine with mask1.
+   * @return The combined mask value for the two passed masks.
+   * */
+  static int mask(final int mask1, final int mask2) {
     return mask1 | mask2;
   }
 
diff --git a/src/main/java/org/lmdbjava/PutFlagSet.java b/src/main/java/org/lmdbjava/PutFlagSet.java
index 8c587138..2f71c604 100644
--- a/src/main/java/org/lmdbjava/PutFlagSet.java
+++ b/src/main/java/org/lmdbjava/PutFlagSet.java
@@ -16,44 +16,58 @@
 package org.lmdbjava;
 
 import java.util.Collection;
-import java.util.EnumSet;
 import java.util.Objects;
 
+ /** An immutable set of flags for use when performing a "put". */
 public interface PutFlagSet extends FlagSet<PutFlags> {
 
+   /**
+    * An immutable empty {@link PutFlagSet}.
+    */
   PutFlagSet EMPTY = PutFlagSetImpl.EMPTY;
 
+   /**
+    * Gets the immutable empty {@link PutFlagSet} instance.
+    * @return The immutable empty {@link PutFlagSet} instance.
+    */
   static PutFlagSet empty() {
     return PutFlagSetImpl.EMPTY;
   }
 
+   /**
+    * Creates an immutable {@link PutFlagSet} containing putFlag.
+    * @param putFlag The flag to include in the {@link PutFlagSet}
+    * @return An immutable {@link PutFlagSet} containing just putFlag.
+    */
   static PutFlagSet of(final PutFlags putFlag) {
     Objects.requireNonNull(putFlag);
     return putFlag;
   }
 
+   /**
+    * Creates an immutable {@link PutFlagSet} containing putFlags.
+    * @param putFlags The flags to include in the {@link PutFlagSet}.
+    * @return An immutable {@link PutFlagSet} containing putFlags.
+    */
   static PutFlagSet of(final PutFlags... putFlags) {
     return builder().setFlags(putFlags).build();
   }
 
+   /**
+    * Creates an immutable {@link PutFlagSet} containing putFlags.
+    * @param putFlags The flags to include in the {@link PutFlagSet}.
+    * @return An immutable {@link PutFlagSet} containing putFlags.
+    */
   static PutFlagSet of(final Collection<PutFlags> putFlags) {
     return builder().setFlags(putFlags).build();
   }
 
+   /**
+    * Create a builder for building an {@link PutFlagSet}.
+    * @return A builder instance for building an {@link PutFlagSet}.
+    */
   static AbstractFlagSet.Builder<PutFlags, PutFlagSet> builder() {
     return new AbstractFlagSet.Builder<>(
-        PutFlags.class, PutFlagSetImpl::new, putFlag -> putFlag, EmptyPutFlagSet::new);
+        PutFlags.class, PutFlagSetImpl::new, putFlag -> putFlag, PutFlagSetEmpty::new);
   }
-
-  class PutFlagSetImpl extends AbstractFlagSet<PutFlags> implements PutFlagSet {
-
-    public static final PutFlagSet EMPTY = new EmptyPutFlagSet();
-
-    private PutFlagSetImpl(final EnumSet<PutFlags> flags) {
-      super(flags);
-    }
-  }
-
-  class EmptyPutFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<PutFlags>
-      implements PutFlagSet {}
-}
+ }
diff --git a/src/main/java/org/lmdbjava/PutFlagSetEmpty.java b/src/main/java/org/lmdbjava/PutFlagSetEmpty.java
new file mode 100644
index 00000000..8119edbe
--- /dev/null
+++ b/src/main/java/org/lmdbjava/PutFlagSetEmpty.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+class PutFlagSetEmpty extends AbstractFlagSet.AbstractEmptyFlagSet<PutFlags>
+    implements PutFlagSet {
+}
diff --git a/src/main/java/org/lmdbjava/PutFlagSetImpl.java b/src/main/java/org/lmdbjava/PutFlagSetImpl.java
new file mode 100644
index 00000000..afa495ef
--- /dev/null
+++ b/src/main/java/org/lmdbjava/PutFlagSetImpl.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import java.util.EnumSet;
+
+class PutFlagSetImpl extends AbstractFlagSet<PutFlags> implements PutFlagSet {
+
+  public static final PutFlagSet EMPTY = new PutFlagSetEmpty();
+
+  PutFlagSetImpl(final EnumSet<PutFlags> flags) {
+    super(flags);
+  }
+}
diff --git a/src/main/java/org/lmdbjava/TxnFlagSet.java b/src/main/java/org/lmdbjava/TxnFlagSet.java
index 4bfdf2e3..7436f5d4 100644
--- a/src/main/java/org/lmdbjava/TxnFlagSet.java
+++ b/src/main/java/org/lmdbjava/TxnFlagSet.java
@@ -16,52 +16,58 @@
 package org.lmdbjava;
 
 import java.util.Collection;
-import java.util.EnumSet;
 import java.util.Objects;
 
+/** An immutable set of flags for use when creating a {@link Txn}. */
 public interface TxnFlagSet extends FlagSet<TxnFlags> {
 
+  /**
+   * An immutable empty {@link TxnFlagSet}.
+   */
   TxnFlagSet EMPTY = TxnFlagSetImpl.EMPTY;
 
+  /**
+   * Gets the immutable empty {@link TxnFlagSet} instance.
+   * @return The immutable empty {@link TxnFlagSet} instance.
+   */
   static TxnFlagSet empty() {
     return TxnFlagSetImpl.EMPTY;
   }
 
-  static TxnFlagSet of(final TxnFlags putflag) {
-    Objects.requireNonNull(putflag);
-    return new SingleTxnFlagSet(putflag);
+  /**
+   * Creates an immutable {@link TxnFlagSet} containing txnFlag.
+   * @param txnFlag The flag to include in the {@link TxnFlagSet}
+   * @return An immutable {@link TxnFlagSet} containing just txnFlag.
+   */
+  static TxnFlagSet of(final TxnFlags txnFlag) {
+    Objects.requireNonNull(txnFlag);
+    return txnFlag;
   }
 
-  static TxnFlagSet of(final TxnFlags... TxnFlags) {
-    return builder().setFlags(TxnFlags).build();
+  /**
+   * Creates an immutable {@link TxnFlagSet} containing txnFlags.
+   * @param txnFlags The flags to include in the {@link TxnFlagSet}.
+   * @return An immutable {@link TxnFlagSet} containing txnFlags.
+   */
+  static TxnFlagSet of(final TxnFlags... txnFlags) {
+    return builder().setFlags(txnFlags).build();
   }
 
+  /**
+   * Creates an immutable {@link TxnFlagSet} containing txnFlags.
+   * @param txnFlags The flags to include in the {@link TxnFlagSet}.
+   * @return An immutable {@link TxnFlagSet} containing txnFlags.
+   */
   static TxnFlagSet of(final Collection<TxnFlags> txnFlags) {
     return builder().setFlags(txnFlags).build();
   }
 
+  /**
+   * Create a builder for building an {@link TxnFlagSet}.
+   * @return A builder instance for building an {@link TxnFlagSet}.
+   */
   static AbstractFlagSet.Builder<TxnFlags, TxnFlagSet> builder() {
     return new AbstractFlagSet.Builder<>(
-        TxnFlags.class, TxnFlagSetImpl::new, SingleTxnFlagSet::new, () -> TxnFlagSetImpl.EMPTY);
-  }
-
-  class TxnFlagSetImpl extends AbstractFlagSet<TxnFlags> implements TxnFlagSet {
-
-    static final TxnFlagSet EMPTY = new EmptyTxnFlagSet();
-
-    private TxnFlagSetImpl(final EnumSet<TxnFlags> flags) {
-      super(flags);
-    }
+        TxnFlags.class, TxnFlagSetImpl::new, txnFlag -> txnFlag, () -> TxnFlagSetImpl.EMPTY);
   }
-
-  class SingleTxnFlagSet extends AbstractFlagSet.AbstractSingleFlagSet<TxnFlags>
-      implements TxnFlagSet {
-
-    SingleTxnFlagSet(final TxnFlags flag) {
-      super(flag);
-    }
-  }
-
-  class EmptyTxnFlagSet extends AbstractFlagSet.AbstractEmptyFlagSet<TxnFlags>
-      implements TxnFlagSet {}
 }
diff --git a/src/main/java/org/lmdbjava/TxnFlagSetEmpty.java b/src/main/java/org/lmdbjava/TxnFlagSetEmpty.java
new file mode 100644
index 00000000..2b7f152d
--- /dev/null
+++ b/src/main/java/org/lmdbjava/TxnFlagSetEmpty.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+class TxnFlagSetEmpty extends AbstractFlagSet.AbstractEmptyFlagSet<TxnFlags>
+    implements TxnFlagSet {
+}
diff --git a/src/main/java/org/lmdbjava/TxnFlagSetImpl.java b/src/main/java/org/lmdbjava/TxnFlagSetImpl.java
new file mode 100644
index 00000000..c81f3be0
--- /dev/null
+++ b/src/main/java/org/lmdbjava/TxnFlagSetImpl.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import java.util.EnumSet;
+
+class TxnFlagSetImpl extends AbstractFlagSet<TxnFlags> implements TxnFlagSet {
+
+  static final TxnFlagSet EMPTY = new TxnFlagSetEmpty();
+
+  TxnFlagSetImpl(final EnumSet<TxnFlags> flags) {
+    super(flags);
+  }
+}
diff --git a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
index dbe32e14..dcebc722 100644
--- a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
@@ -140,6 +140,27 @@ void testAsFlag() {
     }
   }
 
+  @Test
+  void testAddCollection() {
+    final F flagSet = getBuilder()
+        .addFlags(getAllFlags())
+        .build();
+
+    assertThat(flagSet.getFlags())
+        .containsExactlyElementsOf(getAllFlags());
+  }
+
+  @Test
+  void testClearBuilder() {
+    final F flagSet = getBuilder()
+        .addFlag(getFirst())
+        .clear()
+        .build();
+
+    assertThat(flagSet.isEmpty())
+        .isTrue();
+  }
+
   private T[] toArray(final int cnt) {
     //noinspection unchecked
     return (T[]) Array.newInstance(getFlagType(), cnt);
diff --git a/src/test/java/org/lmdbjava/ByteUnitTest.java b/src/test/java/org/lmdbjava/ByteUnitTest.java
index 5724429d..d6608684 100644
--- a/src/test/java/org/lmdbjava/ByteUnitTest.java
+++ b/src/test/java/org/lmdbjava/ByteUnitTest.java
@@ -27,37 +27,48 @@ void test() {
     // BYTES
     Assertions.assertThat(ByteUnit.BYTES.toBytes(2)).isEqualTo(2L);
     Assertions.assertThat(ByteUnit.BYTES.toBytes(0)).isEqualTo(0L);
+    Assertions.assertThat(ByteUnit.BYTES.getFactor()).isEqualTo(1L);
 
     // IEC Units
     Assertions.assertThat(ByteUnit.KIBIBYTES.toBytes(1)).isEqualTo(1024L);
     Assertions.assertThat(ByteUnit.KIBIBYTES.toBytes(2)).isEqualTo(2048L);
+    Assertions.assertThat(ByteUnit.KIBIBYTES.getFactor()).isEqualTo(1024L);
 
     Assertions.assertThat(ByteUnit.MEBIBYTES.toBytes(1)).isEqualTo(1048576L);
     Assertions.assertThat(ByteUnit.MEBIBYTES.toBytes(2)).isEqualTo(2097152L);
+    Assertions.assertThat(ByteUnit.MEBIBYTES.getFactor()).isEqualTo(1048576L);
 
     Assertions.assertThat(ByteUnit.GIBIBYTES.toBytes(1)).isEqualTo(1073741824L);
     Assertions.assertThat(ByteUnit.GIBIBYTES.toBytes(2)).isEqualTo(2147483648L);
+    Assertions.assertThat(ByteUnit.GIBIBYTES.getFactor()).isEqualTo(1073741824L);
 
     Assertions.assertThat(ByteUnit.TEBIBYTES.toBytes(1)).isEqualTo(1099511627776L);
     Assertions.assertThat(ByteUnit.TEBIBYTES.toBytes(2)).isEqualTo(2199023255552L);
+    Assertions.assertThat(ByteUnit.TEBIBYTES.getFactor()).isEqualTo(1099511627776L);
 
     Assertions.assertThat(ByteUnit.PEBIBYTES.toBytes(1)).isEqualTo(1125899906842624L);
     Assertions.assertThat(ByteUnit.PEBIBYTES.toBytes(2)).isEqualTo(2251799813685248L);
+    Assertions.assertThat(ByteUnit.PEBIBYTES.getFactor()).isEqualTo(1125899906842624L);
 
     // SI Units
     Assertions.assertThat(ByteUnit.KILOBYTES.toBytes(1)).isEqualTo(1000L);
     Assertions.assertThat(ByteUnit.KILOBYTES.toBytes(2)).isEqualTo(2000L);
+    Assertions.assertThat(ByteUnit.KILOBYTES.getFactor()).isEqualTo(1000L);
 
     Assertions.assertThat(ByteUnit.MEGABYTES.toBytes(1)).isEqualTo(1000000L);
     Assertions.assertThat(ByteUnit.MEGABYTES.toBytes(2)).isEqualTo(2000000L);
+    Assertions.assertThat(ByteUnit.MEGABYTES.getFactor()).isEqualTo(1000000L);
 
     Assertions.assertThat(ByteUnit.GIGABYTES.toBytes(1)).isEqualTo(1000000000L);
     Assertions.assertThat(ByteUnit.GIGABYTES.toBytes(2)).isEqualTo(2000000000L);
+    Assertions.assertThat(ByteUnit.GIGABYTES.getFactor()).isEqualTo(1000000000L);
 
     Assertions.assertThat(ByteUnit.TERABYTES.toBytes(1)).isEqualTo(1000000000000L);
     Assertions.assertThat(ByteUnit.TERABYTES.toBytes(2)).isEqualTo(2000000000000L);
+    Assertions.assertThat(ByteUnit.TERABYTES.getFactor()).isEqualTo(1000000000000L);
 
     Assertions.assertThat(ByteUnit.PETABYTES.toBytes(1)).isEqualTo(1000000000000000L);
     Assertions.assertThat(ByteUnit.PETABYTES.toBytes(2)).isEqualTo(2000000000000000L);
+    Assertions.assertThat(ByteUnit.PETABYTES.getFactor()).isEqualTo(1000000000000000L);
   }
 }
diff --git a/src/test/java/org/lmdbjava/CopyFlagSetTest.java b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
index 898da499..559bd8ea 100644
--- a/src/test/java/org/lmdbjava/CopyFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
@@ -20,7 +20,7 @@
 import java.util.List;
 import java.util.stream.Collectors;
 
-public class CopyFlagSetTest extends AbstractFlagSetTest<CopyFlags, CopyFlagSet> {
+class CopyFlagSetTest extends AbstractFlagSetTest<CopyFlags, CopyFlagSet> {
 
   @Override
   List<CopyFlags> getAllFlags() {
diff --git a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
index bb1665c6..66d83cc5 100644
--- a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
@@ -34,7 +34,7 @@
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
-public class CursorIterablePerfTest {
+class CursorIterablePerfTest {
 
   private static final int ITERATIONS = 100_000;
 
diff --git a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
index fbda0314..54b57794 100644
--- a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
@@ -148,7 +148,7 @@ void testLongKey(
 
   private void testCSV(
       final Function<
-              DbiBuilder.DbiBuilderStage2<ByteBuffer>, DbiBuilder.DbiBuilderStage3<ByteBuffer>>
+          DbiBuilder.Stage2<ByteBuffer>, DbiBuilder.Stage3<ByteBuffer>>
           comparatorFunc,
       final BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> dbPopulator,
       final DbiFlagSet dbiFlags,
@@ -170,7 +170,7 @@ private void testCSV(
 
   private void testCSV(
       final Function<
-              DbiBuilder.DbiBuilderStage2<ByteBuffer>, DbiBuilder.DbiBuilderStage3<ByteBuffer>>
+          DbiBuilder.Stage2<ByteBuffer>, DbiBuilder.Stage3<ByteBuffer>>
           comparatorFunc,
       final BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> dbPopulator,
       final DbiFlagSet dbiFlags,
@@ -191,9 +191,9 @@ private void testCSV(
               .setEnvFlags(MDB_NOSUBDIR)
               .open(file)) {
 
-        final DbiBuilder.DbiBuilderStage2<ByteBuffer> builderStage2 =
+        final DbiBuilder.Stage2<ByteBuffer> builderStage2 =
             env.createDbi().setDbName(DB_1);
-        final DbiBuilder.DbiBuilderStage3<ByteBuffer> builderStage3 =
+        final DbiBuilder.Stage3<ByteBuffer> builderStage3 =
             comparatorFunc.apply(builderStage2);
         final Dbi<ByteBuffer> dbi = builderStage3.setDbiFlags(dbiFlags).open();
 
diff --git a/src/test/java/org/lmdbjava/DbiBuilderTest.java b/src/test/java/org/lmdbjava/DbiBuilderTest.java
index b7d6480f..c06c3dc9 100644
--- a/src/test/java/org/lmdbjava/DbiBuilderTest.java
+++ b/src/test/java/org/lmdbjava/DbiBuilderTest.java
@@ -24,6 +24,7 @@
 import java.nio.ByteBuffer;
 import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.Comparator;
 import java.util.Iterator;
 import java.util.List;
@@ -31,7 +32,7 @@
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
-public class DbiBuilderTest {
+class DbiBuilderTest {
 
   private TempDir tempDir;
   private Env<ByteBuffer> env;
@@ -169,6 +170,8 @@ public void flags() {
             .withDefaultComparator()
             .setDbiFlags(DbiFlags.MDB_DUPSORT, DbiFlags.MDB_DUPFIXED) // Will get overwritten
             .setDbiFlags() // clear them
+            .setDbiFlags(Collections.singletonList(DbiFlags.MDB_INTEGERDUP))
+            .setDbiFlags() // clear them
             .addDbiFlags(DbiFlags.MDB_CREATE) // Not a dbi flag as far as lmdb is concerned.
             .addDbiFlags(DbiFlags.MDB_INTEGERKEY)
             .addDbiFlags(DbiFlags.MDB_REVERSEKEY)
diff --git a/src/test/java/org/lmdbjava/DbiFlagSetTest.java b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
index 1c44f0c0..be97aea6 100644
--- a/src/test/java/org/lmdbjava/DbiFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
@@ -20,7 +20,7 @@
 import java.util.List;
 import java.util.stream.Collectors;
 
-public class DbiFlagSetTest extends AbstractFlagSetTest<DbiFlags, DbiFlagSet> {
+class DbiFlagSetTest extends AbstractFlagSetTest<DbiFlags, DbiFlagSet> {
 
   @Override
   List<DbiFlags> getAllFlags() {
diff --git a/src/test/java/org/lmdbjava/EnvFlagSetTest.java b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
index bd181ce8..35fcc001 100644
--- a/src/test/java/org/lmdbjava/EnvFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
@@ -20,7 +20,7 @@
 import java.util.List;
 import java.util.stream.Collectors;
 
-public class EnvFlagSetTest extends AbstractFlagSetTest<EnvFlags, EnvFlagSet> {
+class EnvFlagSetTest extends AbstractFlagSetTest<EnvFlags, EnvFlagSet> {
 
   @Override
   List<EnvFlags> getAllFlags() {
diff --git a/src/test/java/org/lmdbjava/GarbageCollectionTest.java b/src/test/java/org/lmdbjava/GarbageCollectionTest.java
index 26a99e98..e6c8ca88 100644
--- a/src/test/java/org/lmdbjava/GarbageCollectionTest.java
+++ b/src/test/java/org/lmdbjava/GarbageCollectionTest.java
@@ -27,7 +27,7 @@
 import org.mockito.MockedStatic;
 import org.mockito.Mockito;
 
-public class GarbageCollectionTest {
+class GarbageCollectionTest {
 
   private static final String DB_NAME = "my DB";
   private static final String KEY_PREFIX = "Uncorruptedkey";
diff --git a/src/test/java/org/lmdbjava/PutFlagSetTest.java b/src/test/java/org/lmdbjava/PutFlagSetTest.java
index bc1a24e0..9b6f3a09 100644
--- a/src/test/java/org/lmdbjava/PutFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/PutFlagSetTest.java
@@ -24,7 +24,7 @@
 import java.util.stream.IntStream;
 import org.junit.jupiter.api.Test;
 
-public class PutFlagSetTest extends AbstractFlagSetTest<PutFlags, PutFlagSet> {
+class PutFlagSetTest extends AbstractFlagSetTest<PutFlags, PutFlagSet> {
 
   @Override
   List<PutFlags> getAllFlags() {
diff --git a/src/test/java/org/lmdbjava/TempDir.java b/src/test/java/org/lmdbjava/TempDir.java
index 7d2977b9..d8acb2b9 100644
--- a/src/test/java/org/lmdbjava/TempDir.java
+++ b/src/test/java/org/lmdbjava/TempDir.java
@@ -21,7 +21,7 @@
 import java.nio.file.Path;
 import java.util.UUID;
 
-public class TempDir implements AutoCloseable {
+class TempDir implements AutoCloseable {
   private final Path root;
 
   public TempDir() {
diff --git a/src/test/java/org/lmdbjava/TxnFlagSetTest.java b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
index 4cf1e879..3ef93195 100644
--- a/src/test/java/org/lmdbjava/TxnFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
@@ -20,7 +20,7 @@
 import java.util.List;
 import java.util.stream.Collectors;
 
-public class TxnFlagSetTest extends AbstractFlagSetTest<TxnFlags, TxnFlagSet> {
+class TxnFlagSetTest extends AbstractFlagSetTest<TxnFlags, TxnFlagSet> {
 
   @Override
   List<TxnFlags> getAllFlags() {

From 72b5234561243a6f589d4355e7718e92f538bc86 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 7 Nov 2025 16:52:46 +0000
Subject: [PATCH 278/322] Auto-format

---
 .../java/org/lmdbjava/AbstractFlagSet.java    |  7 +-
 src/main/java/org/lmdbjava/ByteUnit.java      |  1 +
 src/main/java/org/lmdbjava/CopyFlagSet.java   |  9 ++-
 .../java/org/lmdbjava/CopyFlagSetEmpty.java   |  3 +-
 src/main/java/org/lmdbjava/Dbi.java           |  4 +-
 src/main/java/org/lmdbjava/DbiBuilder.java    | 64 +++++++++----------
 src/main/java/org/lmdbjava/DbiFlagSet.java    |  5 ++
 .../java/org/lmdbjava/DbiFlagSetEmpty.java    |  3 +-
 src/main/java/org/lmdbjava/Env.java           |  4 +-
 src/main/java/org/lmdbjava/EnvFlagSet.java    |  9 ++-
 .../java/org/lmdbjava/EnvFlagSetEmpty.java    |  3 +-
 src/main/java/org/lmdbjava/FlagSet.java       | 15 ++++-
 src/main/java/org/lmdbjava/MaskedFlag.java    | 11 ++--
 src/main/java/org/lmdbjava/PutFlagSet.java    | 59 +++++++++--------
 .../java/org/lmdbjava/PutFlagSetEmpty.java    |  3 +-
 src/main/java/org/lmdbjava/TxnFlagSet.java    |  9 ++-
 .../java/org/lmdbjava/TxnFlagSetEmpty.java    |  3 +-
 .../org/lmdbjava/AbstractFlagSetTest.java     | 15 ++---
 .../org/lmdbjava/CursorIterableRangeTest.java | 14 ++--
 19 files changed, 126 insertions(+), 115 deletions(-)

diff --git a/src/main/java/org/lmdbjava/AbstractFlagSet.java b/src/main/java/org/lmdbjava/AbstractFlagSet.java
index cff79ef1..99b073d9 100644
--- a/src/main/java/org/lmdbjava/AbstractFlagSet.java
+++ b/src/main/java/org/lmdbjava/AbstractFlagSet.java
@@ -24,9 +24,11 @@
 import java.util.function.Function;
 import java.util.function.Supplier;
 
-/** Encapsulates an immutable set of flags and the associated bit mask for the flags in the set.
+/**
+ * Encapsulates an immutable set of flags and the associated bit mask for the flags in the set.
+ *
  * @param <T> The type of the flags in this set. Must extend {@link MaskedFlag} and {@link Enum<T>}.
- * */
+ */
 abstract class AbstractFlagSet<T extends Enum<T> & MaskedFlag> implements FlagSet<T> {
 
   private final Set<T> flags;
@@ -268,6 +270,7 @@ public Builder<E, S> setFlags(final Collection<E> flags) {
 
     /**
      * Replaces any flags already set in the builder with the passed flags.
+     *
      * @param flags The flags to set in the builder.
      * @return this builder instance.
      */
diff --git a/src/main/java/org/lmdbjava/ByteUnit.java b/src/main/java/org/lmdbjava/ByteUnit.java
index c03eea9d..51dab217 100644
--- a/src/main/java/org/lmdbjava/ByteUnit.java
+++ b/src/main/java/org/lmdbjava/ByteUnit.java
@@ -62,6 +62,7 @@ public long toBytes(final long value) {
 
   /**
    * Gets factor to apply when converting this unit into bytes.
+   *
    * @return The factor to apply when converting this unit into bytes.
    */
   public long getFactor() {
diff --git a/src/main/java/org/lmdbjava/CopyFlagSet.java b/src/main/java/org/lmdbjava/CopyFlagSet.java
index 56c875c4..c8e35477 100644
--- a/src/main/java/org/lmdbjava/CopyFlagSet.java
+++ b/src/main/java/org/lmdbjava/CopyFlagSet.java
@@ -22,13 +22,12 @@
 /** An immutable set of flags for use when performing a {@link Env#copy(Path, CopyFlagSet)}. */
 public interface CopyFlagSet extends FlagSet<CopyFlags> {
 
-  /**
-   * An immutable empty {@link CopyFlagSet}.
-   */
+  /** An immutable empty {@link CopyFlagSet}. */
   CopyFlagSet EMPTY = CopyFlagSetImpl.EMPTY;
 
   /**
    * Gets the immutable empty {@link CopyFlagSet} instance.
+   *
    * @return The immutable empty {@link CopyFlagSet} instance.
    */
   static CopyFlagSet empty() {
@@ -37,6 +36,7 @@ static CopyFlagSet empty() {
 
   /**
    * Creates an immutable {@link CopyFlagSet} containing copyFlag.
+   *
    * @param copyFlag The flag to include in the {@link CopyFlagSet}
    * @return An immutable {@link CopyFlagSet} containing just copyFlag.
    */
@@ -47,6 +47,7 @@ static CopyFlagSet of(final CopyFlags copyFlag) {
 
   /**
    * Creates an immutable {@link CopyFlagSet} containing copyFlags.
+   *
    * @param copyFlags The flags to include in the {@link CopyFlagSet}.
    * @return An immutable {@link CopyFlagSet} containing copyFlags.
    */
@@ -56,6 +57,7 @@ static CopyFlagSet of(final CopyFlags... copyFlags) {
 
   /**
    * Creates an immutable {@link CopyFlagSet} containing copyFlags.
+   *
    * @param copyFlags The flags to include in the {@link CopyFlagSet}.
    * @return An immutable {@link CopyFlagSet} containing copyFlags.
    */
@@ -65,6 +67,7 @@ static CopyFlagSet of(final Collection<CopyFlags> copyFlags) {
 
   /**
    * Create a builder for building an {@link CopyFlagSet}.
+   *
    * @return A builder instance for building an {@link CopyFlagSet}.
    */
   static AbstractFlagSet.Builder<CopyFlags, CopyFlagSet> builder() {
diff --git a/src/main/java/org/lmdbjava/CopyFlagSetEmpty.java b/src/main/java/org/lmdbjava/CopyFlagSetEmpty.java
index 3227b9e9..f18af382 100644
--- a/src/main/java/org/lmdbjava/CopyFlagSetEmpty.java
+++ b/src/main/java/org/lmdbjava/CopyFlagSetEmpty.java
@@ -16,5 +16,4 @@
 package org.lmdbjava;
 
 class CopyFlagSetEmpty extends AbstractFlagSet.AbstractEmptyFlagSet<CopyFlags>
-    implements CopyFlagSet {
-}
+    implements CopyFlagSet {}
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index 3a387960..e5d66568 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -279,6 +279,7 @@ public byte[] getName() {
 
   /**
    * Obtains the name of this database, using the {@link Env#DEFAULT_NAME_CHARSET} {@link Charset}.
+   *
    * @return The name of this database, using the {@link Env#DEFAULT_NAME_CHARSET} {@link Charset}.
    */
   public String getNameAsString() {
@@ -288,7 +289,8 @@ public String getNameAsString() {
   /**
    * Obtains the name of this database, using the supplied {@link Charset}.
    *
-   * @param charset The {@link Charset} to use when converting the DB from a byte[] to a {@link String}.
+   * @param charset The {@link Charset} to use when converting the DB from a byte[] to a {@link
+   *     String}.
    * @return The name of the database. If this is the unnamed database an empty string will be
    *     returned.
    * @throws RuntimeException if the name can't be decoded.
diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
index df9853ff..fcb457ed 100644
--- a/src/main/java/org/lmdbjava/DbiBuilder.java
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -109,14 +109,12 @@ private Stage2(final DbiBuilder<T> dbiBuilder) {
      * functionally identical.
      *
      * <p>This option may be slightly more performant than when using {@link
-     * Stage2#withNativeComparator()} which calls down to LMDB for ALL comparison
-     * operations.
+     * Stage2#withNativeComparator()} which calls down to LMDB for ALL comparison operations.
      *
      * <p>If you do not intend to use {@link CursorIterable} then it doesn't matter whether you
-     * choose {@link Stage2#withNativeComparator()}, {@link
-     * Stage2#withDefaultComparator()} or {@link
-     * Stage2#withIteratorComparator(ComparatorFactory)} as these comparators will never
-     * be used.
+     * choose {@link Stage2#withNativeComparator()}, {@link Stage2#withDefaultComparator()} or
+     * {@link Stage2#withIteratorComparator(ComparatorFactory)} as these comparators will never be
+     * used.
      *
      * @return The next builder stage.
      */
@@ -131,15 +129,13 @@ public Stage3<T> withDefaultComparator() {
      * keys using the same comparator that is used for insertion order into the db.
      *
      * <p>This option may be slightly less performant than when using {@link
-     * Stage2#withDefaultComparator()} as it needs to call down to LMDB to perform the
-     * comparisons, however it guarantees that {@link CursorIterable} key comparison matches LMDB
-     * key comparison.
+     * Stage2#withDefaultComparator()} as it needs to call down to LMDB to perform the comparisons,
+     * however it guarantees that {@link CursorIterable} key comparison matches LMDB key comparison.
      *
      * <p>If you do not intend to use {@link CursorIterable} then it doesn't matter whether you
-     * choose {@link Stage2#withNativeComparator()}, {@link
-     * Stage2#withDefaultComparator()} or {@link
-     * Stage2#withIteratorComparator(ComparatorFactory)} as these comparators will never
-     * be used.
+     * choose {@link Stage2#withNativeComparator()}, {@link Stage2#withDefaultComparator()} or
+     * {@link Stage2#withIteratorComparator(ComparatorFactory)} as these comparators will never be
+     * used.
      *
      * @return The next builder stage.
      */
@@ -167,8 +163,7 @@ public Stage3<T> withNativeComparator() {
      *     the {@link Dbi}. It must not return null.
      * @return The next builder stage.
      */
-    public Stage3<T> withCallbackComparator(
-        final ComparatorFactory<T> comparatorFactory) {
+    public Stage3<T> withCallbackComparator(final ComparatorFactory<T> comparatorFactory) {
       this.comparatorFactory = Objects.requireNonNull(comparatorFactory);
       this.comparatorType = ComparatorType.CALLBACK;
       return new Stage3<>(this);
@@ -189,18 +184,16 @@ public Stage3<T> withCallbackComparator(
      * when using {@link CursorIterable}.
      *
      * <p>If you do not intend to use {@link CursorIterable} then it doesn't matter whether you
-     * choose {@link Stage2#withNativeComparator()}, {@link
-     * Stage2#withDefaultComparator()} or {@link
-     * Stage2#withIteratorComparator(ComparatorFactory)} as these comparators will never
-     * be used.
+     * choose {@link Stage2#withNativeComparator()}, {@link Stage2#withDefaultComparator()} or
+     * {@link Stage2#withIteratorComparator(ComparatorFactory)} as these comparators will never be
+     * used.
      *
      * @param comparatorFactory The comparator to use with {@link CursorIterable}. {@link
      *     ComparatorFactory#create(DbiFlagSet)} will be called once during the initialisation of
      *     the {@link Dbi}. It must not return null.
      * @return The next builder stage.
      */
-    public Stage3<T> withIteratorComparator(
-        final ComparatorFactory<T> comparatorFactory) {
+    public Stage3<T> withIteratorComparator(final ComparatorFactory<T> comparatorFactory) {
       this.comparatorFactory = Objects.requireNonNull(comparatorFactory);
       this.comparatorType = ComparatorType.ITERATOR;
       return new Stage3<>(this);
@@ -227,8 +220,8 @@ private Stage3(Stage2<T> stage2) {
      * Apply all the dbi flags supplied in dbiFlags.
      *
      * <p>Clears all flags currently set by previous calls to {@link
-     * Stage3#setDbiFlags(Collection)}, {@link Stage3#setDbiFlags(DbiFlags...)}
-     * or {@link Stage3#addDbiFlag(DbiFlags)}.
+     * Stage3#setDbiFlags(Collection)}, {@link Stage3#setDbiFlags(DbiFlags...)} or {@link
+     * Stage3#addDbiFlag(DbiFlags)}.
      *
      * @param dbiFlags to open the database with. A null {@link Collection} will just clear all set
      *     flags. Null items are ignored.
@@ -246,8 +239,8 @@ public Stage3<T> setDbiFlags(final Collection<DbiFlags> dbiFlags) {
      * Apply all the dbi flags supplied in dbiFlags.
      *
      * <p>Clears all flags currently set by previous calls to {@link
-     * Stage3#setDbiFlags(Collection)}, {@link Stage3#setDbiFlags(DbiFlags...)}
-     * or {@link Stage3#addDbiFlag(DbiFlags)}.
+     * Stage3#setDbiFlags(Collection)}, {@link Stage3#setDbiFlags(DbiFlags...)} or {@link
+     * Stage3#addDbiFlag(DbiFlags)}.
      *
      * @param dbiFlags to open the database with. A null array will just clear all set flags. Null
      *     items are ignored.
@@ -265,8 +258,8 @@ public Stage3<T> setDbiFlags(final DbiFlags... dbiFlags) {
      * Apply all the dbi flags supplied in dbiFlags.
      *
      * <p>Clears all flags currently set by previous calls to {@link
-     * Stage3#setDbiFlags(Collection)}, {@link Stage3#setDbiFlags(DbiFlags...)}
-     * or {@link Stage3#addDbiFlag(DbiFlags)}.
+     * Stage3#setDbiFlags(Collection)}, {@link Stage3#setDbiFlags(DbiFlags...)} or {@link
+     * Stage3#addDbiFlag(DbiFlags)}.
      *
      * @param dbiFlagSet to open the database with. A null value will just clear all set flags.
      * @return This builder instance.
@@ -281,8 +274,8 @@ public Stage3<T> setDbiFlags(final DbiFlagSet dbiFlagSet) {
 
     /**
      * Adds a dbiFlag to those flags already added to this builder by {@link
-     * Stage3#setDbiFlags(DbiFlags...)}, {@link Stage3#setDbiFlags(Collection)}
-     * or {@link Stage3#addDbiFlag(DbiFlags)}.
+     * Stage3#setDbiFlags(DbiFlags...)}, {@link Stage3#setDbiFlags(Collection)} or {@link
+     * Stage3#addDbiFlag(DbiFlags)}.
      *
      * @param dbiFlag to add to any existing flags. A null value is a no-op.
      * @return this builder instance.
@@ -294,8 +287,8 @@ public Stage3<T> addDbiFlag(final DbiFlags dbiFlag) {
 
     /**
      * Adds a dbiFlag to those flags already added to this builder by {@link
-     * Stage3#setDbiFlags(DbiFlags...)}, {@link Stage3#setDbiFlags(Collection)}
-     * or {@link Stage3#addDbiFlag(DbiFlags)}.
+     * Stage3#setDbiFlags(DbiFlags...)}, {@link Stage3#setDbiFlags(Collection)} or {@link
+     * Stage3#addDbiFlag(DbiFlags)}.
      *
      * @param dbiFlagSet to add to any existing flags. A null value is a no-op.
      * @return this builder instance.
@@ -310,8 +303,8 @@ public Stage3<T> addDbiFlags(final DbiFlagSet dbiFlagSet) {
     /**
      * Use the supplied transaction to open the {@link Dbi}.
      *
-     * <p>The caller MUST commit the transaction after calling {@link Stage3#open()}, in
-     * order to retain the <code>Dbi</code> in the <code>Env</code>.
+     * <p>The caller MUST commit the transaction after calling {@link Stage3#open()}, in order to
+     * retain the <code>Dbi</code> in the <code>Env</code>.
      *
      * <p>If you don't call this method to supply a {@link Txn}, a {@link Txn} will be opened for
      * the purpose of creating and opening the {@link Dbi}, then closed. Therefore, if you already
@@ -413,6 +406,7 @@ private enum ComparatorType {
 
   /**
    * A factory for creating a {@link Comparator} from a {@link DbiFlagSet}
+   *
    * @param <T> The type of buffer that will be compared by the created {@link Comparator}.
    */
   @FunctionalInterface
@@ -422,8 +416,8 @@ public interface ComparatorFactory<T> {
      * Creates a comparator for the supplied {@link DbiFlagSet}. This will only be called once
      * during the initialisation of the {@link Dbi}.
      *
-     * @param dbiFlagSet The flags set on the DB that the returned {@link Comparator} will be used by.
-     *                   The flags in the set may impact how the returned {@link Comparator} should behave.
+     * @param dbiFlagSet The flags set on the DB that the returned {@link Comparator} will be used
+     *     by. The flags in the set may impact how the returned {@link Comparator} should behave.
      * @return A {@link Comparator} applicable to the passed DB flags.
      */
     Comparator<T> create(final DbiFlagSet dbiFlagSet);
diff --git a/src/main/java/org/lmdbjava/DbiFlagSet.java b/src/main/java/org/lmdbjava/DbiFlagSet.java
index 2481f166..82043fe3 100644
--- a/src/main/java/org/lmdbjava/DbiFlagSet.java
+++ b/src/main/java/org/lmdbjava/DbiFlagSet.java
@@ -29,6 +29,7 @@ public interface DbiFlagSet extends FlagSet<DbiFlags> {
 
   /**
    * Gets the immutable empty {@link DbiFlagSet} instance.
+   *
    * @return The immutable empty {@link DbiFlagSet} instance.
    */
   static DbiFlagSet empty() {
@@ -37,6 +38,7 @@ static DbiFlagSet empty() {
 
   /**
    * Creates an immutable {@link DbiFlagSet} containing dbiFlag.
+   *
    * @param dbiFlag The flag to include in the {@link DbiFlagSet}
    * @return An immutable {@link DbiFlagSet} containing just dbiFlag.
    */
@@ -47,6 +49,7 @@ static DbiFlagSet of(final DbiFlags dbiFlag) {
 
   /**
    * Creates an immutable {@link DbiFlagSet} containing dbiFlags.
+   *
    * @param dbiFlags The flags to include in the {@link DbiFlagSet}.
    * @return An immutable {@link DbiFlagSet} containing dbiFlags.
    */
@@ -56,6 +59,7 @@ static DbiFlagSet of(final DbiFlags... dbiFlags) {
 
   /**
    * Creates an immutable {@link DbiFlagSet} containing dbiFlags.
+   *
    * @param dbiFlags The flags to include in the {@link DbiFlagSet}.
    * @return An immutable {@link DbiFlagSet} containing dbiFlags.
    */
@@ -65,6 +69,7 @@ static DbiFlagSet of(final Collection<DbiFlags> dbiFlags) {
 
   /**
    * Create a builder for building an {@link DbiFlagSet}.
+   *
    * @return A builder instance for building an {@link DbiFlagSet}.
    */
   static AbstractFlagSet.Builder<DbiFlags, DbiFlagSet> builder() {
diff --git a/src/main/java/org/lmdbjava/DbiFlagSetEmpty.java b/src/main/java/org/lmdbjava/DbiFlagSetEmpty.java
index 3b57642c..cff91caf 100644
--- a/src/main/java/org/lmdbjava/DbiFlagSetEmpty.java
+++ b/src/main/java/org/lmdbjava/DbiFlagSetEmpty.java
@@ -16,5 +16,4 @@
 package org.lmdbjava;
 
 class DbiFlagSetEmpty extends AbstractFlagSet.AbstractEmptyFlagSet<DbiFlags>
-    implements DbiFlagSet {
-}
+    implements DbiFlagSet {}
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index b368b4aa..d6fa7dc2 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -55,8 +55,8 @@ public final class Env<T> implements AutoCloseable {
   public static final String DISABLE_CHECKS_PROP = "lmdbjava.disable.checks";
 
   /**
-   * The default {@link Charset} used to convert DB names from a byte[] to a String or
-   * to encode a String as a byte[]. Only used if not explicit {@link Charset} is provided.
+   * The default {@link Charset} used to convert DB names from a byte[] to a String or to encode a
+   * String as a byte[]. Only used if not explicit {@link Charset} is provided.
    */
   public static final Charset DEFAULT_NAME_CHARSET = StandardCharsets.UTF_8;
 
diff --git a/src/main/java/org/lmdbjava/EnvFlagSet.java b/src/main/java/org/lmdbjava/EnvFlagSet.java
index 7e5f8cc3..70ed4e90 100644
--- a/src/main/java/org/lmdbjava/EnvFlagSet.java
+++ b/src/main/java/org/lmdbjava/EnvFlagSet.java
@@ -21,13 +21,12 @@
 /** An immutable set of flags for use when opening the {@link Env}. */
 public interface EnvFlagSet extends FlagSet<EnvFlags> {
 
-  /**
-   * An immutable empty {@link EnvFlagSet}.
-   */
+  /** An immutable empty {@link EnvFlagSet}. */
   EnvFlagSet EMPTY = EnvFlagSetImpl.EMPTY;
 
   /**
    * Gets the immutable empty {@link EnvFlagSet} instance.
+   *
    * @return The immutable empty {@link EnvFlagSet} instance.
    */
   static EnvFlagSet empty() {
@@ -36,6 +35,7 @@ static EnvFlagSet empty() {
 
   /**
    * Creates an immutable {@link EnvFlagSet} containing envFlag.
+   *
    * @param envFlag The flag to include in the {@link EnvFlagSet}
    * @return An immutable {@link EnvFlagSet} containing just envFlag.
    */
@@ -46,6 +46,7 @@ static EnvFlagSet of(final EnvFlags envFlag) {
 
   /**
    * Creates an immutable {@link EnvFlagSet} containing envFlags.
+   *
    * @param envFlags The flags to include in the {@link EnvFlagSet}.
    * @return An immutable {@link EnvFlagSet} containing envFlags.
    */
@@ -55,6 +56,7 @@ static EnvFlagSet of(final EnvFlags... envFlags) {
 
   /**
    * Creates an immutable {@link EnvFlagSet} containing envFlags.
+   *
    * @param envFlags The flags to include in the {@link EnvFlagSet}.
    * @return An immutable {@link EnvFlagSet} containing envFlags.
    */
@@ -64,6 +66,7 @@ static EnvFlagSet of(final Collection<EnvFlags> envFlags) {
 
   /**
    * Create a builder for building an {@link EnvFlagSet}.
+   *
    * @return A builder instance for building an {@link EnvFlagSet}.
    */
   static AbstractFlagSet.Builder<EnvFlags, EnvFlagSet> builder() {
diff --git a/src/main/java/org/lmdbjava/EnvFlagSetEmpty.java b/src/main/java/org/lmdbjava/EnvFlagSetEmpty.java
index 7cd55edf..552b1646 100644
--- a/src/main/java/org/lmdbjava/EnvFlagSetEmpty.java
+++ b/src/main/java/org/lmdbjava/EnvFlagSetEmpty.java
@@ -16,5 +16,4 @@
 package org.lmdbjava;
 
 class EnvFlagSetEmpty extends AbstractFlagSet.AbstractEmptyFlagSet<EnvFlags>
-    implements EnvFlagSet {
-}
+    implements EnvFlagSet {}
diff --git a/src/main/java/org/lmdbjava/FlagSet.java b/src/main/java/org/lmdbjava/FlagSet.java
index de63d9c6..bec120e4 100644
--- a/src/main/java/org/lmdbjava/FlagSet.java
+++ b/src/main/java/org/lmdbjava/FlagSet.java
@@ -31,12 +31,14 @@ public interface FlagSet<T extends MaskedFlag> extends Iterable<T> {
 
   /**
    * The combined mask for this flagSet.
+   *
    * @return The combined mask for this flagSet.
    */
   int getMask();
 
   /**
    * Combines this {@link FlagSet} with another and returns the combined mask value.
+   *
    * @param other The other {@link FlagSet} to combine with this.
    * @return The result of combining the mask of this {@link FlagSet} with the mask of the other
    *     {@link FlagSet}.
@@ -51,12 +53,14 @@ default int getMaskWith(final FlagSet<T> other) {
 
   /**
    * Get the set of flags in this {@link FlagSet}.
+   *
    * @return The set of flags in this {@link FlagSet}.
    */
   Set<T> getFlags();
 
   /**
    * Tests if flag is non-null and included in this {@link FlagSet}.
+   *
    * @param flag The flag to test.
    * @return True if flag is non-null and included in this {@link FlagSet}.
    */
@@ -64,12 +68,14 @@ default int getMaskWith(final FlagSet<T> other) {
 
   /**
    * The number of flags in this set.
+   *
    * @return The number of flags in this set.
    */
   int size();
 
   /**
    * Tests if at least one of flags are included in this {@link FlagSet}
+   *
    * @param flags The flags to test.
    * @return True if at least one of flags are included in this {@link FlagSet}
    */
@@ -88,12 +94,14 @@ default boolean areAnySet(final FlagSet<T> flags) {
 
   /**
    * Tests if this {@link FlagSet} is empty.
+   *
    * @return True if this {@link FlagSet} is empty.
    */
   boolean isEmpty();
 
   /**
    * Gets an {@link Iterator} (in no particular order) for the flags in this {@link FlagSet}.
+   *
    * @return The {@link Iterator} (in no particular order) for the flags in this {@link FlagSet}.
    */
   @Override
@@ -101,11 +109,13 @@ default Iterator<T> iterator() {
     return getFlags().iterator();
   }
 
-  /** Convert this {@link FlagSet} to a string for use in toString methods.
+  /**
+   * Convert this {@link FlagSet} to a string for use in toString methods.
+   *
    * @param flagSet The {@link FlagSet} to convert to a string.
    * @param <T> The type of the flags in the {@link FlagSet}.
    * @return The {@link String} representation of the flagSet.
-   * */
+   */
   static <T extends MaskedFlag> String asString(final FlagSet<T> flagSet) {
     Objects.requireNonNull(flagSet);
     final String flagsStr =
@@ -118,6 +128,7 @@ static <T extends MaskedFlag> String asString(final FlagSet<T> flagSet) {
 
   /**
    * Compares a {@link FlagSet} to another object
+   *
    * @param flagSet The {@link FlagSet} to compare.
    * @param other THe object to compare against the {@link FlagSet}.
    * @return True if both arguments implement {@link FlagSet} and contain the same flags.
diff --git a/src/main/java/org/lmdbjava/MaskedFlag.java b/src/main/java/org/lmdbjava/MaskedFlag.java
index a45fab97..67afebce 100644
--- a/src/main/java/org/lmdbjava/MaskedFlag.java
+++ b/src/main/java/org/lmdbjava/MaskedFlag.java
@@ -22,9 +22,7 @@
 /** Indicates an enum that can provide integers for each of its values. */
 public interface MaskedFlag {
 
-  /**
-   * The mask value for an empty mask, i.e. no flags set.
-   */
+  /** The mask value for an empty mask, i.e. no flags set. */
   int EMPTY_MASK = 0;
 
   /**
@@ -36,6 +34,7 @@ public interface MaskedFlag {
 
   /**
    * The name of the flag.
+   *
    * @return The name of the flag.
    */
   String name();
@@ -63,11 +62,13 @@ static <M extends MaskedFlag> int mask(final M... flags) {
     }
   }
 
-  /** Combine the two masks into a single mask value, i.e. when combining two {@link FlagSet}s.
+  /**
+   * Combine the two masks into a single mask value, i.e. when combining two {@link FlagSet}s.
+   *
    * @param mask1 The mask to combine with mask2.
    * @param mask2 The mask to combine with mask1.
    * @return The combined mask value for the two passed masks.
-   * */
+   */
   static int mask(final int mask1, final int mask2) {
     return mask1 | mask2;
   }
diff --git a/src/main/java/org/lmdbjava/PutFlagSet.java b/src/main/java/org/lmdbjava/PutFlagSet.java
index 2f71c604..a5605d1a 100644
--- a/src/main/java/org/lmdbjava/PutFlagSet.java
+++ b/src/main/java/org/lmdbjava/PutFlagSet.java
@@ -18,56 +18,59 @@
 import java.util.Collection;
 import java.util.Objects;
 
- /** An immutable set of flags for use when performing a "put". */
+/** An immutable set of flags for use when performing a "put". */
 public interface PutFlagSet extends FlagSet<PutFlags> {
 
-   /**
-    * An immutable empty {@link PutFlagSet}.
-    */
+  /** An immutable empty {@link PutFlagSet}. */
   PutFlagSet EMPTY = PutFlagSetImpl.EMPTY;
 
-   /**
-    * Gets the immutable empty {@link PutFlagSet} instance.
-    * @return The immutable empty {@link PutFlagSet} instance.
-    */
+  /**
+   * Gets the immutable empty {@link PutFlagSet} instance.
+   *
+   * @return The immutable empty {@link PutFlagSet} instance.
+   */
   static PutFlagSet empty() {
     return PutFlagSetImpl.EMPTY;
   }
 
-   /**
-    * Creates an immutable {@link PutFlagSet} containing putFlag.
-    * @param putFlag The flag to include in the {@link PutFlagSet}
-    * @return An immutable {@link PutFlagSet} containing just putFlag.
-    */
+  /**
+   * Creates an immutable {@link PutFlagSet} containing putFlag.
+   *
+   * @param putFlag The flag to include in the {@link PutFlagSet}
+   * @return An immutable {@link PutFlagSet} containing just putFlag.
+   */
   static PutFlagSet of(final PutFlags putFlag) {
     Objects.requireNonNull(putFlag);
     return putFlag;
   }
 
-   /**
-    * Creates an immutable {@link PutFlagSet} containing putFlags.
-    * @param putFlags The flags to include in the {@link PutFlagSet}.
-    * @return An immutable {@link PutFlagSet} containing putFlags.
-    */
+  /**
+   * Creates an immutable {@link PutFlagSet} containing putFlags.
+   *
+   * @param putFlags The flags to include in the {@link PutFlagSet}.
+   * @return An immutable {@link PutFlagSet} containing putFlags.
+   */
   static PutFlagSet of(final PutFlags... putFlags) {
     return builder().setFlags(putFlags).build();
   }
 
-   /**
-    * Creates an immutable {@link PutFlagSet} containing putFlags.
-    * @param putFlags The flags to include in the {@link PutFlagSet}.
-    * @return An immutable {@link PutFlagSet} containing putFlags.
-    */
+  /**
+   * Creates an immutable {@link PutFlagSet} containing putFlags.
+   *
+   * @param putFlags The flags to include in the {@link PutFlagSet}.
+   * @return An immutable {@link PutFlagSet} containing putFlags.
+   */
   static PutFlagSet of(final Collection<PutFlags> putFlags) {
     return builder().setFlags(putFlags).build();
   }
 
-   /**
-    * Create a builder for building an {@link PutFlagSet}.
-    * @return A builder instance for building an {@link PutFlagSet}.
-    */
+  /**
+   * Create a builder for building an {@link PutFlagSet}.
+   *
+   * @return A builder instance for building an {@link PutFlagSet}.
+   */
   static AbstractFlagSet.Builder<PutFlags, PutFlagSet> builder() {
     return new AbstractFlagSet.Builder<>(
         PutFlags.class, PutFlagSetImpl::new, putFlag -> putFlag, PutFlagSetEmpty::new);
   }
- }
+}
diff --git a/src/main/java/org/lmdbjava/PutFlagSetEmpty.java b/src/main/java/org/lmdbjava/PutFlagSetEmpty.java
index 8119edbe..a017711a 100644
--- a/src/main/java/org/lmdbjava/PutFlagSetEmpty.java
+++ b/src/main/java/org/lmdbjava/PutFlagSetEmpty.java
@@ -16,5 +16,4 @@
 package org.lmdbjava;
 
 class PutFlagSetEmpty extends AbstractFlagSet.AbstractEmptyFlagSet<PutFlags>
-    implements PutFlagSet {
-}
+    implements PutFlagSet {}
diff --git a/src/main/java/org/lmdbjava/TxnFlagSet.java b/src/main/java/org/lmdbjava/TxnFlagSet.java
index 7436f5d4..44beb4e3 100644
--- a/src/main/java/org/lmdbjava/TxnFlagSet.java
+++ b/src/main/java/org/lmdbjava/TxnFlagSet.java
@@ -21,13 +21,12 @@
 /** An immutable set of flags for use when creating a {@link Txn}. */
 public interface TxnFlagSet extends FlagSet<TxnFlags> {
 
-  /**
-   * An immutable empty {@link TxnFlagSet}.
-   */
+  /** An immutable empty {@link TxnFlagSet}. */
   TxnFlagSet EMPTY = TxnFlagSetImpl.EMPTY;
 
   /**
    * Gets the immutable empty {@link TxnFlagSet} instance.
+   *
    * @return The immutable empty {@link TxnFlagSet} instance.
    */
   static TxnFlagSet empty() {
@@ -36,6 +35,7 @@ static TxnFlagSet empty() {
 
   /**
    * Creates an immutable {@link TxnFlagSet} containing txnFlag.
+   *
    * @param txnFlag The flag to include in the {@link TxnFlagSet}
    * @return An immutable {@link TxnFlagSet} containing just txnFlag.
    */
@@ -46,6 +46,7 @@ static TxnFlagSet of(final TxnFlags txnFlag) {
 
   /**
    * Creates an immutable {@link TxnFlagSet} containing txnFlags.
+   *
    * @param txnFlags The flags to include in the {@link TxnFlagSet}.
    * @return An immutable {@link TxnFlagSet} containing txnFlags.
    */
@@ -55,6 +56,7 @@ static TxnFlagSet of(final TxnFlags... txnFlags) {
 
   /**
    * Creates an immutable {@link TxnFlagSet} containing txnFlags.
+   *
    * @param txnFlags The flags to include in the {@link TxnFlagSet}.
    * @return An immutable {@link TxnFlagSet} containing txnFlags.
    */
@@ -64,6 +66,7 @@ static TxnFlagSet of(final Collection<TxnFlags> txnFlags) {
 
   /**
    * Create a builder for building an {@link TxnFlagSet}.
+   *
    * @return A builder instance for building an {@link TxnFlagSet}.
    */
   static AbstractFlagSet.Builder<TxnFlags, TxnFlagSet> builder() {
diff --git a/src/main/java/org/lmdbjava/TxnFlagSetEmpty.java b/src/main/java/org/lmdbjava/TxnFlagSetEmpty.java
index 2b7f152d..2c229db9 100644
--- a/src/main/java/org/lmdbjava/TxnFlagSetEmpty.java
+++ b/src/main/java/org/lmdbjava/TxnFlagSetEmpty.java
@@ -16,5 +16,4 @@
 package org.lmdbjava;
 
 class TxnFlagSetEmpty extends AbstractFlagSet.AbstractEmptyFlagSet<TxnFlags>
-    implements TxnFlagSet {
-}
+    implements TxnFlagSet {}
diff --git a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
index dcebc722..5dfe5a0d 100644
--- a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
@@ -142,23 +142,16 @@ void testAsFlag() {
 
   @Test
   void testAddCollection() {
-    final F flagSet = getBuilder()
-        .addFlags(getAllFlags())
-        .build();
+    final F flagSet = getBuilder().addFlags(getAllFlags()).build();
 
-    assertThat(flagSet.getFlags())
-        .containsExactlyElementsOf(getAllFlags());
+    assertThat(flagSet.getFlags()).containsExactlyElementsOf(getAllFlags());
   }
 
   @Test
   void testClearBuilder() {
-    final F flagSet = getBuilder()
-        .addFlag(getFirst())
-        .clear()
-        .build();
+    final F flagSet = getBuilder().addFlag(getFirst()).clear().build();
 
-    assertThat(flagSet.isEmpty())
-        .isTrue();
+    assertThat(flagSet.isEmpty()).isTrue();
   }
 
   private T[] toArray(final int cnt) {
diff --git a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
index 54b57794..a1ac67b7 100644
--- a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
@@ -147,9 +147,7 @@ void testLongKey(
   }
 
   private void testCSV(
-      final Function<
-          DbiBuilder.Stage2<ByteBuffer>, DbiBuilder.Stage3<ByteBuffer>>
-          comparatorFunc,
+      final Function<DbiBuilder.Stage2<ByteBuffer>, DbiBuilder.Stage3<ByteBuffer>> comparatorFunc,
       final BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> dbPopulator,
       final DbiFlagSet dbiFlags,
       final String keyType,
@@ -169,9 +167,7 @@ private void testCSV(
   }
 
   private void testCSV(
-      final Function<
-          DbiBuilder.Stage2<ByteBuffer>, DbiBuilder.Stage3<ByteBuffer>>
-          comparatorFunc,
+      final Function<DbiBuilder.Stage2<ByteBuffer>, DbiBuilder.Stage3<ByteBuffer>> comparatorFunc,
       final BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> dbPopulator,
       final DbiFlagSet dbiFlags,
       final String keyType,
@@ -191,10 +187,8 @@ private void testCSV(
               .setEnvFlags(MDB_NOSUBDIR)
               .open(file)) {
 
-        final DbiBuilder.Stage2<ByteBuffer> builderStage2 =
-            env.createDbi().setDbName(DB_1);
-        final DbiBuilder.Stage3<ByteBuffer> builderStage3 =
-            comparatorFunc.apply(builderStage2);
+        final DbiBuilder.Stage2<ByteBuffer> builderStage2 = env.createDbi().setDbName(DB_1);
+        final DbiBuilder.Stage3<ByteBuffer> builderStage3 = comparatorFunc.apply(builderStage2);
         final Dbi<ByteBuffer> dbi = builderStage3.setDbiFlags(dbiFlags).open();
 
         dbPopulator.accept(env, dbi);

From dd95dea98a60cd8bcf60e3a74c41ee9e538be576 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 7 Nov 2025 17:01:58 +0000
Subject: [PATCH 279/322] Add error handling for parse(Int|Long)

---
 .../org/lmdbjava/CursorIterableRangeTest.java |  8 ++++----
 src/test/java/org/lmdbjava/TestUtils.java     | 20 +++++++++++++++++++
 2 files changed, 24 insertions(+), 4 deletions(-)

diff --git a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
index a1ac67b7..0bd62695 100644
--- a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
@@ -222,15 +222,15 @@ private ByteBuffer parseKey(final String key, final int keyLen, final ByteOrder
     if (key != null) {
       if (ByteOrder.nativeOrder().equals(byteOrder)) {
         if (keyLen == Integer.BYTES) {
-          return bbNativeInt(Integer.parseInt(key.trim()));
+          return bbNativeInt(TestUtils.parseInt(key));
         } else {
-          return bbNativeLong(Long.parseLong(key.trim()));
+          return bbNativeLong(TestUtils.parseLong(key));
         }
       } else {
         if (keyLen == Integer.BYTES) {
-          return bb(Integer.parseInt(key.trim()));
+          return bb(TestUtils.parseInt(key));
         } else {
-          return bb(Long.parseLong(key.trim()));
+          return bb(TestUtils.parseLong(key));
         }
       }
     }
diff --git a/src/test/java/org/lmdbjava/TestUtils.java b/src/test/java/org/lmdbjava/TestUtils.java
index abaf63bb..00b923fa 100644
--- a/src/test/java/org/lmdbjava/TestUtils.java
+++ b/src/test/java/org/lmdbjava/TestUtils.java
@@ -120,6 +120,26 @@ static byte[] getBytes(final ByteBuffer byteBuffer) {
     return bytes;
   }
 
+  static int parseInt(final String str) {
+    Objects.requireNonNull(str);
+    final String trimmed = str.trim();
+    try {
+      return Integer.parseInt(trimmed);
+    } catch (NumberFormatException e) {
+      throw new RuntimeException("Unable to parse '" + trimmed + "' as an int.");
+    }
+  }
+
+  static long parseLong(final String str) {
+    Objects.requireNonNull(str);
+    final String trimmed = str.trim();
+    try {
+      return Long.parseLong(trimmed);
+    } catch (NumberFormatException e) {
+      throw new RuntimeException("Unable to parse '" + trimmed + "' as a long.");
+    }
+  }
+
   static void invokePrivateConstructor(final Class<?> clazz) {
     try {
       final Constructor<?> c = clazz.getDeclaredConstructor();

From b53378ade4925608fcfc420e2b567d10f055fe13 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 7 Nov 2025 17:04:38 +0000
Subject: [PATCH 280/322] Remove unused code

---
 .../java/org/lmdbjava/AbstractFlagSet.java    | 85 -------------------
 1 file changed, 85 deletions(-)

diff --git a/src/main/java/org/lmdbjava/AbstractFlagSet.java b/src/main/java/org/lmdbjava/AbstractFlagSet.java
index 99b073d9..71a7416a 100644
--- a/src/main/java/org/lmdbjava/AbstractFlagSet.java
+++ b/src/main/java/org/lmdbjava/AbstractFlagSet.java
@@ -80,11 +80,6 @@ public Iterator<T> iterator() {
     return flags.iterator();
   }
 
-  @Override
-  public boolean equals(Object object) {
-    return FlagSet.equals(this, object);
-  }
-
   @Override
   public int hashCode() {
     return Objects.hash(flags, mask);
@@ -95,81 +90,6 @@ public String toString() {
     return FlagSet.asString(this);
   }
 
-  abstract static class AbstractSingleFlagSet<T extends Enum<T> & MaskedFlag>
-      implements FlagSet<T> {
-
-    private final T flag;
-    // Only holding this for iterator() and getFlags() so make it lazy.
-    private EnumSet<T> enumSet;
-
-    public AbstractSingleFlagSet(final T flag) {
-      this.flag = Objects.requireNonNull(flag);
-    }
-
-    @Override
-    public int getMask() {
-      return flag.getMask();
-    }
-
-    @Override
-    public Set<T> getFlags() {
-      if (enumSet == null) {
-        return initSet();
-      } else {
-        return this.enumSet;
-      }
-    }
-
-    @Override
-    public boolean isSet(final T flag) {
-      return this.flag == flag;
-    }
-
-    @Override
-    public boolean areAnySet(FlagSet<T> flags) {
-      if (flags == null) {
-        return false;
-      } else {
-        return flags.isSet(this.flag);
-      }
-    }
-
-    @Override
-    public int size() {
-      return 1;
-    }
-
-    @Override
-    public boolean isEmpty() {
-      return false;
-    }
-
-    @Override
-    public Iterator<T> iterator() {
-      if (enumSet == null) {
-        return initSet().iterator();
-      } else {
-        return this.enumSet.iterator();
-      }
-    }
-
-    @Override
-    public String toString() {
-      return FlagSet.asString(this);
-    }
-
-    @Override
-    public int hashCode() {
-      return Objects.hash(flag, getFlags());
-    }
-
-    private Set<T> initSet() {
-      final EnumSet<T> set = EnumSet.of(this.flag);
-      this.enumSet = set;
-      return set;
-    }
-  }
-
   static class AbstractEmptyFlagSet<T extends MaskedFlag> implements FlagSet<T> {
 
     @Override
@@ -212,11 +132,6 @@ public String toString() {
       return FlagSet.asString(this);
     }
 
-    @Override
-    public boolean equals(Object object) {
-      return FlagSet.equals(this, object);
-    }
-
     @Override
     public int hashCode() {
       return Objects.hash(getMask(), getFlags());

From deb1f1b41b4c02ab6e5847a39084a2d99dbace04 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 7 Nov 2025 17:12:53 +0000
Subject: [PATCH 281/322] Remove unused code

---
 src/main/java/org/lmdbjava/Key.java | 14 ++------------
 1 file changed, 2 insertions(+), 12 deletions(-)

diff --git a/src/main/java/org/lmdbjava/Key.java b/src/main/java/org/lmdbjava/Key.java
index ac25f65d..d4892b45 100644
--- a/src/main/java/org/lmdbjava/Key.java
+++ b/src/main/java/org/lmdbjava/Key.java
@@ -24,6 +24,7 @@
 
 /**
  * Represents off-heap memory holding a key only.
+ * Equivalent to {@link KeyVal} without the val part.
  *
  * @param <T> buffer type
  */
@@ -31,17 +32,15 @@ final class Key<T> implements AutoCloseable {
 
   private static final MemoryManager MEM_MGR = RUNTIME.getMemoryManager();
   private boolean closed;
-  private T k;
+  private final T k;
   private final BufferProxy<T> proxy;
   private final Pointer ptrKey;
-  private final long ptrKeyAddr;
 
   Key(final BufferProxy<T> proxy) {
     requireNonNull(proxy);
     this.proxy = proxy;
     this.k = proxy.allocate();
     ptrKey = MEM_MGR.allocateTemporary(MDB_VAL_STRUCT_SIZE, false);
-    ptrKeyAddr = ptrKey.address();
   }
 
   @Override
@@ -53,19 +52,10 @@ public void close() {
     proxy.deallocate(k);
   }
 
-  T key() {
-    return k;
-  }
-
   void keyIn(final T key) {
     proxy.in(key, ptrKey);
   }
 
-  T keyOut() {
-    k = proxy.out(k, ptrKey);
-    return k;
-  }
-
   Pointer pointer() {
     return ptrKey;
   }

From 2bfe07c49c9470e374979b28903cda3c78256527 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 7 Nov 2025 17:15:24 +0000
Subject: [PATCH 282/322] Remove unused hashCode methods

---
 src/main/java/org/lmdbjava/AbstractFlagSet.java | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/src/main/java/org/lmdbjava/AbstractFlagSet.java b/src/main/java/org/lmdbjava/AbstractFlagSet.java
index 71a7416a..2e917515 100644
--- a/src/main/java/org/lmdbjava/AbstractFlagSet.java
+++ b/src/main/java/org/lmdbjava/AbstractFlagSet.java
@@ -80,11 +80,6 @@ public Iterator<T> iterator() {
     return flags.iterator();
   }
 
-  @Override
-  public int hashCode() {
-    return Objects.hash(flags, mask);
-  }
-
   @Override
   public String toString() {
     return FlagSet.asString(this);
@@ -131,11 +126,6 @@ public Iterator<T> iterator() {
     public String toString() {
       return FlagSet.asString(this);
     }
-
-    @Override
-    public int hashCode() {
-      return Objects.hash(getMask(), getFlags());
-    }
   }
 
   /**

From c6aa1cee03f8e317b247bf54654fd2968f5ce537 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Sun, 9 Nov 2025 08:33:51 +1100
Subject: [PATCH 283/322] Update to Junit 5.14.1

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 4d60b903..06c78d63 100644
--- a/pom.xml
+++ b/pom.xml
@@ -37,7 +37,7 @@
     <jacoco-maven-plugin.version>0.8.14</jacoco-maven-plugin.version>
     <jnr-constants.version>0.10.4</jnr-constants.version>
     <jnr-ffi.version>2.2.18</jnr-ffi.version>
-    <junit.version>5.14.0</junit.version>
+    <junit.version>5.14.1</junit.version>
     <license-maven-plugin.version>4.6</license-maven-plugin.version>
     <lmdbjava-native.version>0.9.33-2</lmdbjava-native.version>
     <maven-clean-plugin.version>3.5.0</maven-clean-plugin.version>

From b0d6532ca31e25d5a413d5ea9d1c5054aab6be91 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Sun, 9 Nov 2025 08:34:06 +1100
Subject: [PATCH 284/322] Update to Maven Release Plugin 3.2.0

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 06c78d63..c5dc2075 100644
--- a/pom.xml
+++ b/pom.xml
@@ -49,7 +49,7 @@
     <maven-install-plugin.version>3.1.4</maven-install-plugin.version>
     <maven-jar-plugin.version>3.4.2</maven-jar-plugin.version>
     <maven-javadoc-plugin.version>3.12.0</maven-javadoc-plugin.version>
-    <maven-release-plugin.version>3.1.1</maven-release-plugin.version>
+    <maven-release-plugin.version>3.2.0</maven-release-plugin.version>
     <maven-resources-plugin.version>3.3.1</maven-resources-plugin.version>
     <maven-scm-provider-jgit.version>2.2.1</maven-scm-provider-jgit.version>
     <maven-site-plugin.version>3.21.0</maven-site-plugin.version>

From 0b8cc7aa5d1aa7308a7b3e8e288d85829f93df81 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Sun, 9 Nov 2025 08:39:36 +1100
Subject: [PATCH 285/322] [maven-release-plugin] prepare release lmdbjava-0.9.2

---
 pom.xml | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/pom.xml b/pom.xml
index c5dc2075..c586da52 100644
--- a/pom.xml
+++ b/pom.xml
@@ -20,7 +20,7 @@
   <modelVersion>4.0.0</modelVersion>
   <groupId>org.lmdbjava</groupId>
   <artifactId>lmdbjava</artifactId>
-  <version>0.9.2-SNAPSHOT</version>
+  <version>0.9.2</version>
   <packaging>jar</packaging>
   <name>LmdbJava</name>
   <description>Low latency Java API for the ultra-fast, embedded Symas Lightning Database (LMDB)</description>
@@ -224,19 +224,19 @@
             </goals>
             <configuration>
               <rules>
-                <dependencyConvergence/>
+                <dependencyConvergence />
                 <requireMavenVersion>
                   <version>[${maven.enforcer.mvn},)</version>
                 </requireMavenVersion>
                 <requireJavaVersion>
                   <version>[${maven.enforcer.java},)</version>
                 </requireJavaVersion>
-                <requireNoRepositories/>
-                <requirePluginVersions/>
+                <requireNoRepositories />
+                <requirePluginVersions />
                 <requireReleaseDeps>
                   <onlyWhenRelease>true</onlyWhenRelease>
                 </requireReleaseDeps>
-                <requireUpperBoundDeps/>
+                <requireUpperBoundDeps />
               </rules>
             </configuration>
           </execution>
@@ -422,7 +422,7 @@
     <connection>scm:git:git@github.com:lmdbjava/lmdbjava.git</connection>
     <developerConnection>scm:git:git@github.com:lmdbjava/lmdbjava.git</developerConnection>
     <url>git@github.com:lmdbjava/lmdbjava.git</url>
-    <tag>HEAD</tag>
+    <tag>lmdbjava-0.9.2</tag>
   </scm>
   <issueManagement>
     <system>GitHub Issues</system>

From 77919c32b74f0291da8cb5aed93ef4b2f1159955 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Sun, 9 Nov 2025 08:39:42 +1100
Subject: [PATCH 286/322] [maven-release-plugin] prepare for next development
 iteration

---
 pom.xml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pom.xml b/pom.xml
index c586da52..696ba9ff 100644
--- a/pom.xml
+++ b/pom.xml
@@ -20,7 +20,7 @@
   <modelVersion>4.0.0</modelVersion>
   <groupId>org.lmdbjava</groupId>
   <artifactId>lmdbjava</artifactId>
-  <version>0.9.2</version>
+  <version>1.0.0-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>LmdbJava</name>
   <description>Low latency Java API for the ultra-fast, embedded Symas Lightning Database (LMDB)</description>
@@ -422,7 +422,7 @@
     <connection>scm:git:git@github.com:lmdbjava/lmdbjava.git</connection>
     <developerConnection>scm:git:git@github.com:lmdbjava/lmdbjava.git</developerConnection>
     <url>git@github.com:lmdbjava/lmdbjava.git</url>
-    <tag>lmdbjava-0.9.2</tag>
+    <tag>HEAD</tag>
   </scm>
   <issueManagement>
     <system>GitHub Issues</system>

From a84ceaa5b735bcce0a1c3a58a15db5bc49d4da34 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Sun, 9 Nov 2025 19:20:06 +0000
Subject: [PATCH 287/322] Change CursorIterableRangeTest to do default+native
 modes

---
 src/main/java/org/lmdbjava/Key.java           |   3 +-
 .../org/lmdbjava/CursorIterableRangeTest.java | 121 ++++++++++++------
 src/test/java/org/lmdbjava/TestUtils.java     |   2 -
 src/test/java/org/lmdbjava/TutorialTest.java  | 121 ++++++++++++++++++
 4 files changed, 203 insertions(+), 44 deletions(-)

diff --git a/src/main/java/org/lmdbjava/Key.java b/src/main/java/org/lmdbjava/Key.java
index d4892b45..da8bbe6b 100644
--- a/src/main/java/org/lmdbjava/Key.java
+++ b/src/main/java/org/lmdbjava/Key.java
@@ -23,8 +23,7 @@
 import jnr.ffi.provider.MemoryManager;
 
 /**
- * Represents off-heap memory holding a key only.
- * Equivalent to {@link KeyVal} without the val part.
+ * Represents off-heap memory holding a key only. Equivalent to {@link KeyVal} without the val part.
  *
  * @param <T> buffer type
  */
diff --git a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
index 0bd62695..46305959 100644
--- a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
@@ -18,13 +18,8 @@
 
 import static java.nio.ByteBuffer.allocateDirect;
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.lmdbjava.DbiFlags.MDB_CREATE;
-import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
-import static org.lmdbjava.DbiFlags.MDB_INTEGERKEY;
 import static org.lmdbjava.Env.create;
-import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
 import static org.lmdbjava.TestUtils.DB_1;
-import static org.lmdbjava.TestUtils.POSIX_MODE;
 import static org.lmdbjava.TestUtils.bb;
 
 import java.io.File;
@@ -41,14 +36,19 @@
 import java.util.function.Function;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.CsvFileSource;
-import org.lmdbjava.ByteBufferProxy.AbstractByteBufferProxy;
 import org.lmdbjava.CursorIterable.KeyVal;
 
 /** Test {@link CursorIterable}. */
 public final class CursorIterableRangeTest {
 
-  private static final DbiFlagSet CREATE_AND_DUPSORT = DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT);
-  private static final DbiFlagSet CREATE_AND_INTEGERKEY = DbiFlagSet.of(MDB_CREATE, MDB_INTEGERKEY);
+  private static final DbiFlagSet FLAGSET_DUPSORT =
+      DbiFlagSet.of(DbiFlags.MDB_CREATE, DbiFlags.MDB_DUPSORT);
+  private static final DbiFlagSet FLAGSET_REVERSEKEY =
+      DbiFlagSet.of(DbiFlags.MDB_CREATE, DbiFlags.MDB_REVERSEKEY);
+  private static final DbiFlagSet FLAGSET_INTEGERKEY =
+      DbiFlagSet.of(DbiFlags.MDB_CREATE, DbiFlags.MDB_INTEGERKEY);
+  private static final DbiFlagSet FLAGSET_REVERSE_INTEGERKEY =
+      DbiFlagSet.of(DbiFlags.MDB_CREATE, DbiFlags.MDB_INTEGERKEY, DbiFlags.MDB_REVERSEKEY);
 
   @ParameterizedTest(name = "{index} => {0}: ({1}, {2})")
   @CsvFileSource(resources = "/CursorIterableRangeTest/testSignedComparator.csv")
@@ -57,7 +57,7 @@ void testSignedComparator(
     testCSV(
         builder -> builder.withCallbackComparator(ignored -> ByteBuffer::compareTo),
         createBasicDBPopulator(),
-        MDB_CREATE,
+        DbiFlags.MDB_CREATE,
         keyType,
         startKey,
         stopKey,
@@ -68,16 +68,21 @@ void testSignedComparator(
   @CsvFileSource(resources = "/CursorIterableRangeTest/testUnsignedComparator.csv")
   void testUnsignedComparator(
       final String keyType, final String startKey, final String stopKey, final String expectedKV) {
-    testCSV(
-        builder ->
-            builder.withIteratorComparator(
-                ignored -> AbstractByteBufferProxy::compareLexicographically),
-        createBasicDBPopulator(),
-        MDB_CREATE,
-        keyType,
-        startKey,
-        stopKey,
-        expectedKV);
+    testCSV(createBasicDBPopulator(), DbiFlags.MDB_CREATE, keyType, startKey, stopKey, expectedKV);
+  }
+
+  @ParameterizedTest(name = "{index} => {0}: ({1}, {2})")
+  @CsvFileSource(resources = "/CursorIterableRangeTest/testUnsignedComparator.csv")
+  void testUnsignedComparator_Iterator(
+      final String keyType, final String startKey, final String stopKey, final String expectedKV) {
+    testCSV(createBasicDBPopulator(), DbiFlags.MDB_CREATE, keyType, startKey, stopKey, expectedKV);
+  }
+
+  @ParameterizedTest(name = "{index} => {0}: ({1}, {2})")
+  @CsvFileSource(resources = "/CursorIterableRangeTest/testUnsignedComparator.csv")
+  void testUnsignedComparator_Callback(
+      final String keyType, final String startKey, final String stopKey, final String expectedKV) {
+    testCSV(createBasicDBPopulator(), DbiFlags.MDB_CREATE, keyType, startKey, stopKey, expectedKV);
   }
 
   @ParameterizedTest(name = "{index} => {0}: ({1}, {2})")
@@ -87,7 +92,7 @@ void testSignedComparatorDupsort(
     testCSV(
         builder -> builder.withCallbackComparator(ignored -> ByteBuffer::compareTo),
         createMultiDBPopulator(2),
-        CREATE_AND_DUPSORT,
+        FLAGSET_DUPSORT,
         keyType,
         startKey,
         stopKey,
@@ -98,16 +103,7 @@ void testSignedComparatorDupsort(
   @CsvFileSource(resources = "/CursorIterableRangeTest/testUnsignedComparatorDupsort.csv")
   void testUnsignedComparatorDupsort(
       final String keyType, final String startKey, final String stopKey, final String expectedKV) {
-    testCSV(
-        builder ->
-            builder.withIteratorComparator(
-                ignored -> AbstractByteBufferProxy::compareLexicographically),
-        createMultiDBPopulator(2),
-        CREATE_AND_DUPSORT,
-        keyType,
-        startKey,
-        stopKey,
-        expectedKV);
+    testCSV(createMultiDBPopulator(2), FLAGSET_DUPSORT, keyType, startKey, stopKey, expectedKV);
   }
 
   @ParameterizedTest(name = "{index} => {0}: ({1}, {2})")
@@ -115,11 +111,8 @@ void testUnsignedComparatorDupsort(
   void testIntegerKey(
       final String keyType, final String startKey, final String stopKey, final String expectedKV) {
     testCSV(
-        builder ->
-            builder.withIteratorComparator(
-                ignored -> AbstractByteBufferProxy::compareAsIntegerKeys),
         createIntegerDBPopulator(),
-        DbiFlagSet.of(MDB_CREATE, MDB_INTEGERKEY),
+        FLAGSET_INTEGERKEY,
         keyType,
         startKey,
         stopKey,
@@ -133,11 +126,8 @@ void testIntegerKey(
   void testLongKey(
       final String keyType, final String startKey, final String stopKey, final String expectedKV) {
     testCSV(
-        builder ->
-            builder.withIteratorComparator(
-                ignored -> AbstractByteBufferProxy::compareAsIntegerKeys),
         createLongDBPopulator(),
-        CREATE_AND_INTEGERKEY,
+        FLAGSET_INTEGERKEY,
         keyType,
         startKey,
         stopKey,
@@ -166,6 +156,58 @@ private void testCSV(
         ByteOrder.BIG_ENDIAN);
   }
 
+  private void testCSV(
+      final BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> dbPopulator,
+      final DbiFlagSet dbiFlags,
+      final String keyType,
+      final String startKey,
+      final String stopKey,
+      final String expectedKV) {
+    testCSV(
+        dbPopulator,
+        dbiFlags,
+        keyType,
+        startKey,
+        stopKey,
+        expectedKV,
+        Integer.BYTES,
+        ByteOrder.BIG_ENDIAN);
+  }
+
+  private void testCSV(
+      final BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> dbPopulator,
+      final DbiFlagSet dbiFlags,
+      final String keyType,
+      final String startKey,
+      final String stopKey,
+      final String expectedKV,
+      final int keyLen,
+      final ByteOrder byteOrder) {
+    // First test with our default iterator comparator
+    testCSV(
+        DbiBuilder.Stage2::withDefaultComparator,
+        dbPopulator,
+        dbiFlags,
+        keyType,
+        startKey,
+        stopKey,
+        expectedKV,
+        keyLen,
+        byteOrder);
+
+    // Now test with mdp_cmp doing all comparisons, should be the same
+    testCSV(
+        DbiBuilder.Stage2::withNativeComparator,
+        dbPopulator,
+        dbiFlags,
+        keyType,
+        startKey,
+        stopKey,
+        expectedKV,
+        keyLen,
+        byteOrder);
+  }
+
   private void testCSV(
       final Function<DbiBuilder.Stage2<ByteBuffer>, DbiBuilder.Stage3<ByteBuffer>> comparatorFunc,
       final BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> dbPopulator,
@@ -183,8 +225,7 @@ private void testCSV(
               .setMapSize(256, ByteUnit.KIBIBYTES)
               .setMaxReaders(1)
               .setMaxDbs(1)
-              .setFilePermissions(POSIX_MODE)
-              .setEnvFlags(MDB_NOSUBDIR)
+              .setEnvFlags(EnvFlags.MDB_NOSUBDIR)
               .open(file)) {
 
         final DbiBuilder.Stage2<ByteBuffer> builderStage2 = env.createDbi().setDbName(DB_1);
diff --git a/src/test/java/org/lmdbjava/TestUtils.java b/src/test/java/org/lmdbjava/TestUtils.java
index 00b923fa..1dd04d50 100644
--- a/src/test/java/org/lmdbjava/TestUtils.java
+++ b/src/test/java/org/lmdbjava/TestUtils.java
@@ -38,8 +38,6 @@ final class TestUtils {
   public static final String DB_3 = "test-db-3";
   public static final String DB_4 = "test-db-2";
 
-  public static final int POSIX_MODE = 0664;
-
   private TestUtils() {}
 
   static byte[] ba(final int value) {
diff --git a/src/test/java/org/lmdbjava/TutorialTest.java b/src/test/java/org/lmdbjava/TutorialTest.java
index ac16774f..096e990b 100644
--- a/src/test/java/org/lmdbjava/TutorialTest.java
+++ b/src/test/java/org/lmdbjava/TutorialTest.java
@@ -22,6 +22,8 @@
 import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
 import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
+import static org.lmdbjava.DbiFlags.MDB_INTEGERKEY;
+import static org.lmdbjava.DbiFlags.MDB_REVERSEKEY;
 import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
 import static org.lmdbjava.GetOp.MDB_SET;
 import static org.lmdbjava.SeekOp.MDB_FIRST;
@@ -29,7 +31,10 @@
 import static org.lmdbjava.SeekOp.MDB_PREV;
 
 import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
 import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import org.agrona.DirectBuffer;
@@ -470,6 +475,122 @@ void tutorial7() {
     env.close();
   }
 
+  /**
+   * In this tutorial we'll look at using keys that are longs. The same approach applies would apply
+   * to int keys.
+   */
+  @Test
+  void tutorial8() {
+    final Path dir = tempDir.createTempDir();
+    final Env<ByteBuffer> env = createSimpleEnv(dir);
+
+    // This time we're going to tell the Dbi that all the keys are integers.
+    // MDB_INTEGERKEY applies to both int and long keys.
+    // LMDB can make optimisations for better performance.
+    final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, DbiFlagSet.of(MDB_CREATE, MDB_INTEGERKEY));
+
+    // MDB_INTEGERKEY requires that the keys are written/read in native order
+    final ByteBuffer key = ByteBuffer.allocateDirect(Long.BYTES).order(ByteOrder.nativeOrder());
+    final ByteBuffer val = ByteBuffer.allocateDirect(100);
+
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+
+      // Store one key, but many values, and in non-natural order.
+      key.putLong(42L).flip();
+      val.put("val-42".getBytes(UTF_8)).flip();
+      db.put(txn, key, val);
+
+      key.clear();
+      val.clear();
+      key.putLong(1L).flip();
+      val.put("val-1".getBytes(UTF_8)).flip();
+      db.put(txn, key, val);
+
+      key.clear();
+      val.clear();
+      key.putLong(Long.MAX_VALUE).flip();
+      val.put(("val-" + Long.MAX_VALUE).getBytes(UTF_8)).flip();
+      db.put(txn, key, val);
+
+      key.clear();
+      val.clear();
+      key.putLong(1_000L).flip();
+      val.put("val-1".getBytes(UTF_8)).flip();
+      db.put(txn, key, val);
+
+      // Get all the keys
+      final List<Long> keys = new ArrayList<>();
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+        for (final KeyVal<ByteBuffer> kv : ci) {
+          assertThat(kv.key()).isNotNull();
+          assertThat(kv.val()).isNotNull();
+          keys.add(kv.key().order(ByteOrder.nativeOrder()).getLong());
+        }
+      }
+
+      assertThat(keys).containsExactly(1L, 42L, 1_000L, Long.MAX_VALUE);
+
+      txn.commit();
+    }
+    env.close();
+  }
+
+  /** In this tutorial we'll look storing the data in reverse order */
+  @Test
+  void tutorial9() {
+    final Path dir = tempDir.createTempDir();
+    final Env<ByteBuffer> env = createSimpleEnv(dir);
+
+    final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, DbiFlagSet.of(MDB_CREATE, MDB_REVERSEKEY));
+
+    final ByteBuffer key = ByteBuffer.allocateDirect(100);
+    final ByteBuffer val = ByteBuffer.allocateDirect(100);
+
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+
+      // Store one key, but many values, and in non-natural order.
+      key.put("tac".getBytes(UTF_8)).flip();
+      val.put("CAT".getBytes(UTF_8)).flip();
+      db.put(txn, key, val);
+
+      key.clear();
+      val.clear();
+      key.put("god".getBytes(UTF_8)).flip();
+      val.put("DOG".getBytes(UTF_8)).flip();
+      db.put(txn, key, val);
+
+      key.clear();
+      val.clear();
+      key.put("esroh".getBytes(UTF_8)).flip();
+      val.put("HORSE".getBytes(UTF_8)).flip();
+      db.put(txn, key, val);
+
+      key.clear();
+      val.clear();
+      key.put("tnahpele".getBytes(UTF_8)).flip();
+      val.put("ELEPHANT".getBytes(UTF_8)).flip();
+      db.put(txn, key, val);
+
+      // Get all the keys
+      final List<String> keys = new ArrayList<>();
+      final List<String> values = new ArrayList<>();
+      try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
+        for (final KeyVal<ByteBuffer> kv : ci) {
+          assertThat(kv.key()).isNotNull();
+          assertThat(kv.val()).isNotNull();
+          keys.add(UTF_8.decode(kv.key()).toString());
+          values.add(UTF_8.decode(kv.val()).toString());
+        }
+      }
+
+      assertThat(keys).containsExactly("tac", "god", "tnahpele", "esroh");
+      assertThat(values).containsExactly("CAT", "DOG", "ELEPHANT", "HORSE");
+
+      txn.commit();
+    }
+    env.close();
+  }
+
   // You've finished! There are lots of other neat things we could show you (eg
   // how to speed up inserts by appending them in key order, using integer
   // or reverse ordered keys, using Env.DISABLE_CHECKS_PROP etc), but you now

From a5e4cf276c96187feff917201d997cbceef1bb4b Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Sun, 9 Nov 2025 19:23:40 +0000
Subject: [PATCH 288/322] Remove separator comments

---
 src/main/java/org/lmdbjava/ByteBufferProxy.java | 6 ------
 src/main/java/org/lmdbjava/Env.java             | 2 --
 2 files changed, 8 deletions(-)

diff --git a/src/main/java/org/lmdbjava/ByteBufferProxy.java b/src/main/java/org/lmdbjava/ByteBufferProxy.java
index 52bfc924..25218fe4 100644
--- a/src/main/java/org/lmdbjava/ByteBufferProxy.java
+++ b/src/main/java/org/lmdbjava/ByteBufferProxy.java
@@ -86,8 +86,6 @@ public BufferMustBeDirectException() {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
   /**
    * Provides {@link ByteBuffer} pooling and address resolution for concrete {@link BufferProxy}
    * implementations.
@@ -246,8 +244,6 @@ protected byte[] getBytes(final ByteBuffer buffer) {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
   /**
    * A proxy that uses Java reflection to modify byte buffer fields, and official JNR-FFF methods to
    * manipulate native pointers.
@@ -292,8 +288,6 @@ protected ByteBuffer out(final ByteBuffer buffer, final Pointer ptr) {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
   /**
    * A proxy that uses Java's "unsafe" class to directly manipulate byte buffer fields and JNR-FFF
    * allocated memory pointers.
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index d6fa7dc2..d43ebd0f 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -688,8 +688,6 @@ public AlreadyOpenException() {
     }
   }
 
-  // --------------------------------------------------------------------------------
-
   /**
    * Builder for configuring and opening Env.
    *

From f8e6e076ee0d6b91a039d680426efb4861747ad7 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Sun, 9 Nov 2025 19:32:08 +0000
Subject: [PATCH 289/322] Add more tests to CursorIterableRangeTest

---
 .../org/lmdbjava/CursorIterableRangeTest.java | 66 +++++++++++++++++++
 1 file changed, 66 insertions(+)

diff --git a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
index 46305959..809b5065 100644
--- a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
@@ -47,6 +47,8 @@ public final class CursorIterableRangeTest {
       DbiFlagSet.of(DbiFlags.MDB_CREATE, DbiFlags.MDB_REVERSEKEY);
   private static final DbiFlagSet FLAGSET_INTEGERKEY =
       DbiFlagSet.of(DbiFlags.MDB_CREATE, DbiFlags.MDB_INTEGERKEY);
+  private static final DbiFlagSet FLAGSET_INTEGERKEY_DUPSORT =
+      DbiFlagSet.of(DbiFlags.MDB_CREATE, DbiFlags.MDB_INTEGERKEY, DbiFlags.MDB_DUPSORT);
   private static final DbiFlagSet FLAGSET_REVERSE_INTEGERKEY =
       DbiFlagSet.of(DbiFlags.MDB_CREATE, DbiFlags.MDB_INTEGERKEY, DbiFlags.MDB_REVERSEKEY);
 
@@ -121,6 +123,21 @@ void testIntegerKey(
         ByteOrder.nativeOrder());
   }
 
+  @ParameterizedTest(name = "{index} => {0}: ({1}, {2})")
+  @CsvFileSource(resources = "/CursorIterableRangeTest/testUnsignedComparatorDupsort.csv")
+  void testIntegerKeyDupSort(
+      final String keyType, final String startKey, final String stopKey, final String expectedKV) {
+    testCSV(
+        createMultiIntegerDBPopulator(2),
+        FLAGSET_INTEGERKEY_DUPSORT,
+        keyType,
+        startKey,
+        stopKey,
+        expectedKV,
+        Integer.BYTES,
+        ByteOrder.nativeOrder());
+  }
+
   @ParameterizedTest(name = "{index} => {0}: ({1}, {2})")
   @CsvFileSource(resources = "/CursorIterableRangeTest/testLongKey.csv")
   void testLongKey(
@@ -136,6 +153,21 @@ void testLongKey(
         ByteOrder.nativeOrder());
   }
 
+  @ParameterizedTest(name = "{index} => {0}: ({1}, {2})")
+  @CsvFileSource(resources = "/CursorIterableRangeTest/testUnsignedComparatorDupsort.csv")
+  void testLongKeyDupSort(
+      final String keyType, final String startKey, final String stopKey, final String expectedKV) {
+    testCSV(
+        createMultiLongDBPopulator(2),
+        FLAGSET_INTEGERKEY_DUPSORT,
+        keyType,
+        startKey,
+        stopKey,
+        expectedKV,
+        Long.BYTES,
+        ByteOrder.nativeOrder());
+  }
+
   private void testCSV(
       final Function<DbiBuilder.Stage2<ByteBuffer>, DbiBuilder.Stage3<ByteBuffer>> comparatorFunc,
       final BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> dbPopulator,
@@ -319,6 +351,40 @@ private BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> createMultiDBPopulator(fina
     };
   }
 
+  private BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> createMultiIntegerDBPopulator(final int copies) {
+    return (env, dbi) -> {
+      try (Txn<ByteBuffer> txn = env.txnWrite()) {
+        final Cursor<ByteBuffer> c = dbi.openCursor(txn);
+        for (int i = 0; i < copies; i++) {
+          c.put(bbNativeInt(0), bb(1 + i));
+          c.put(bbNativeInt(2), bb(3 + i));
+          c.put(bbNativeInt(4), bb(5 + i));
+          c.put(bbNativeInt(6), bb(7 + i));
+          c.put(bbNativeInt(8), bb(9 + i));
+          c.put(bbNativeInt(-2), bb(-1 + i));
+        }
+        txn.commit();
+      }
+    };
+  }
+
+  private BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> createMultiLongDBPopulator(final int copies) {
+    return (env, dbi) -> {
+      try (Txn<ByteBuffer> txn = env.txnWrite()) {
+        final Cursor<ByteBuffer> c = dbi.openCursor(txn);
+        for (int i = 0; i < copies; i++) {
+          c.put(bbNativeLong(0), bb(1 + i));
+          c.put(bbNativeLong(2), bb(3 + i));
+          c.put(bbNativeLong(4), bb(5 + i));
+          c.put(bbNativeLong(6), bb(7 + i));
+          c.put(bbNativeLong(8), bb(9 + i));
+          c.put(bbNativeLong(-2), bb(-1 + i));
+        }
+        txn.commit();
+      }
+    };
+  }
+
   private BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> createIntegerDBPopulator() {
     return (env, dbi) -> {
       try (Txn<ByteBuffer> txn = env.txnWrite()) {

From 6982acad6a4150de8187df2a0d39bb0087e5e1fb Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Sun, 9 Nov 2025 19:33:27 +0000
Subject: [PATCH 290/322] Remove unused test, auto format

---
 .../CursorIterableIntegerDupTest.java         | 593 ------------------
 .../org/lmdbjava/CursorIterableRangeTest.java |   6 +-
 2 files changed, 4 insertions(+), 595 deletions(-)
 delete mode 100644 src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java

diff --git a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java b/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
deleted file mode 100644
index e751e458..00000000
--- a/src/test/java/org/lmdbjava/CursorIterableIntegerDupTest.java
+++ /dev/null
@@ -1,593 +0,0 @@
-/*
- * Copyright © 2016-2025 The LmdbJava Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.lmdbjava;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.lmdbjava.DbiFlags.MDB_CREATE;
-import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
-import static org.lmdbjava.DbiFlags.MDB_INTEGERDUP;
-import static org.lmdbjava.Env.create;
-import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
-import static org.lmdbjava.KeyRange.all;
-import static org.lmdbjava.KeyRange.allBackward;
-import static org.lmdbjava.KeyRange.atLeast;
-import static org.lmdbjava.KeyRange.atLeastBackward;
-import static org.lmdbjava.KeyRange.atMost;
-import static org.lmdbjava.KeyRange.atMostBackward;
-import static org.lmdbjava.KeyRange.closed;
-import static org.lmdbjava.KeyRange.closedBackward;
-import static org.lmdbjava.KeyRange.closedOpen;
-import static org.lmdbjava.KeyRange.closedOpenBackward;
-import static org.lmdbjava.KeyRange.greaterThan;
-import static org.lmdbjava.KeyRange.greaterThanBackward;
-import static org.lmdbjava.KeyRange.lessThan;
-import static org.lmdbjava.KeyRange.lessThanBackward;
-import static org.lmdbjava.KeyRange.open;
-import static org.lmdbjava.KeyRange.openBackward;
-import static org.lmdbjava.KeyRange.openClosed;
-import static org.lmdbjava.KeyRange.openClosedBackward;
-import static org.lmdbjava.TestUtils.DB_1;
-import static org.lmdbjava.TestUtils.DB_2;
-import static org.lmdbjava.TestUtils.DB_3;
-import static org.lmdbjava.TestUtils.DB_4;
-import static org.lmdbjava.TestUtils.bb;
-import static org.lmdbjava.TestUtils.bbNative;
-import static org.lmdbjava.TestUtils.getNativeInt;
-import static org.lmdbjava.TestUtils.getNativeIntOrLong;
-
-import com.google.common.primitives.UnsignedBytes;
-import java.io.IOException;
-import java.nio.ByteBuffer;
-import java.util.AbstractMap;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Comparator;
-import java.util.Deque;
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-import java.util.function.Function;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-import org.assertj.core.api.Assertions;
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtensionContext;
-import org.junit.jupiter.params.Parameter;
-import org.junit.jupiter.params.ParameterizedClass;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.ArgumentsProvider;
-import org.junit.jupiter.params.provider.ArgumentsSource;
-import org.junit.jupiter.params.support.ParameterDeclarations;
-import org.lmdbjava.CursorIterable.KeyVal;
-
-/**
- * Test {@link CursorIterable} using {@link DbiFlags#MDB_INTEGERKEY} to ensure that comparators work
- * with native order integer keys.
- */
-@Disabled // Waiting for the merge of stroomdev66's cursor tests
-@ParameterizedClass(name = "{index}: dbi: {0}")
-@ArgumentsSource(CursorIterableIntegerDupTest.MyArgumentProvider.class)
-public final class CursorIterableIntegerDupTest {
-
-  private static final DbiFlagSet DBI_FLAGS =
-      DbiFlagSet.of(MDB_CREATE, MDB_INTEGERDUP, MDB_DUPSORT);
-  private static final BufferProxy<ByteBuffer> BUFFER_PROXY = ByteBufferProxy.PROXY_OPTIMAL;
-  private static final List<Map.Entry<Integer, Integer>> INPUT_DATA;
-
-  static {
-    // 2 => 21
-    // 2 => 22
-    // 3 => 31
-    // ...
-    // 9 => 92
-    INPUT_DATA = new ArrayList<>();
-    for (int i = 2; i <= 9; i++) {
-      final int val1 = (i * 10) + 1;
-      final int val2 = (i * 10) + 2;
-      INPUT_DATA.add(new AbstractMap.SimpleEntry<>(i, val1));
-      INPUT_DATA.add(new AbstractMap.SimpleEntry<>(i, val2));
-    }
-  }
-
-  private TempDir tempDir;
-  private Env<ByteBuffer> env;
-  private Deque<Map.Entry<Integer, Integer>> expectedEntriesDeque;
-
-  @Parameter public DbiFactory dbiFactory;
-
-  @BeforeEach
-  public void before() throws IOException {
-    tempDir = new TempDir();
-    final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
-    env =
-        create(bufferProxy)
-            .setMapSize(256, ByteUnit.KIBIBYTES)
-            .setMaxReaders(1)
-            .setMaxDbs(3)
-            .setEnvFlags(MDB_NOSUBDIR)
-            .open(tempDir.createTempFile());
-
-    populateExpectedEntriesDeque();
-  }
-
-  @AfterEach
-  public void after() {
-    env.close();
-    tempDir.cleanup();
-  }
-
-  @Test
-  public void allBackwardTest() {
-    verify(allBackward(), 8, 6, 4, 2);
-  }
-
-  @Test
-  public void allTest() {
-    verify(all(), 2, 4, 6, 8);
-  }
-
-  @Test
-  public void atLeastBackwardTest() {
-    verify(atLeastBackward(bbNative(5)), 4, 2);
-    verify(atLeastBackward(bbNative(6)), 6, 4, 2);
-    verify(atLeastBackward(bbNative(9)), 8, 6, 4, 2);
-  }
-
-  @Test
-  public void atLeastTest() {
-    verify(atLeast(bbNative(5)), 6, 8);
-    verify(atLeast(bbNative(6)), 6, 8);
-  }
-
-  @Test
-  public void atMostBackwardTest() {
-    verify(atMostBackward(bbNative(5)), 8, 6);
-    verify(atMostBackward(bbNative(6)), 8, 6);
-  }
-
-  @Test
-  public void atMostTest() {
-    verify(atMost(bbNative(5)), 2, 4);
-    verify(atMost(bbNative(6)), 2, 4, 6);
-  }
-
-  private void populateExpectedEntriesDeque() {
-    expectedEntriesDeque = new LinkedList<>();
-    expectedEntriesDeque.addAll(INPUT_DATA);
-  }
-
-  private void populateDatabase(final Dbi<ByteBuffer> dbi) {
-    try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      final Cursor<ByteBuffer> c = dbi.openCursor(txn);
-      for (Map.Entry<Integer, Integer> entry : INPUT_DATA) {
-        c.put(bbNative(entry.getKey()), bb(entry.getValue()));
-      }
-      txn.commit();
-    }
-    //    try (Txn<ByteBuffer> txn = env.txnRead();
-    //         CursorIterable<ByteBuffer> c = dbi.iterate(txn)) {
-    //
-    //      for (final KeyVal<ByteBuffer> kv : c) {
-    //        System.out.print(getNativeInt(kv.key()) + " => " + kv.val().getInt());
-    //        System.out.print(", ");
-    //      }
-    //      System.out.println();
-    //    }
-  }
-
-  private int[] rangeInc(final int fromInc, final int toInc) {
-    int idx = 0;
-    if (fromInc <= toInc) {
-      // Forwards
-      final int[] arr = new int[toInc - fromInc + 1];
-      for (int i = fromInc; i <= toInc; i++) {
-        arr[idx++] = i;
-      }
-      return arr;
-    } else {
-      // Backwards
-      final int[] arr = new int[fromInc - toInc + 1];
-      for (int i = fromInc; i >= toInc; i--) {
-        arr[idx++] = i;
-      }
-      return arr;
-    }
-  }
-
-  @Test
-  public void closedBackwardTest() {
-    verify(closedBackward(bbNative(7), bbNative(3)), rangeInc(7, 3));
-    verify(closedBackward(bbNative(6), bbNative(2)), rangeInc(6, 2));
-    verify(closedBackward(bbNative(9), bbNative(3)), rangeInc(9, 3));
-  }
-
-  @Test
-  public void closedOpenBackwardTest() {
-    verify(closedOpenBackward(bbNative(8), bbNative(3)), rangeInc(8, 4));
-    verify(closedOpenBackward(bbNative(7), bbNative(2)), rangeInc(7, 3));
-    verify(closedOpenBackward(bbNative(9), bbNative(3)), rangeInc(9, 4));
-  }
-
-  @Test
-  public void closedOpenTest() {
-    verify(closedOpen(bbNative(3), bbNative(8)), rangeInc(3, 7));
-    verify(closedOpen(bbNative(2), bbNative(6)), rangeInc(2, 5));
-  }
-
-  @Test
-  public void closedTest() {
-    verify(closed(bbNative(3), bbNative(7)), rangeInc(3, 7));
-    verify(closed(bbNative(2), bbNative(6)), rangeInc(2, 6));
-    verify(closed(bbNative(1), bbNative(7)), rangeInc(2, 7));
-  }
-
-  @Test
-  public void greaterThanBackwardTest() {
-    verify(greaterThanBackward(bbNative(6)), rangeInc(5, 2));
-    verify(greaterThanBackward(bbNative(7)), rangeInc(6, 2));
-    verify(greaterThanBackward(bbNative(9)), rangeInc(8, 2));
-  }
-
-  @Test
-  public void greaterThanTest() {
-    verify(greaterThan(bbNative(4)), rangeInc(5, 9));
-    verify(greaterThan(bbNative(3)), rangeInc(4, 9));
-  }
-
-  public void iterableOnlyReturnedOnce() {
-    Assertions.assertThatThrownBy(
-            () -> {
-              final Dbi<ByteBuffer> db = getDb();
-              try (Txn<ByteBuffer> txn = env.txnRead();
-                  CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-                c.iterator(); // ok
-                c.iterator(); // fails
-              }
-            })
-        .isInstanceOf(IllegalStateException.class);
-  }
-
-  @Test
-  public void iterate() {
-    populateExpectedEntriesDeque();
-    final Dbi<ByteBuffer> db = getDb();
-    try (Txn<ByteBuffer> txn = env.txnRead();
-        CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-
-      for (final KeyVal<ByteBuffer> kv : c) {
-        final Map.Entry<Integer, Integer> entry = expectedEntriesDeque.pollFirst();
-        assertThat(entry).isNotNull();
-        //        System.out.println(entry.getKey() + " => " + entry.getValue());
-        assertThat(getNativeInt(kv.key())).isEqualTo(entry.getKey());
-        assertThat(kv.val().getInt()).isEqualTo(entry.getValue());
-      }
-    }
-  }
-
-  public void iteratorOnlyReturnedOnce() {
-    Assertions.assertThatThrownBy(
-            () -> {
-              final Dbi<ByteBuffer> db = getDb();
-              try (Txn<ByteBuffer> txn = env.txnRead();
-                  CursorIterable<ByteBuffer> c = db.iterate(txn)) {
-                c.iterator(); // ok
-                c.iterator(); // fails
-              }
-            })
-        .isInstanceOf(IllegalStateException.class);
-  }
-
-  @Test
-  public void lessThanBackwardTest() {
-    verify(lessThanBackward(bbNative(5)), 8, 6);
-    verify(lessThanBackward(bbNative(2)), 8, 6, 4);
-  }
-
-  @Test
-  public void lessThanTest() {
-    verify(lessThan(bbNative(5)), 2, 4);
-    verify(lessThan(bbNative(8)), 2, 4, 6);
-  }
-
-  @Test
-  public void openBackwardTest() {
-    verify(openBackward(bbNative(7), bbNative(2)), 6, 4);
-    verify(openBackward(bbNative(8), bbNative(1)), 6, 4, 2);
-    verify(openBackward(bbNative(9), bbNative(4)), 8, 6);
-  }
-
-  @Test
-  public void openClosedBackwardTest() {
-    verify(openClosedBackward(bbNative(7), bbNative(2)), 6, 4, 2);
-    verify(openClosedBackward(bbNative(8), bbNative(4)), 6, 4);
-    verify(openClosedBackward(bbNative(9), bbNative(4)), 8, 6, 4);
-  }
-
-  @Test
-  public void openClosedBackwardTestWithGuava() {
-    final Comparator<byte[]> guava = UnsignedBytes.lexicographicalComparator();
-    final Comparator<ByteBuffer> comparator =
-        (bb1, bb2) -> {
-          final byte[] array1 = new byte[bb1.remaining()];
-          final byte[] array2 = new byte[bb2.remaining()];
-          bb1.mark();
-          bb2.mark();
-          bb1.get(array1);
-          bb2.get(array2);
-          bb1.reset();
-          bb2.reset();
-          return guava.compare(array1, array2);
-        };
-
-    final Dbi<ByteBuffer> guavaDbi =
-        env.createDbi()
-            .setDbName(DB_1)
-            .withIteratorComparator(ignored -> comparator)
-            .setDbiFlags(MDB_CREATE)
-            .open();
-
-    populateDatabase(guavaDbi);
-    verify(openClosedBackward(bbNative(7), bbNative(2)), guavaDbi, 6, 4, 2);
-    verify(openClosedBackward(bbNative(8), bbNative(4)), guavaDbi, 6, 4);
-  }
-
-  @Test
-  public void openClosedTest() {
-    verify(openClosed(bbNative(3), bbNative(8)), 4, 6, 8);
-    verify(openClosed(bbNative(2), bbNative(6)), 4, 6);
-  }
-
-  @Test
-  public void openTest() {
-    verify(open(bbNative(3), bbNative(7)), 4, 6);
-    verify(open(bbNative(2), bbNative(8)), 4, 6);
-  }
-
-  @Test
-  public void removeOddElements() {
-    final Dbi<ByteBuffer> db = getDb();
-    verify(db, all(), 2, 4, 6, 8);
-    int idx = -1;
-    try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      try (CursorIterable<ByteBuffer> ci = db.iterate(txn)) {
-        final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
-        while (c.hasNext()) {
-          c.next();
-          idx++;
-          if (idx % 2 == 0) {
-            c.remove();
-          }
-        }
-      }
-      txn.commit();
-    }
-    verify(db, all(), 4, 8);
-  }
-
-  public void nextWithClosedEnvTest() {
-    Assertions.assertThatThrownBy(
-            () -> {
-              final Dbi<ByteBuffer> db = getDb();
-              try (Txn<ByteBuffer> txn = env.txnRead()) {
-                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
-
-                  env.close();
-                  c.next();
-                }
-              }
-            })
-        .isInstanceOf(Env.AlreadyClosedException.class);
-  }
-
-  public void removeWithClosedEnvTest() {
-    Assertions.assertThatThrownBy(
-            () -> {
-              final Dbi<ByteBuffer> db = getDb();
-              try (Txn<ByteBuffer> txn = env.txnWrite()) {
-                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
-                  final KeyVal<ByteBuffer> keyVal = c.next();
-                  assertThat(keyVal).isNotNull();
-                  env.close();
-                  c.remove();
-                }
-              }
-            })
-        .isInstanceOf(Env.AlreadyClosedException.class);
-  }
-
-  public void hasNextWithClosedEnvTest() {
-    Assertions.assertThatThrownBy(
-            () -> {
-              final Dbi<ByteBuffer> db = getDb();
-              try (Txn<ByteBuffer> txn = env.txnRead()) {
-                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
-
-                  env.close();
-                  c.hasNext();
-                }
-              }
-            })
-        .isInstanceOf(Env.AlreadyClosedException.class);
-  }
-
-  public void forEachRemainingWithClosedEnvTest() {
-    Assertions.assertThatThrownBy(
-            () -> {
-              final Dbi<ByteBuffer> db = getDb();
-              try (Txn<ByteBuffer> txn = env.txnRead()) {
-                try (CursorIterable<ByteBuffer> ci = db.iterate(txn, KeyRange.all())) {
-                  final Iterator<KeyVal<ByteBuffer>> c = ci.iterator();
-
-                  env.close();
-                  c.forEachRemaining(keyVal -> {});
-                }
-              }
-            })
-        .isInstanceOf(Env.AlreadyClosedException.class);
-  }
-
-  private void verify(final KeyRange<ByteBuffer> range, final int... expectedKeys) {
-    // Verify using all comparator types
-    final Dbi<ByteBuffer> db = getDb();
-    verify(range, db, expectedKeys);
-  }
-
-  private void verify(
-      final Dbi<ByteBuffer> dbi, final KeyRange<ByteBuffer> range, final int... expectedKeys) {
-    verify(range, dbi, expectedKeys);
-  }
-
-  private void verify(
-      final KeyRange<ByteBuffer> range, final Dbi<ByteBuffer> dbi, final int... expectedKeys) {
-    final boolean isForward = range.getType().isDirectionForward();
-
-    final List<Integer> expectedValues =
-        Arrays.stream(expectedKeys)
-            .boxed()
-            .flatMap(
-                key -> {
-                  final int base = key * 10;
-                  return isForward ? Stream.of(base + 1, base + 2) : Stream.of(base + 2, base + 1);
-                })
-            .collect(Collectors.toList());
-
-    final List<Integer> results = new ArrayList<>();
-    //    System.out.println(rangeToString(range) + ", expected: " + expectedValues);
-
-    try (Txn<ByteBuffer> txn = env.txnRead();
-        CursorIterable<ByteBuffer> c = dbi.iterate(txn, range)) {
-      for (final KeyVal<ByteBuffer> kv : c) {
-        final int key = getNativeInt(kv.key());
-        final int val = kv.val().getInt();
-        //        System.out.println(key + " => " + val);
-        results.add(val);
-        assertThat(val)
-            .satisfiesAnyOf(
-                v -> assertThat(v).isEqualTo((key * 10) + 1),
-                v -> assertThat(v).isEqualTo((key * 10) + 2));
-      }
-    }
-
-    assertThat(results).hasSize(expectedValues.size());
-    for (int idx = 0; idx < results.size(); idx++) {
-      assertThat(results.get(idx)).isEqualTo(expectedValues.get(idx));
-    }
-  }
-
-  private String rangeToString(final KeyRange<ByteBuffer> range) {
-    final ByteBuffer start = range.getStart();
-    final ByteBuffer stop = range.getStop();
-    return range.getType()
-        + " start: "
-        + (start != null ? getNativeInt(start) : "")
-        + " stop: "
-        + (stop != null ? getNativeInt(stop) : "");
-  }
-
-  private Dbi<ByteBuffer> getDb() {
-    final Dbi<ByteBuffer> dbi = dbiFactory.factory.apply(env);
-    populateDatabase(dbi);
-    return dbi;
-  }
-
-  private static class DbiFactory {
-    private final String name;
-    private final Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory;
-
-    private DbiFactory(String name, Function<Env<ByteBuffer>, Dbi<ByteBuffer>> factory) {
-      this.name = name;
-      this.factory = factory;
-    }
-
-    @Override
-    public String toString() {
-      return name;
-    }
-  }
-
-  static class MyArgumentProvider implements ArgumentsProvider {
-
-    @Override
-    public Stream<? extends Arguments> provideArguments(
-        ParameterDeclarations parameters, ExtensionContext context) throws Exception {
-      final DbiFactory defaultComparatorDb =
-          new DbiFactory(
-              "defaultComparator",
-              env ->
-                  env.createDbi()
-                      .setDbName(DB_1)
-                      .withDefaultComparator()
-                      .setDbiFlags(DBI_FLAGS)
-                      .open());
-      final DbiFactory nativeComparatorDb =
-          new DbiFactory(
-              "nativeComparator",
-              env ->
-                  env.createDbi()
-                      .setDbName(DB_2)
-                      .withNativeComparator()
-                      .setDbiFlags(DBI_FLAGS)
-                      .open());
-      final DbiFactory callbackComparatorDb =
-          new DbiFactory(
-              "callbackComparator",
-              env ->
-                  env.createDbi()
-                      .setDbName(DB_3)
-                      .withCallbackComparator(MyArgumentProvider::buildComparator)
-                      .setDbiFlags(DBI_FLAGS)
-                      .open());
-      final DbiFactory iteratorComparatorDb =
-          new DbiFactory(
-              "iteratorComparator",
-              env ->
-                  env.createDbi()
-                      .setDbName(DB_4)
-                      .withIteratorComparator(MyArgumentProvider::buildComparator)
-                      .setDbiFlags(DBI_FLAGS)
-                      .open());
-      return Stream.of(
-              defaultComparatorDb, nativeComparatorDb, callbackComparatorDb, iteratorComparatorDb)
-          .map(Arguments::of);
-    }
-
-    private static Comparator<ByteBuffer> buildComparator(final DbiFlagSet dbiFlagSet) {
-      final Comparator<ByteBuffer> baseComparator = BUFFER_PROXY.getComparator(DBI_FLAGS);
-      return (o1, o2) -> {
-        if (o1.remaining() != o2.remaining()) {
-          // Make sure LMDB is always giving us consistent key lengths.
-          Assertions.fail(
-              "o1: "
-                  + o1
-                  + " "
-                  + getNativeIntOrLong(o1)
-                  + ", o2: "
-                  + o2
-                  + " "
-                  + getNativeIntOrLong(o2));
-        }
-        return baseComparator.compare(o1, o2);
-      };
-    }
-  }
-}
diff --git a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
index 809b5065..8c4868f0 100644
--- a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
@@ -351,7 +351,8 @@ private BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> createMultiDBPopulator(fina
     };
   }
 
-  private BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> createMultiIntegerDBPopulator(final int copies) {
+  private BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> createMultiIntegerDBPopulator(
+      final int copies) {
     return (env, dbi) -> {
       try (Txn<ByteBuffer> txn = env.txnWrite()) {
         final Cursor<ByteBuffer> c = dbi.openCursor(txn);
@@ -368,7 +369,8 @@ private BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> createMultiIntegerDBPopulat
     };
   }
 
-  private BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> createMultiLongDBPopulator(final int copies) {
+  private BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> createMultiLongDBPopulator(
+      final int copies) {
     return (env, dbi) -> {
       try (Txn<ByteBuffer> txn = env.txnWrite()) {
         final Cursor<ByteBuffer> c = dbi.openCursor(txn);

From 6740e2bd927bb04280b1f68e2b4a1e8d69fe5589 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Wed, 12 Nov 2025 08:57:59 +0000
Subject: [PATCH 291/322] Add tests to stop CodeQL warnings

---
 src/test/java/org/lmdbjava/AbstractFlagSetTest.java |  1 +
 src/test/java/org/lmdbjava/CopyFlagSetTest.java     | 10 ++++++++++
 src/test/java/org/lmdbjava/DbiFlagSetTest.java      | 10 ++++++++++
 src/test/java/org/lmdbjava/EnvFlagSetTest.java      | 10 ++++++++++
 src/test/java/org/lmdbjava/PutFlagSetTest.java      |  9 +++++++++
 src/test/java/org/lmdbjava/TxnFlagSetTest.java      | 10 ++++++++++
 6 files changed, 50 insertions(+)

diff --git a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
index 5dfe5a0d..bef97911 100644
--- a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
@@ -99,6 +99,7 @@ void testAllFlags() {
       final F flagSet = getBuilder().setFlags(flags).build();
       final int flagSetMask = flagSet.getMask();
 
+      // Make sure all the mask values are unique
       assertThat(masks).doesNotContain(flagSetMask);
       masks.add(flagSetMask);
       assertThat(flagSetMask).isEqualTo(MaskedFlag.mask(flags));
diff --git a/src/test/java/org/lmdbjava/CopyFlagSetTest.java b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
index 559bd8ea..ec9005bd 100644
--- a/src/test/java/org/lmdbjava/CopyFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
@@ -19,9 +19,19 @@
 import java.util.Collection;
 import java.util.List;
 import java.util.stream.Collectors;
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 class CopyFlagSetTest extends AbstractFlagSetTest<CopyFlags, CopyFlagSet> {
 
+  @Test
+  void test() {
+    // This is here purely to stop CodeQL moaning that this class is unused.
+    // All the actual tests are in the superclass
+    Assertions.assertThat(getAllFlags())
+        .isNotNull();
+  }
+
   @Override
   List<CopyFlags> getAllFlags() {
     return Arrays.stream(CopyFlags.values()).collect(Collectors.toList());
diff --git a/src/test/java/org/lmdbjava/DbiFlagSetTest.java b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
index be97aea6..ce9c1ec9 100644
--- a/src/test/java/org/lmdbjava/DbiFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
@@ -19,9 +19,19 @@
 import java.util.Collection;
 import java.util.List;
 import java.util.stream.Collectors;
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 class DbiFlagSetTest extends AbstractFlagSetTest<DbiFlags, DbiFlagSet> {
 
+  @Test
+  void test() {
+    // This is here purely to stop CodeQL moaning that this class is unused.
+    // All the actual tests are in the superclass
+    Assertions.assertThat(getAllFlags())
+        .isNotNull();
+  }
+
   @Override
   List<DbiFlags> getAllFlags() {
     return Arrays.stream(DbiFlags.values()).collect(Collectors.toList());
diff --git a/src/test/java/org/lmdbjava/EnvFlagSetTest.java b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
index 35fcc001..1c5110c3 100644
--- a/src/test/java/org/lmdbjava/EnvFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
@@ -19,9 +19,19 @@
 import java.util.Collection;
 import java.util.List;
 import java.util.stream.Collectors;
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 class EnvFlagSetTest extends AbstractFlagSetTest<EnvFlags, EnvFlagSet> {
 
+  @Test
+  void test() {
+    // This is here purely to stop CodeQL moaning that this class is unused.
+    // All the actual tests are in the superclass
+    Assertions.assertThat(getAllFlags())
+        .isNotNull();
+  }
+
   @Override
   List<EnvFlags> getAllFlags() {
     return Arrays.stream(EnvFlags.values()).collect(Collectors.toList());
diff --git a/src/test/java/org/lmdbjava/PutFlagSetTest.java b/src/test/java/org/lmdbjava/PutFlagSetTest.java
index 9b6f3a09..9cb4504d 100644
--- a/src/test/java/org/lmdbjava/PutFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/PutFlagSetTest.java
@@ -22,10 +22,19 @@
 import java.util.List;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
+import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 class PutFlagSetTest extends AbstractFlagSetTest<PutFlags, PutFlagSet> {
 
+  @Test
+  void test() {
+    // This is here purely to stop CodeQL moaning that this class is unused.
+    // All the actual tests are in the superclass
+    Assertions.assertThat(getAllFlags())
+        .isNotNull();
+  }
+
   @Override
   List<PutFlags> getAllFlags() {
     return Arrays.stream(PutFlags.values()).collect(Collectors.toList());
diff --git a/src/test/java/org/lmdbjava/TxnFlagSetTest.java b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
index 3ef93195..27e8c4cf 100644
--- a/src/test/java/org/lmdbjava/TxnFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
@@ -19,9 +19,19 @@
 import java.util.Collection;
 import java.util.List;
 import java.util.stream.Collectors;
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.Test;
 
 class TxnFlagSetTest extends AbstractFlagSetTest<TxnFlags, TxnFlagSet> {
 
+  @Test
+  void test() {
+    // This is here purely to stop CodeQL moaning that this class is unused.
+    // All the actual tests are in the superclass
+    Assertions.assertThat(getAllFlags())
+        .isNotNull();
+  }
+
   @Override
   List<TxnFlags> getAllFlags() {
     return Arrays.stream(TxnFlags.values()).collect(Collectors.toList());

From 0103f134b51cd1e93e4e9e18c9e648a1e4dfe201 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Wed, 12 Nov 2025 09:01:03 +0000
Subject: [PATCH 292/322] Auto format

---
 src/test/java/org/lmdbjava/CopyFlagSetTest.java | 3 +--
 src/test/java/org/lmdbjava/DbiFlagSetTest.java  | 3 +--
 src/test/java/org/lmdbjava/EnvFlagSetTest.java  | 3 +--
 src/test/java/org/lmdbjava/PutFlagSetTest.java  | 3 +--
 src/test/java/org/lmdbjava/TxnFlagSetTest.java  | 3 +--
 5 files changed, 5 insertions(+), 10 deletions(-)

diff --git a/src/test/java/org/lmdbjava/CopyFlagSetTest.java b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
index ec9005bd..96203af9 100644
--- a/src/test/java/org/lmdbjava/CopyFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
@@ -28,8 +28,7 @@ class CopyFlagSetTest extends AbstractFlagSetTest<CopyFlags, CopyFlagSet> {
   void test() {
     // This is here purely to stop CodeQL moaning that this class is unused.
     // All the actual tests are in the superclass
-    Assertions.assertThat(getAllFlags())
-        .isNotNull();
+    Assertions.assertThat(getAllFlags()).isNotNull();
   }
 
   @Override
diff --git a/src/test/java/org/lmdbjava/DbiFlagSetTest.java b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
index ce9c1ec9..5be7bc60 100644
--- a/src/test/java/org/lmdbjava/DbiFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
@@ -28,8 +28,7 @@ class DbiFlagSetTest extends AbstractFlagSetTest<DbiFlags, DbiFlagSet> {
   void test() {
     // This is here purely to stop CodeQL moaning that this class is unused.
     // All the actual tests are in the superclass
-    Assertions.assertThat(getAllFlags())
-        .isNotNull();
+    Assertions.assertThat(getAllFlags()).isNotNull();
   }
 
   @Override
diff --git a/src/test/java/org/lmdbjava/EnvFlagSetTest.java b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
index 1c5110c3..24300c1f 100644
--- a/src/test/java/org/lmdbjava/EnvFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
@@ -28,8 +28,7 @@ class EnvFlagSetTest extends AbstractFlagSetTest<EnvFlags, EnvFlagSet> {
   void test() {
     // This is here purely to stop CodeQL moaning that this class is unused.
     // All the actual tests are in the superclass
-    Assertions.assertThat(getAllFlags())
-        .isNotNull();
+    Assertions.assertThat(getAllFlags()).isNotNull();
   }
 
   @Override
diff --git a/src/test/java/org/lmdbjava/PutFlagSetTest.java b/src/test/java/org/lmdbjava/PutFlagSetTest.java
index 9cb4504d..93d3aab0 100644
--- a/src/test/java/org/lmdbjava/PutFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/PutFlagSetTest.java
@@ -31,8 +31,7 @@ class PutFlagSetTest extends AbstractFlagSetTest<PutFlags, PutFlagSet> {
   void test() {
     // This is here purely to stop CodeQL moaning that this class is unused.
     // All the actual tests are in the superclass
-    Assertions.assertThat(getAllFlags())
-        .isNotNull();
+    Assertions.assertThat(getAllFlags()).isNotNull();
   }
 
   @Override
diff --git a/src/test/java/org/lmdbjava/TxnFlagSetTest.java b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
index 27e8c4cf..2d700525 100644
--- a/src/test/java/org/lmdbjava/TxnFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
@@ -28,8 +28,7 @@ class TxnFlagSetTest extends AbstractFlagSetTest<TxnFlags, TxnFlagSet> {
   void test() {
     // This is here purely to stop CodeQL moaning that this class is unused.
     // All the actual tests are in the superclass
-    Assertions.assertThat(getAllFlags())
-        .isNotNull();
+    Assertions.assertThat(getAllFlags()).isNotNull();
   }
 
   @Override

From 42495667abd3756392933369cc4d20cfdfb09855 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Wed, 12 Nov 2025 09:23:53 +0000
Subject: [PATCH 293/322] Fix typo in javadoc

---
 src/main/java/org/lmdbjava/ByteUnit.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/org/lmdbjava/ByteUnit.java b/src/main/java/org/lmdbjava/ByteUnit.java
index 51dab217..1c37ad24 100644
--- a/src/main/java/org/lmdbjava/ByteUnit.java
+++ b/src/main/java/org/lmdbjava/ByteUnit.java
@@ -15,7 +15,7 @@
  */
 package org.lmdbjava;
 
-/** Simple {@link Enum} for converting various IEC and SI byte units down a number of bytes. */
+/** Simple {@link Enum} for converting various IEC and SI byte units down to a number of bytes. */
 public enum ByteUnit {
 
   /** IEC/SI byte unit for bytes. */

From 35b0a9dacf1f4528f0800c7f17d4584d097e5f1c Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Wed, 12 Nov 2025 09:38:15 +0000
Subject: [PATCH 294/322] Tidy code

---
 src/test/java/org/lmdbjava/CursorIterablePerfTest.java | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
index 66d83cc5..198ffd28 100644
--- a/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterablePerfTest.java
@@ -22,7 +22,6 @@
 import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
 import static org.lmdbjava.TestUtils.bb;
 
-import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.nio.charset.StandardCharsets;
 import java.time.Duration;
@@ -44,7 +43,7 @@ class CursorIterablePerfTest {
   private Env<ByteBuffer> env;
 
   @BeforeEach
-  public void before() throws IOException {
+  public void before() {
     tempDir = new TempDir();
     final BufferProxy<ByteBuffer> bufferProxy = ByteBufferProxy.PROXY_OPTIMAL;
     env =

From 9a3571876e320fea48702ecc30a1510f2e944959 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 14 Nov 2025 15:22:42 +0000
Subject: [PATCH 295/322] Add in test classes for deprecated methods

---
 src/main/java/org/lmdbjava/DbiBuilder.java    |   4 +-
 src/main/java/org/lmdbjava/Env.java           | 172 ++---
 src/main/java/org/lmdbjava/Verifier.java      |   3 +-
 .../org/lmdbjava/CursorDeprecatedTest.java    | 312 ++++++++
 .../org/lmdbjava/CursorIterableRangeTest.java | 103 +--
 .../java/org/lmdbjava/CursorParamTest.java    |   7 +-
 src/test/java/org/lmdbjava/CursorTest.java    |  87 ++-
 .../java/org/lmdbjava/DbiDeprecatedTest.java  | 675 ++++++++++++++++++
 src/test/java/org/lmdbjava/DbiTest.java       | 108 ++-
 .../java/org/lmdbjava/EnvDeprecatedTest.java  | 383 ++++++++++
 src/test/java/org/lmdbjava/EnvTest.java       |  38 +-
 .../org/lmdbjava/GarbageCollectionTest.java   |   7 +-
 src/test/java/org/lmdbjava/TutorialTest.java  |  36 +-
 src/test/java/org/lmdbjava/TxnTest.java       |  29 +-
 14 files changed, 1710 insertions(+), 254 deletions(-)
 create mode 100644 src/test/java/org/lmdbjava/CursorDeprecatedTest.java
 create mode 100644 src/test/java/org/lmdbjava/DbiDeprecatedTest.java
 create mode 100644 src/test/java/org/lmdbjava/EnvDeprecatedTest.java

diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
index fcb457ed..f322cb6d 100644
--- a/src/main/java/org/lmdbjava/DbiBuilder.java
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -170,11 +170,9 @@ public Stage3<T> withCallbackComparator(final ComparatorFactory<T> comparatorFac
     }
 
     /**
+     * <strong>WARNING</strong>: Only use this if you fully understand the risks and implications.
      * <hr>
      *
-     * <p><strong>WARNING</strong>: Only use this if you fully understand the risks and
-     * implications. <hr>
-     *
      * <p>With this option, {@link CursorIterable} will make use of the passed comparator for
      * comparing iteration keys to start/stop keys. It has <strong>NO</strong> bearing on the
      * insert/iteration order of the database (which is controlled by LMDB's own comparators).
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index d43ebd0f..eec1c354 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -16,7 +16,6 @@
 package org.lmdbjava;
 
 import static java.lang.Boolean.getBoolean;
-import static java.nio.charset.StandardCharsets.UTF_8;
 import static java.util.Objects.requireNonNull;
 import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
@@ -135,27 +134,6 @@ public void close() {
     LIB.mdb_env_close(ptr);
   }
 
-  /**
-   * Copies an LMDB environment to the specified destination path.
-   *
-   * <p>This function may be used to make a backup of an existing environment. No lockfile is
-   * created, since it gets recreated at need.
-   *
-   * <p>If this environment was created using {@link EnvFlags#MDB_NOSUBDIR}, the destination path
-   * must be a directory that exists but contains no files. If {@link EnvFlags#MDB_NOSUBDIR} was
-   * used, the destination path must not exist, but it must be possible to create a file at the
-   * provided path.
-   *
-   * <p>Note: This call can trigger significant file size growth if run in parallel with write
-   * transactions, because it employs a read-only transaction. See long-lived transactions under
-   * "Caveats" in the LMDB native documentation.
-   *
-   * @param path writable destination path as described above
-   */
-  public void copy(final Path path) {
-    copy(path, CopyFlagSet.EMPTY);
-  }
-
   /**
    * Copies an LMDB environment to the specified destination path.
    *
@@ -173,11 +151,12 @@ public void copy(final Path path) {
    *
    * @param path writable destination path as described above
    * @param flags special options for this copy
+   * @deprecated Use {@link Env#copy(Path, CopyFlagSet)}
    */
-  public void copy(final Path path, final CopyFlagSet flags) {
+  @Deprecated
+  public void copy(final File path, final CopyFlags... flags) {
     requireNonNull(path);
-    validatePath(path);
-    checkRc(LIB.mdb_env_copy2(ptr, path.toAbsolutePath().toString(), flags.getMask()));
+    copy(path.toPath(), CopyFlagSet.of(flags));
   }
 
   /**
@@ -196,13 +175,9 @@ public void copy(final Path path, final CopyFlagSet flags) {
    * "Caveats" in the LMDB native documentation.
    *
    * @param path writable destination path as described above
-   * @param flags special options for this copy
-   * @deprecated Use {@link Env#copy(Path, CopyFlagSet)}
    */
-  @Deprecated
-  public void copy(final File path, final CopyFlags... flags) {
-    requireNonNull(path);
-    copy(path.toPath(), CopyFlagSet.of(flags));
+  public void copy(final Path path) {
+    copy(path, CopyFlagSet.EMPTY);
   }
 
   /**
@@ -221,12 +196,12 @@ public void copy(final File path, final CopyFlags... flags) {
    * "Caveats" in the LMDB native documentation.
    *
    * @param path writable destination path as described above
-   * @deprecated Use {@link Env#copy(Path)}
+   * @param flags special options for this copy
    */
-  @Deprecated
-  public void copy(final File path) {
+  public void copy(final Path path, final CopyFlagSet flags) {
     requireNonNull(path);
-    copy(path.toPath(), CopyFlagSet.EMPTY);
+    validatePath(path);
+    checkRc(LIB.mdb_env_copy2(ptr, path.toAbsolutePath().toString(), flags.getMask()));
   }
 
   /**
@@ -243,16 +218,17 @@ public void copy(final File path) {
   public List<byte[]> getDbiNames() {
     final List<byte[]> result = new ArrayList<>();
     // The unnamed DB is special so the names of the named DBs are held as keys in it.
-    final Dbi<T> unnamedDb = openDbi((byte[]) null, DbiFlagSet.EMPTY);
-    try (final Txn<T> txn = txnRead();
-        final Cursor<T> cursor = unnamedDb.openCursor(txn)) {
-      if (!cursor.first()) {
-        return Collections.emptyList();
+    try (final Txn<T> readTxn = txnRead()) {
+      final Dbi<T> unnamedDb = new Dbi<>(this, readTxn, null, proxy, DbiFlagSet.EMPTY);
+      try (final Cursor<T> cursor = unnamedDb.openCursor(readTxn)) {
+        if (!cursor.first()) {
+          return Collections.emptyList();
+        }
+        do {
+          final byte[] name = proxy.getBytes(cursor.key());
+          result.add(name);
+        } while (cursor.next());
       }
-      do {
-        final byte[] name = proxy.getBytes(cursor.key());
-        result.add(name);
-      } while (cursor.next());
     }
     return result;
   }
@@ -336,8 +312,10 @@ public boolean isReadOnly() {
   }
 
   /**
-   * Open (and optionally creates, if {@link DbiFlags#MDB_CREATE} is set) a {@link Dbi} using a
-   * builder.
+   * Returns a builder for creating and opening a {@link Dbi} instance in this {@link Env}.
+   *
+   * <p>The flag {@link DbiFlags#MDB_CREATE} needs to be set on the builder if you need to create a
+   * new database before opening it.
    *
    * @return A new builder instance for creating/opening a {@link Dbi}.
    */
@@ -345,55 +323,17 @@ public DbiBuilder<T> createDbi() {
     return new DbiBuilder<>(this, proxy, readOnly);
   }
 
-  /**
-   * Open (and optionally creates, if {@link DbiFlags#MDB_CREATE} is set) a {@link Dbi} using a
-   * builder.
-   *
-   * <p>For more options when opening a {@link Dbi} see {@link Env#createDbi()}.
-   *
-   * @param name name of the database (or null if no name is required)
-   * @param dbiFlagSet Flags to open the database with
-   * @return a database that is ready to use
-   */
-  public Dbi<T> openDbi(final String name, final DbiFlagSet dbiFlagSet) {
-    final byte[] nameBytes = name == null ? null : name.getBytes(UTF_8);
-    try (Txn<T> txn = readOnly ? txnRead() : txnWrite()) {
-      final Dbi<T> dbi = new Dbi<>(this, txn, nameBytes, proxy, dbiFlagSet);
-      txn.commit(); // even RO Txns require a commit to retain Dbi in Env
-      return dbi;
-    }
-  }
-
-  /**
-   * Convenience method that opens a {@link Dbi} with a default {@link Comparator} that is not
-   * invoked from native code.
-   *
-   * <p>For more options when opening a {@link Dbi} see {@link Env#createDbi()}.
-   *
-   * @param name name of the database (or null if no name is required)
-   * @param dbiFlagSet Flags to open the database with
-   * @return a database that is ready to use
-   */
-  public Dbi<T> openDbi(final byte[] name, final DbiFlagSet dbiFlagSet) {
-    try (Txn<T> txn = readOnly ? txnRead() : txnWrite()) {
-      final Dbi<T> dbi = new Dbi<>(this, txn, name, proxy, dbiFlagSet);
-      txn.commit(); // even RO Txns require a commit to retain Dbi in Env
-      return dbi;
-    }
-  }
-
   /**
    * @param name name of the database (or null if no name is required)
    * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#createDbi()} or {@link Env#openDbi(String, DbiFlagSet)}
-   *     Convenience method that opens a {@link Dbi} with a UTF-8 database name and default {@link
-   *     Comparator} that is not invoked from native code.
+   * @deprecated Instead use {@link Env#createDbi()}
+   *     <p>Convenience method that opens a {@link Dbi} with a UTF-8 database name and default
+   *     {@link Comparator} that is not invoked from native code.
    */
   @Deprecated()
   public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
-    final byte[] nameBytes = name == null ? null : name.getBytes(UTF_8);
-    return openDbi(nameBytes, null, false, flags);
+    return createDbi().setDbName(name).withDefaultComparator().setDbiFlags(flags).open();
   }
 
   /**
@@ -402,9 +342,9 @@ public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
    *     comparator will be used.
    * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#createDbi()} Convenience method that opens a {@link Dbi}
-   *     with a UTF-8 database name and associated {@link Comparator} for use by {@link
-   *     CursorIterable} when comparing start/stop keys.
+   * @deprecated Instead use {@link Env#createDbi()}
+   *     <p>Convenience method that opens a {@link Dbi} with a UTF-8 database name and associated
+   *     {@link Comparator} for use by {@link CursorIterable} when comparing start/stop keys.
    *     <p>It is very important that the passed comparator behaves in the same way as the
    *     comparator LMDB uses for its insertion order (for the type of data that will be stored in
    *     the database), or you fully understand the implications of them behaving differently.
@@ -415,7 +355,12 @@ public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
   public Dbi<T> openDbi(
       final String name, final Comparator<T> comparator, final DbiFlags... flags) {
     final byte[] nameBytes = name == null ? null : name.getBytes(DEFAULT_NAME_CHARSET);
-    return openDbi(nameBytes, comparator, false, flags);
+    try (Txn<T> txn = readOnly ? txnRead() : txnWrite()) {
+      final Dbi<T> dbi =
+          new Dbi<>(this, txn, nameBytes, comparator, false, proxy, DbiFlagSet.of(flags));
+      txn.commit(); // even RO Txns require a commit to retain Dbi in Env
+      return dbi;
+    }
   }
 
   /**
@@ -425,11 +370,12 @@ public Dbi<T> openDbi(
    * @param nativeCb whether LMDB native code calls back to the Java comparator
    * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#createDbi()} Convenience method that opens a {@link Dbi}
-   *     with a UTF-8 database name and associated {@link Comparator}. The comparator will be used
-   *     by {@link CursorIterable} when comparing start/stop keys as a minimum. If nativeCb is
-   *     {@code true}, this comparator will also be called by LMDB to determine insertion/iteration
-   *     order. Calling back to a java comparator may significantly impact performance.
+   * @deprecated Instead use {@link Env#createDbi()}
+   *     <p>Convenience method that opens a {@link Dbi} with a UTF-8 database name and associated
+   *     {@link Comparator}. The comparator will be used by {@link CursorIterable} when comparing
+   *     start/stop keys as a minimum. If nativeCb is {@code true}, this comparator will also be
+   *     called by LMDB to determine insertion/iteration order. Calling back to a java comparator
+   *     may significantly impact performance.
    */
   @Deprecated()
   public Dbi<T> openDbi(
@@ -438,15 +384,21 @@ public Dbi<T> openDbi(
       final boolean nativeCb,
       final DbiFlags... flags) {
     final byte[] nameBytes = name == null ? null : name.getBytes(DEFAULT_NAME_CHARSET);
-    return openDbi(nameBytes, comparator, nativeCb, flags);
+    try (Txn<T> txn = readOnly ? txnRead() : txnWrite()) {
+      final Dbi<T> dbi =
+          new Dbi<>(this, txn, nameBytes, comparator, nativeCb, proxy, DbiFlagSet.of(flags));
+      txn.commit(); // even RO Txns require a commit to retain Dbi in Env
+      return dbi;
+    }
   }
 
   /**
    * @param name name of the database (or null if no name is required)
    * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#createDbi()} <hr> Convenience method that opens a {@link
-   *     Dbi} with a default {@link Comparator} that is not invoked from native code.
+   * @deprecated Instead use {@link Env#createDbi()}
+   *     <p>Convenience method that opens a {@link Dbi} with a default {@link Comparator} that is
+   *     not invoked from native code.
    */
   @Deprecated()
   public Dbi<T> openDbi(final byte[] name, final DbiFlags... flags) {
@@ -455,11 +407,12 @@ public Dbi<T> openDbi(final byte[] name, final DbiFlags... flags) {
 
   /**
    * @param name name of the database (or null if no name is required)
-   * @param comparator custom comparator callback (or null to use LMDB default)
+   * @param comparator custom iterator comparator (or null to use LMDB default)
    * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#createDbi()} <hr> Convenience method that opens a {@link
-   *     Dbi} with an associated {@link Comparator} that is not invoked from native code.
+   * @deprecated Instead use {@link Env#createDbi()}
+   *     <p>Convenience method that opens a {@link Dbi} with an associated {@link Comparator} that
+   *     is not invoked from native code.
    */
   @Deprecated()
   public Dbi<T> openDbi(
@@ -478,9 +431,9 @@ public Dbi<T> openDbi(
    * @param nativeCb whether native code calls back to the Java comparator
    * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#createDbi()} <hr> Convenience method that opens a {@link
-   *     Dbi} with an associated {@link Comparator} that may be invoked from native code if
-   *     specified.
+   * @deprecated Instead use {@link Env#createDbi()}
+   *     <p>Convenience method that opens a {@link Dbi} with an associated {@link Comparator} that
+   *     may be invoked from native code if specified.
    *     <p>This method will automatically commit the private transaction before returning. This
    *     ensures the <code>Dbi</code> is available in the <code>Env</code>.
    */
@@ -491,7 +444,8 @@ public Dbi<T> openDbi(
       final boolean nativeCb,
       final DbiFlags... flags) {
     try (Txn<T> txn = readOnly ? txnRead() : txnWrite()) {
-      final Dbi<T> dbi = openDbi(txn, name, comparator, nativeCb, flags);
+      final Dbi<T> dbi =
+          new Dbi<>(this, txn, name, comparator, nativeCb, proxy, DbiFlagSet.of(flags));
       txn.commit(); // even RO Txns require a commit to retain Dbi in Env
       return dbi;
     }
@@ -504,8 +458,8 @@ public Dbi<T> openDbi(
    * @param nativeCb whether native LMDB code should call back to the Java comparator
    * @param flags to open the database with
    * @return a database that is ready to use
-   * @deprecated Instead use {@link Env#createDbi()} Open the {@link Dbi} using the passed {@link
-   *     Txn}.
+   * @deprecated Instead use {@link Env#createDbi()}
+   *     <p>Open the {@link Dbi} using the passed {@link Txn}.
    *     <p>The caller must commit the transaction after this method returns in order to retain the
    *     <code>Dbi</code> in the <code>Env</code>.
    *     <p>A {@link Comparator} may be provided when calling this method. Such comparator is
diff --git a/src/main/java/org/lmdbjava/Verifier.java b/src/main/java/org/lmdbjava/Verifier.java
index cbe99b81..87351fb0 100644
--- a/src/main/java/org/lmdbjava/Verifier.java
+++ b/src/main/java/org/lmdbjava/Verifier.java
@@ -175,7 +175,8 @@ private void createDbis() {
 
   private void deleteDbis() {
     for (final byte[] existingDbiName : env.getDbiNames()) {
-      final Dbi<ByteBuffer> existingDbi = env.openDbi(existingDbiName, DbiFlagSet.EMPTY);
+      final Dbi<ByteBuffer> existingDbi =
+          env.createDbi().setDbName(existingDbiName).withDefaultComparator().open();
       try (Txn<ByteBuffer> txn = env.txnWrite()) {
         existingDbi.drop(txn, true);
         txn.commit();
diff --git a/src/test/java/org/lmdbjava/CursorDeprecatedTest.java b/src/test/java/org/lmdbjava/CursorDeprecatedTest.java
new file mode 100644
index 00000000..cff118fa
--- /dev/null
+++ b/src/test/java/org/lmdbjava/CursorDeprecatedTest.java
@@ -0,0 +1,312 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import static java.lang.Long.BYTES;
+import static java.lang.Long.MIN_VALUE;
+import static java.nio.ByteBuffer.allocateDirect;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
+import static org.lmdbjava.ByteUnit.MEBIBYTES;
+import static org.lmdbjava.DbiFlags.MDB_CREATE;
+import static org.lmdbjava.DbiFlags.MDB_DUPFIXED;
+import static org.lmdbjava.DbiFlags.MDB_DUPSORT;
+import static org.lmdbjava.Env.create;
+import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
+import static org.lmdbjava.PutFlags.MDB_APPENDDUP;
+import static org.lmdbjava.PutFlags.MDB_MULTIPLE;
+import static org.lmdbjava.PutFlags.MDB_NODUPDATA;
+import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
+import static org.lmdbjava.SeekOp.MDB_FIRST;
+import static org.lmdbjava.SeekOp.MDB_GET_BOTH;
+import static org.lmdbjava.TestUtils.DB_1;
+import static org.lmdbjava.TestUtils.bb;
+
+import java.nio.ByteBuffer;
+import java.nio.file.Path;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.lmdbjava.Txn.NotReadyException;
+import org.lmdbjava.Txn.ReadOnlyRequiredException;
+
+/**
+ * Tests all the deprecated methods in {@link Cursor}. Essentially a duplicate of {@link
+ * CursorTest}. When all the deprecated methods are deleted we can delete this test class.
+ *
+ * @deprecated Tests all the deprecated methods in {@link Cursor}.
+ */
+@Deprecated
+public class CursorDeprecatedTest {
+
+  private TempDir tempDir;
+  private Env<ByteBuffer> env;
+
+  @BeforeEach
+  void beforeEach() {
+    tempDir = new TempDir();
+    Path file = tempDir.createTempFile();
+    env =
+        create(PROXY_OPTIMAL)
+            .setMapSize(MEBIBYTES.toBytes(1))
+            .setMaxReaders(1)
+            .setMaxDbs(1)
+            .open(file.toFile(), Env.Builder.POSIX_MODE_DEFAULT, MDB_NOSUBDIR);
+  }
+
+  @AfterEach
+  void afterEach() {
+    env.close();
+    tempDir.cleanup();
+  }
+
+  @Test
+  void count() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+    try (Txn<ByteBuffer> txn = env.txnWrite();
+        Cursor<ByteBuffer> c = db.openCursor(txn)) {
+      c.put(bb(1), bb(2), new PutFlags[] {MDB_APPENDDUP});
+      assertThat(c.count()).isEqualTo(1L);
+      c.put(bb(1), bb(4), new PutFlags[] {MDB_APPENDDUP});
+      c.put(bb(1), bb(6), new PutFlags[] {MDB_APPENDDUP});
+      assertThat(c.count()).isEqualTo(3L);
+      c.put(bb(2), bb(1), new PutFlags[] {MDB_APPENDDUP});
+      c.put(bb(2), bb(2), new PutFlags[] {MDB_APPENDDUP});
+      assertThat(c.count()).isEqualTo(2L);
+    }
+  }
+
+  @Test
+  void cursorCannotCloseIfTransactionCommitted() {
+    assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+              try (Txn<ByteBuffer> txn = env.txnWrite()) {
+                try (Cursor<ByteBuffer> c = db.openCursor(txn); ) {
+                  c.put(bb(1), bb(2), new PutFlags[] {MDB_APPENDDUP});
+                  assertThat(c.count()).isEqualTo(1L);
+                  c.put(bb(1), bb(4), new PutFlags[] {MDB_APPENDDUP});
+                  assertThat(c.count()).isEqualTo(2L);
+                  txn.commit();
+                }
+              }
+            })
+        .isInstanceOf(NotReadyException.class);
+  }
+
+  @Test
+  void cursorFirstLastNextPrev() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    try (Txn<ByteBuffer> txn = env.txnWrite();
+        Cursor<ByteBuffer> c = db.openCursor(txn)) {
+      c.put(bb(1), bb(2), new PutFlags[] {MDB_NOOVERWRITE});
+      c.put(bb(3), bb(4), new PutFlags[0]);
+      c.put(bb(5), bb(6), new PutFlags[0]);
+      c.put(bb(7), bb(8), new PutFlags[0]);
+
+      assertThat(c.first()).isTrue();
+      assertThat(c.key().getInt(0)).isEqualTo(1);
+      assertThat(c.val().getInt(0)).isEqualTo(2);
+
+      assertThat(c.last()).isTrue();
+      assertThat(c.key().getInt(0)).isEqualTo(7);
+      assertThat(c.val().getInt(0)).isEqualTo(8);
+
+      assertThat(c.prev()).isTrue();
+      assertThat(c.key().getInt(0)).isEqualTo(5);
+      assertThat(c.val().getInt(0)).isEqualTo(6);
+
+      assertThat(c.first()).isTrue();
+      assertThat(c.next()).isTrue();
+      assertThat(c.key().getInt(0)).isEqualTo(3);
+      assertThat(c.val().getInt(0)).isEqualTo(4);
+    }
+  }
+
+  @Test
+  void delete() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+    try (Txn<ByteBuffer> txn = env.txnWrite();
+        Cursor<ByteBuffer> c = db.openCursor(txn)) {
+      c.put(bb(1), bb(2), MDB_NOOVERWRITE);
+      c.put(bb(3), bb(4), new PutFlags[0]);
+      assertThat(c.seek(MDB_FIRST)).isTrue();
+      assertThat(c.key().getInt()).isEqualTo(1);
+      assertThat(c.val().getInt()).isEqualTo(2);
+      c.delete();
+      assertThat(c.seek(MDB_FIRST)).isTrue();
+      assertThat(c.key().getInt()).isEqualTo(3);
+      assertThat(c.val().getInt()).isEqualTo(4);
+      c.delete();
+      assertThat(c.seek(MDB_FIRST)).isFalse();
+    }
+  }
+
+  @Test
+  void getKeyVal() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+    try (Txn<ByteBuffer> txn = env.txnWrite();
+        Cursor<ByteBuffer> c = db.openCursor(txn)) {
+      c.put(bb(1), bb(2), new PutFlags[] {MDB_APPENDDUP});
+      c.put(bb(1), bb(4), new PutFlags[] {MDB_APPENDDUP});
+      c.put(bb(1), bb(6), new PutFlags[] {MDB_APPENDDUP});
+      c.put(bb(2), bb(1), new PutFlags[] {MDB_APPENDDUP});
+      c.put(bb(2), bb(2), new PutFlags[] {MDB_APPENDDUP});
+      c.put(bb(2), bb(3), new PutFlags[] {MDB_APPENDDUP});
+      c.put(bb(2), bb(4), new PutFlags[] {MDB_APPENDDUP});
+      assertThat(c.get(bb(1), bb(2), MDB_GET_BOTH)).isTrue();
+      assertThat(c.count()).isEqualTo(3L);
+      assertThat(c.get(bb(1), bb(3), MDB_GET_BOTH)).isFalse();
+      assertThat(c.get(bb(2), bb(1), MDB_GET_BOTH)).isTrue();
+      assertThat(c.count()).isEqualTo(4L);
+      assertThat(c.get(bb(2), bb(0), MDB_GET_BOTH)).isFalse();
+    }
+  }
+
+  @Test
+  void putMultiple() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT, MDB_DUPFIXED);
+    final int elemCount = 20;
+
+    final ByteBuffer values = allocateDirect(Integer.BYTES * elemCount);
+    for (int i = 1; i <= elemCount; i++) {
+      values.putInt(i);
+    }
+    values.flip();
+
+    final int key = 100;
+    final ByteBuffer k = bb(key);
+    try (Txn<ByteBuffer> txn = env.txnWrite();
+        Cursor<ByteBuffer> c = db.openCursor(txn)) {
+      c.putMultiple(k, values, elemCount, new PutFlags[] {MDB_MULTIPLE});
+      assertThat(c.count()).isEqualTo((long) elemCount);
+    }
+  }
+
+  @Test
+  void putMultipleWithoutMdbMultipleFlag() {
+    assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+              try (Txn<ByteBuffer> txn = env.txnWrite();
+                  Cursor<ByteBuffer> c = db.openCursor(txn)) {
+                c.putMultiple(bb(100), bb(1), 1, new PutFlags[0]);
+              }
+            })
+        .isInstanceOf(IllegalArgumentException.class);
+  }
+
+  @Test
+  void renewTxRw() {
+    assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+              try (Txn<ByteBuffer> txn = env.txnWrite()) {
+                assertThat(txn.isReadOnly()).isFalse();
+
+                try (Cursor<ByteBuffer> c = db.openCursor(txn)) {
+                  c.renew(txn);
+                }
+              }
+            })
+        .isInstanceOf(ReadOnlyRequiredException.class);
+  }
+
+  @Test
+  void repeatedCloseCausesNotError() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      final Cursor<ByteBuffer> c = db.openCursor(txn);
+      c.close();
+      c.close();
+    }
+  }
+
+  @Test
+  void reserve() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final ByteBuffer key = bb(5);
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      assertThat(db.get(txn, key)).isNull();
+      try (Cursor<ByteBuffer> c = db.openCursor(txn)) {
+        final ByteBuffer val = c.reserve(key, BYTES * 2, new PutFlags[0]);
+        assertThat(db.get(txn, key)).isNotNull();
+        val.putLong(MIN_VALUE).flip();
+      }
+      txn.commit();
+    }
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      final ByteBuffer val = db.get(txn, key);
+      assertThat(val.capacity()).isEqualTo(BYTES * 2);
+      assertThat(val.getLong()).isEqualTo(MIN_VALUE);
+    }
+  }
+
+  @Test
+  void returnValueForNoDupData() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+    try (Txn<ByteBuffer> txn = env.txnWrite();
+        Cursor<ByteBuffer> c = db.openCursor(txn)) {
+      // ok
+      assertThat(c.put(bb(5), bb(6), new PutFlags[] {MDB_NODUPDATA})).isTrue();
+      assertThat(c.put(bb(5), bb(7), new PutFlags[] {MDB_NODUPDATA})).isTrue();
+      assertThat(c.put(bb(5), bb(6), new PutFlags[] {MDB_NODUPDATA})).isFalse();
+    }
+  }
+
+  @Test
+  void returnValueForNoOverwrite() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    try (Txn<ByteBuffer> txn = env.txnWrite();
+        Cursor<ByteBuffer> c = db.openCursor(txn)) {
+      // ok
+      assertThat(c.put(bb(5), bb(6), new PutFlags[] {MDB_NOOVERWRITE})).isTrue();
+      // fails, but gets exist val
+      assertThat(c.put(bb(5), bb(8), new PutFlags[] {MDB_NOOVERWRITE})).isFalse();
+      assertThat(c.val().getInt(0)).isEqualTo(6);
+    }
+  }
+
+  @Test
+  void testCursorByteBufferDuplicate() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      try (Cursor<ByteBuffer> c = db.openCursor(txn)) {
+        c.put(bb(1), bb(2), new PutFlags[0]);
+        c.put(bb(3), bb(4), new PutFlags[0]);
+      }
+      txn.commit();
+    }
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      try (Cursor<ByteBuffer> c = db.openCursor(txn)) {
+        c.first();
+        final ByteBuffer key1 = c.key().duplicate();
+        final ByteBuffer val1 = c.val().duplicate();
+
+        c.last();
+        final ByteBuffer key2 = c.key().duplicate();
+        final ByteBuffer val2 = c.val().duplicate();
+
+        assertThat(key1.getInt(0)).isEqualTo(1);
+        assertThat(val1.getInt(0)).isEqualTo(2);
+
+        assertThat(key2.getInt(0)).isEqualTo(3);
+        assertThat(val2.getInt(0)).isEqualTo(4);
+      }
+    }
+  }
+}
diff --git a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
index 8c4868f0..66d534a5 100644
--- a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
@@ -16,16 +16,15 @@
 
 package org.lmdbjava;
 
-import static java.nio.ByteBuffer.allocateDirect;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.lmdbjava.Env.create;
 import static org.lmdbjava.TestUtils.DB_1;
 import static org.lmdbjava.TestUtils.bb;
+import static org.lmdbjava.TestUtils.bbNative;
+import static org.lmdbjava.TestUtils.parseInt;
+import static org.lmdbjava.TestUtils.parseLong;
 
-import java.io.File;
-import java.io.FileReader;
 import java.io.IOException;
-import java.io.Reader;
 import java.io.StringWriter;
 import java.io.UncheckedIOException;
 import java.io.Writer;
@@ -43,14 +42,10 @@ public final class CursorIterableRangeTest {
 
   private static final DbiFlagSet FLAGSET_DUPSORT =
       DbiFlagSet.of(DbiFlags.MDB_CREATE, DbiFlags.MDB_DUPSORT);
-  private static final DbiFlagSet FLAGSET_REVERSEKEY =
-      DbiFlagSet.of(DbiFlags.MDB_CREATE, DbiFlags.MDB_REVERSEKEY);
   private static final DbiFlagSet FLAGSET_INTEGERKEY =
       DbiFlagSet.of(DbiFlags.MDB_CREATE, DbiFlags.MDB_INTEGERKEY);
   private static final DbiFlagSet FLAGSET_INTEGERKEY_DUPSORT =
       DbiFlagSet.of(DbiFlags.MDB_CREATE, DbiFlags.MDB_INTEGERKEY, DbiFlags.MDB_DUPSORT);
-  private static final DbiFlagSet FLAGSET_REVERSE_INTEGERKEY =
-      DbiFlagSet.of(DbiFlags.MDB_CREATE, DbiFlags.MDB_INTEGERKEY, DbiFlags.MDB_REVERSEKEY);
 
   @ParameterizedTest(name = "{index} => {0}: ({1}, {2})")
   @CsvFileSource(resources = "/CursorIterableRangeTest/testSignedComparator.csv")
@@ -295,15 +290,15 @@ private ByteBuffer parseKey(final String key, final int keyLen, final ByteOrder
     if (key != null) {
       if (ByteOrder.nativeOrder().equals(byteOrder)) {
         if (keyLen == Integer.BYTES) {
-          return bbNativeInt(TestUtils.parseInt(key));
+          return bbNative(parseInt(key));
         } else {
-          return bbNativeLong(TestUtils.parseLong(key));
+          return bbNative(parseLong(key));
         }
       } else {
         if (keyLen == Integer.BYTES) {
-          return bb(TestUtils.parseInt(key));
+          return bb(parseInt(key));
         } else {
-          return bb(TestUtils.parseLong(key));
+          return bb(parseLong(key));
         }
       }
     }
@@ -357,12 +352,12 @@ private BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> createMultiIntegerDBPopulat
       try (Txn<ByteBuffer> txn = env.txnWrite()) {
         final Cursor<ByteBuffer> c = dbi.openCursor(txn);
         for (int i = 0; i < copies; i++) {
-          c.put(bbNativeInt(0), bb(1 + i));
-          c.put(bbNativeInt(2), bb(3 + i));
-          c.put(bbNativeInt(4), bb(5 + i));
-          c.put(bbNativeInt(6), bb(7 + i));
-          c.put(bbNativeInt(8), bb(9 + i));
-          c.put(bbNativeInt(-2), bb(-1 + i));
+          c.put(bbNative(0), bb(1 + i));
+          c.put(bbNative(2), bb(3 + i));
+          c.put(bbNative(4), bb(5 + i));
+          c.put(bbNative(6), bb(7 + i));
+          c.put(bbNative(8), bb(9 + i));
+          c.put(bbNative(-2), bb(-1 + i));
         }
         txn.commit();
       }
@@ -375,12 +370,12 @@ private BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> createMultiLongDBPopulator(
       try (Txn<ByteBuffer> txn = env.txnWrite()) {
         final Cursor<ByteBuffer> c = dbi.openCursor(txn);
         for (int i = 0; i < copies; i++) {
-          c.put(bbNativeLong(0), bb(1 + i));
-          c.put(bbNativeLong(2), bb(3 + i));
-          c.put(bbNativeLong(4), bb(5 + i));
-          c.put(bbNativeLong(6), bb(7 + i));
-          c.put(bbNativeLong(8), bb(9 + i));
-          c.put(bbNativeLong(-2), bb(-1 + i));
+          c.put(bbNative(0L), bb(1 + i));
+          c.put(bbNative(2L), bb(3 + i));
+          c.put(bbNative(4L), bb(5 + i));
+          c.put(bbNative(6L), bb(7 + i));
+          c.put(bbNative(8L), bb(9 + i));
+          c.put(bbNative(-2L), bb(-1 + i));
         }
         txn.commit();
       }
@@ -391,11 +386,11 @@ private BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> createIntegerDBPopulator()
     return (env, dbi) -> {
       try (Txn<ByteBuffer> txn = env.txnWrite()) {
         final Cursor<ByteBuffer> c = dbi.openCursor(txn);
-        c.put(bbNativeInt(0), bb(1));
-        c.put(bbNativeInt(1000), bb(2));
-        c.put(bbNativeInt(1000000), bb(3));
-        c.put(bbNativeInt(-1000000), bb(4));
-        c.put(bbNativeInt(-1000), bb(5));
+        c.put(bbNative(0), bb(1));
+        c.put(bbNative(1000), bb(2));
+        c.put(bbNative(1000000), bb(3));
+        c.put(bbNative(-1000000), bb(4));
+        c.put(bbNative(-1000), bb(5));
         txn.commit();
       }
     };
@@ -405,53 +400,13 @@ private BiConsumer<Env<ByteBuffer>, Dbi<ByteBuffer>> createLongDBPopulator() {
     return (env, dbi) -> {
       try (Txn<ByteBuffer> txn = env.txnWrite()) {
         final Cursor<ByteBuffer> c = dbi.openCursor(txn);
-        c.put(bbNativeLong(0), bb(1));
-        c.put(bbNativeLong(1000), bb(2));
-        c.put(bbNativeLong(1000000), bb(3));
-        c.put(bbNativeLong(-1000000), bb(4));
-        c.put(bbNativeLong(-1000), bb(5));
+        c.put(bbNative(0L), bb(1));
+        c.put(bbNative(1000L), bb(2));
+        c.put(bbNative(1000000L), bb(3));
+        c.put(bbNative(-1000000L), bb(4));
+        c.put(bbNative(-1000L), bb(5));
         txn.commit();
       }
     };
   }
-
-  private void populateDatabase(
-      final Env<ByteBuffer> env, final Dbi<ByteBuffer> dbi, final int copies) {
-    try (Txn<ByteBuffer> txn = env.txnWrite()) {
-      final Cursor<ByteBuffer> c = dbi.openCursor(txn);
-      for (int i = 0; i < copies; i++) {
-        c.put(bb(0), bb(1 + i));
-        c.put(bb(2), bb(3 + i));
-        c.put(bb(4), bb(5 + i));
-        c.put(bb(6), bb(7 + i));
-        c.put(bb(8), bb(9 + i));
-        c.put(bb(-2), bb(-1 + i));
-      }
-      txn.commit();
-    }
-  }
-
-  private String readFile(final File file) throws IOException {
-    final StringBuilder result = new StringBuilder();
-    try (final Reader reader = new FileReader(file)) {
-      final char[] cbuf = new char[4096];
-      int nread;
-      while ((nread = reader.read(cbuf, 0, cbuf.length)) != -1) {
-        result.append(cbuf, 0, nread);
-      }
-    }
-    return result.toString();
-  }
-
-  static ByteBuffer bbNativeInt(final int value) {
-    final ByteBuffer bb = allocateDirect(Integer.BYTES).order(ByteOrder.nativeOrder());
-    bb.putInt(value).flip();
-    return bb;
-  }
-
-  static ByteBuffer bbNativeLong(final long value) {
-    final ByteBuffer bb = allocateDirect(Long.BYTES).order(ByteOrder.nativeOrder());
-    bb.putLong(value).flip();
-    return bb;
-  }
 }
diff --git a/src/test/java/org/lmdbjava/CursorParamTest.java b/src/test/java/org/lmdbjava/CursorParamTest.java
index cc2fdaf3..28f60419 100644
--- a/src/test/java/org/lmdbjava/CursorParamTest.java
+++ b/src/test/java/org/lmdbjava/CursorParamTest.java
@@ -94,7 +94,12 @@ protected AbstractBufferRunner(final BufferProxy<T> proxy) {
     public final void execute(final Path tmp) {
       try (Env<T> env = env(tmp)) {
         assertThat(env.getDbiNames()).isEmpty();
-        final Dbi<T> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
+        final Dbi<T> db =
+            env.createDbi()
+                .setDbName(DB_1)
+                .withDefaultComparator()
+                .setDbiFlags(MDB_CREATE, MDB_DUPSORT)
+                .open();
         assertThat(env.getDbiNames().get(0)).isEqualTo(DB_1.getBytes(UTF_8));
         try (Txn<T> txn = env.txnWrite();
             Cursor<T> c = db.openCursor(txn)) {
diff --git a/src/test/java/org/lmdbjava/CursorTest.java b/src/test/java/org/lmdbjava/CursorTest.java
index 01af8e10..97f9d706 100644
--- a/src/test/java/org/lmdbjava/CursorTest.java
+++ b/src/test/java/org/lmdbjava/CursorTest.java
@@ -78,7 +78,12 @@ void afterEach() {
   void closedCursorRejectsSubsequentGets() {
     assertThatThrownBy(
             () -> {
-              final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+              final Dbi<ByteBuffer> db =
+                  env.createDbi()
+                      .setDbName(DB_1)
+                      .withDefaultComparator()
+                      .setDbiFlags(MDB_CREATE)
+                      .open();
               try (Txn<ByteBuffer> txn = env.txnWrite()) {
                 final Cursor<ByteBuffer> c = db.openCursor(txn);
                 c.close();
@@ -175,7 +180,12 @@ void closedEnvRejectsDeleteCall() {
 
   @Test
   void count() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
+    final Dbi<ByteBuffer> db =
+        env.createDbi()
+            .setDbName(DB_1)
+            .withDefaultComparator()
+            .setDbiFlags(MDB_CREATE, MDB_DUPSORT)
+            .open();
     try (Txn<ByteBuffer> txn = env.txnWrite();
         Cursor<ByteBuffer> c = db.openCursor(txn)) {
       c.put(bb(1), bb(2), MDB_APPENDDUP);
@@ -193,7 +203,12 @@ void count() {
   void cursorCannotCloseIfTransactionCommitted() {
     assertThatThrownBy(
             () -> {
-              final Dbi<ByteBuffer> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
+              final Dbi<ByteBuffer> db =
+                  env.createDbi()
+                      .setDbName(DB_1)
+                      .withDefaultComparator()
+                      .setDbiFlags(MDB_CREATE, MDB_DUPSORT)
+                      .open();
               try (Txn<ByteBuffer> txn = env.txnWrite()) {
                 try (Cursor<ByteBuffer> c = db.openCursor(txn); ) {
                   c.put(bb(1), bb(2), MDB_APPENDDUP);
@@ -209,7 +224,8 @@ void cursorCannotCloseIfTransactionCommitted() {
 
   @Test
   void cursorFirstLastNextPrev() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
     try (Txn<ByteBuffer> txn = env.txnWrite();
         Cursor<ByteBuffer> c = db.openCursor(txn)) {
       c.put(bb(1), bb(2), MDB_NOOVERWRITE);
@@ -238,7 +254,12 @@ void cursorFirstLastNextPrev() {
 
   @Test
   void delete() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
+    final Dbi<ByteBuffer> db =
+        env.createDbi()
+            .setDbName(DB_1)
+            .withDefaultComparator()
+            .setDbiFlags(MDB_CREATE, MDB_DUPSORT)
+            .open();
     try (Txn<ByteBuffer> txn = env.txnWrite();
         Cursor<ByteBuffer> c = db.openCursor(txn)) {
       c.put(bb(1), bb(2), MDB_NOOVERWRITE);
@@ -257,7 +278,12 @@ void delete() {
 
   @Test
   void getKeyVal() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
+    final Dbi<ByteBuffer> db =
+        env.createDbi()
+            .setDbName(DB_1)
+            .withDefaultComparator()
+            .setDbiFlags(MDB_CREATE, MDB_DUPSORT)
+            .open();
     try (Txn<ByteBuffer> txn = env.txnWrite();
         Cursor<ByteBuffer> c = db.openCursor(txn)) {
       c.put(bb(1), bb(2), MDB_APPENDDUP);
@@ -279,7 +305,11 @@ void getKeyVal() {
   @Test
   void putMultiple() {
     final Dbi<ByteBuffer> db =
-        env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT, MDB_DUPFIXED));
+        env.createDbi()
+            .setDbName(DB_1)
+            .withDefaultComparator()
+            .setDbiFlags(MDB_CREATE, MDB_DUPSORT, MDB_DUPFIXED)
+            .open();
     final int elemCount = 20;
 
     final ByteBuffer values = allocateDirect(Integer.BYTES * elemCount);
@@ -301,7 +331,12 @@ void putMultiple() {
   void putMultipleWithoutMdbMultipleFlag() {
     assertThatThrownBy(
             () -> {
-              final Dbi<ByteBuffer> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
+              final Dbi<ByteBuffer> db =
+                  env.createDbi()
+                      .setDbName(DB_1)
+                      .withDefaultComparator()
+                      .setDbiFlags(MDB_CREATE, MDB_DUPSORT)
+                      .open();
               try (Txn<ByteBuffer> txn = env.txnWrite();
                   Cursor<ByteBuffer> c = db.openCursor(txn)) {
                 c.putMultiple(bb(100), bb(1), 1);
@@ -312,7 +347,8 @@ void putMultipleWithoutMdbMultipleFlag() {
 
   @Test
   void renewTxRo() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
 
     final Cursor<ByteBuffer> c;
     try (Txn<ByteBuffer> txn = env.txnRead()) {
@@ -332,7 +368,12 @@ void renewTxRo() {
   void renewTxRw() {
     assertThatThrownBy(
             () -> {
-              final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+              final Dbi<ByteBuffer> db =
+                  env.createDbi()
+                      .setDbName(DB_1)
+                      .withDefaultComparator()
+                      .setDbiFlags(MDB_CREATE)
+                      .open();
               try (Txn<ByteBuffer> txn = env.txnWrite()) {
                 assertThat(txn.isReadOnly()).isFalse();
 
@@ -346,7 +387,12 @@ void renewTxRw() {
 
   @Test
   void repeatedCloseCausesNotError() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
+    final Dbi<ByteBuffer> db =
+        env.createDbi()
+            .setDbName(DB_1)
+            .withDefaultComparator()
+            .setDbiFlags(MDB_CREATE, MDB_DUPSORT)
+            .open();
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       final Cursor<ByteBuffer> c = db.openCursor(txn);
       c.close();
@@ -356,7 +402,8 @@ void repeatedCloseCausesNotError() {
 
   @Test
   void reserve() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
     final ByteBuffer key = bb(5);
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       assertThat(db.get(txn, key)).isNull();
@@ -376,7 +423,12 @@ void reserve() {
 
   @Test
   void returnValueForNoDupData() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
+    final Dbi<ByteBuffer> db =
+        env.createDbi()
+            .setDbName(DB_1)
+            .withDefaultComparator()
+            .setDbiFlags(MDB_CREATE, MDB_DUPSORT)
+            .open();
     try (Txn<ByteBuffer> txn = env.txnWrite();
         Cursor<ByteBuffer> c = db.openCursor(txn)) {
       // ok
@@ -388,7 +440,8 @@ void returnValueForNoDupData() {
 
   @Test
   void returnValueForNoOverwrite() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
     try (Txn<ByteBuffer> txn = env.txnWrite();
         Cursor<ByteBuffer> c = db.openCursor(txn)) {
       // ok
@@ -401,7 +454,8 @@ void returnValueForNoOverwrite() {
 
   @Test
   void testCursorByteBufferDuplicate() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       try (Cursor<ByteBuffer> c = db.openCursor(txn)) {
         c.put(bb(1), bb(2));
@@ -431,7 +485,8 @@ void testCursorByteBufferDuplicate() {
   private void doEnvClosedTest(
       final Consumer<Cursor<ByteBuffer>> workBeforeEnvClosed,
       final Consumer<Cursor<ByteBuffer>> workAfterEnvClose) {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
 
     db.put(bb(1), bb(10));
     db.put(bb(2), bb(20));
diff --git a/src/test/java/org/lmdbjava/DbiDeprecatedTest.java b/src/test/java/org/lmdbjava/DbiDeprecatedTest.java
new file mode 100644
index 00000000..7156b963
--- /dev/null
+++ b/src/test/java/org/lmdbjava/DbiDeprecatedTest.java
@@ -0,0 +1,675 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import static java.lang.Long.MAX_VALUE;
+import static java.lang.System.getProperty;
+import static java.nio.ByteBuffer.allocateDirect;
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static java.util.Collections.nCopies;
+import static java.util.concurrent.TimeUnit.SECONDS;
+import static java.util.stream.Collectors.toList;
+import static java.util.stream.IntStream.range;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
+import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
+import static org.lmdbjava.ByteUnit.MEBIBYTES;
+import static org.lmdbjava.DbiFlags.*;
+import static org.lmdbjava.Env.create;
+import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
+import static org.lmdbjava.GetOp.MDB_SET_KEY;
+import static org.lmdbjava.KeyRange.atMost;
+import static org.lmdbjava.PutFlags.MDB_NODUPDATA;
+import static org.lmdbjava.PutFlags.MDB_NOOVERWRITE;
+import static org.lmdbjava.TestUtils.*;
+
+import java.nio.ByteBuffer;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.BiConsumer;
+import java.util.function.Function;
+import java.util.function.IntFunction;
+import java.util.function.ToIntFunction;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.lmdbjava.CursorIterable.KeyVal;
+import org.lmdbjava.Dbi.DbFullException;
+import org.lmdbjava.Env.AlreadyClosedException;
+import org.lmdbjava.Env.MapFullException;
+import org.lmdbjava.LmdbNativeException.ConstantDerivedException;
+
+/**
+ * Tests all the deprecated methods in {@link Dbi}. Essentially a duplicate of {@link DbiTest}. When
+ * all the deprecated methods are deleted we can delete this test class.
+ *
+ * @deprecated Tests all the deprecated methods in {@link Dbi}.
+ */
+@Deprecated
+public class DbiDeprecatedTest {
+
+  private TempDir tempDir;
+  private Env<ByteBuffer> env;
+  private TempDir tempDirBa;
+  private Env<byte[]> envBa;
+
+  @BeforeEach
+  void beforeEach() {
+    tempDir = new TempDir();
+    final Path file = tempDir.createTempFile();
+    env =
+        create()
+            .setMapSize(MEBIBYTES.toBytes(64))
+            .setMaxReaders(2)
+            .setMaxDbs(2)
+            .open(file.toFile(), MDB_NOSUBDIR);
+    tempDirBa = new TempDir();
+    final Path fileBa = tempDirBa.createTempFile();
+    envBa =
+        create(PROXY_BA)
+            .setMapSize(MEBIBYTES.toBytes(64))
+            .setMaxReaders(2)
+            .setMaxDbs(2)
+            .open(fileBa.toFile(), MDB_NOSUBDIR);
+  }
+
+  @AfterEach
+  void afterEach() {
+    env.close();
+    envBa.close();
+    tempDir.cleanup();
+    tempDirBa.cleanup();
+  }
+
+  @Test
+  void close() {
+    assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+              db.put(bb(1), bb(42));
+              db.close();
+              db.put(bb(2), bb(42)); // error
+            })
+        .isInstanceOf(ConstantDerivedException.class);
+  }
+
+  @Test
+  void customComparator() {
+    final Comparator<ByteBuffer> reverseOrder =
+        (o1, o2) -> {
+          final int lexical = PROXY_OPTIMAL.getComparator().compare(o1, o2);
+          if (lexical == 0) {
+            return 0;
+          }
+          return lexical * -1;
+        };
+    doCustomComparator(env, reverseOrder, TestUtils::bb, ByteBuffer::getInt);
+  }
+
+  @Test
+  void customComparatorByteArray() {
+    final Comparator<byte[]> reverseOrder =
+        (o1, o2) -> {
+          final int lexical = PROXY_BA.getComparator().compare(o1, o2);
+          if (lexical == 0) {
+            return 0;
+          }
+          return lexical * -1;
+        };
+    doCustomComparator(envBa, reverseOrder, TestUtils::ba, TestUtils::fromBa);
+  }
+
+  private <T> void doCustomComparator(
+      Env<T> env,
+      Comparator<T> comparator,
+      IntFunction<T> serializer,
+      ToIntFunction<T> deserializer) {
+    final Dbi<T> db = env.openDbi(DB_1, comparator, true, MDB_CREATE);
+    try (Txn<T> txn = env.txnWrite()) {
+      assertThat(db.put(txn, serializer.apply(2), serializer.apply(3))).isTrue();
+      assertThat(db.put(txn, serializer.apply(4), serializer.apply(6))).isTrue();
+      assertThat(db.put(txn, serializer.apply(6), serializer.apply(7))).isTrue();
+      assertThat(db.put(txn, serializer.apply(8), serializer.apply(7))).isTrue();
+      txn.commit();
+    }
+    try (Txn<T> txn = env.txnRead();
+        CursorIterable<T> ci = db.iterate(txn, atMost(serializer.apply(4)))) {
+      final Iterator<KeyVal<T>> iter = ci.iterator();
+      assertThat(deserializer.applyAsInt(iter.next().key())).isEqualTo(8);
+      assertThat(deserializer.applyAsInt(iter.next().key())).isEqualTo(6);
+      assertThat(deserializer.applyAsInt(iter.next().key())).isEqualTo(4);
+    }
+  }
+
+  @Test
+  void dbOpenMaxDatabases() {
+    assertThatThrownBy(
+            () -> {
+              env.openDbi("db1 is OK", MDB_CREATE);
+              env.openDbi("db2 is OK", MDB_CREATE);
+              env.openDbi("db3 fails", MDB_CREATE);
+            })
+        .isInstanceOf(DbFullException.class);
+  }
+
+  @Test
+  void dbiWithComparatorThreadSafety() {
+    doDbiWithComparatorThreadSafety(
+        env, PROXY_OPTIMAL::getComparator, TestUtils::bb, ByteBuffer::getInt);
+  }
+
+  @Test
+  void dbiWithComparatorThreadSafetyByteArray() {
+    doDbiWithComparatorThreadSafety(
+        envBa, PROXY_BA::getComparator, TestUtils::ba, TestUtils::fromBa);
+  }
+
+  private <T> void doDbiWithComparatorThreadSafety(
+      Env<T> env,
+      Function<DbiFlagSet, Comparator<T>> comparator,
+      IntFunction<T> serializer,
+      ToIntFunction<T> deserializer) {
+    final DbiFlags[] flags = new DbiFlags[] {MDB_CREATE, MDB_INTEGERKEY};
+    final Comparator<T> c = comparator.apply(DbiFlagSet.of(flags));
+    final Dbi<T> db = env.openDbi(DB_1, c, true, flags);
+
+    final List<Integer> keys = range(0, 1_000).boxed().collect(toList());
+
+    final ExecutorService pool = Executors.newCachedThreadPool();
+    final AtomicBoolean proceed = new AtomicBoolean(true);
+    final Future<?> reader =
+        pool.submit(
+            () -> {
+              while (proceed.get()) {
+                try (Txn<T> txn = env.txnRead()) {
+                  db.get(txn, serializer.apply(50));
+                }
+              }
+            });
+
+    for (final Integer key : keys) {
+      try (Txn<T> txn = env.txnWrite()) {
+        db.put(txn, serializer.apply(key), serializer.apply(3));
+        txn.commit();
+      }
+    }
+
+    try (Txn<T> txn = env.txnRead();
+        CursorIterable<T> ci = db.iterate(txn)) {
+      final Iterator<KeyVal<T>> iter = ci.iterator();
+      final List<Integer> result = new ArrayList<>();
+      while (iter.hasNext()) {
+        result.add(deserializer.applyAsInt(iter.next().key()));
+      }
+
+      assertThat(result).contains(keys.toArray(new Integer[0]));
+    }
+
+    proceed.set(false);
+    try {
+      reader.get(1, SECONDS);
+      pool.shutdown();
+      pool.awaitTermination(1, SECONDS);
+    } catch (ExecutionException | InterruptedException | TimeoutException e) {
+      throw new IllegalStateException(e);
+    }
+  }
+
+  @Test
+  void drop() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      db.put(txn, bb(1), bb(42));
+      db.put(txn, bb(2), bb(42));
+      assertThat(db.get(txn, bb(1))).isNotNull();
+      assertThat(db.get(txn, bb(2))).isNotNull();
+      db.drop(txn);
+      assertThat(db.get(txn, bb(1))).isNull(); // data gone
+      assertThat(db.get(txn, bb(2))).isNull();
+      db.put(txn, bb(1), bb(42)); // ensure DB still works
+      db.put(txn, bb(2), bb(42));
+      assertThat(db.get(txn, bb(1))).isNotNull();
+      assertThat(db.get(txn, bb(2))).isNotNull();
+    }
+  }
+
+  @Test
+  void dropAndDelete() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> nameDb = env.openDbi((byte[]) null);
+    final byte[] dbNameBytes = DB_1.getBytes(UTF_8);
+    final ByteBuffer dbNameBuffer = allocateDirect(dbNameBytes.length);
+    dbNameBuffer.put(dbNameBytes).flip();
+
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      assertThat(nameDb.get(txn, dbNameBuffer)).isNotNull();
+      db.drop(txn, true);
+      assertThat(nameDb.get(txn, dbNameBuffer)).isNull();
+      txn.commit();
+    }
+  }
+
+  @Test
+  void dropAndDeleteAnonymousDb() {
+    env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> nameDb = env.openDbi((byte[]) null);
+    final byte[] dbNameBytes = DB_1.getBytes(UTF_8);
+    final ByteBuffer dbNameBuffer = allocateDirect(dbNameBytes.length);
+    dbNameBuffer.put(dbNameBytes).flip();
+
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      assertThat(nameDb.get(txn, dbNameBuffer)).isNotNull();
+      nameDb.drop(txn, true);
+      assertThat(nameDb.get(txn, dbNameBuffer)).isNull();
+      txn.commit();
+    }
+
+    nameDb.close(); // explicit close after drop is OK
+  }
+
+  @Test
+  void getName() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    assertThat(db.getName()).isEqualTo(DB_1.getBytes(UTF_8));
+  }
+
+  @Test
+  void getNamesWhenDbisPresent() {
+    final byte[] dbHello = new byte[] {'h', 'e', 'l', 'l', 'o'};
+    final byte[] dbWorld = new byte[] {'w', 'o', 'r', 'l', 'd'};
+    env.openDbi(dbHello, MDB_CREATE);
+    env.openDbi(dbWorld, MDB_CREATE);
+    final List<byte[]> dbiNames = env.getDbiNames();
+    assertThat(dbiNames).hasSize(2);
+    assertThat(dbiNames.get(0)).isEqualTo(dbHello);
+    assertThat(dbiNames.get(1)).isEqualTo(dbWorld);
+  }
+
+  @Test
+  void getNamesWhenEmpty() {
+    final List<byte[]> dbiNames = env.getDbiNames();
+    assertThat(dbiNames).isEmpty();
+  }
+
+  @Test
+  void listsFlags() {
+    final Dbi<ByteBuffer> dbi = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT, MDB_REVERSEKEY);
+
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      final List<DbiFlags> flags = dbi.listFlags(txn);
+      assertThat(flags).containsExactlyInAnyOrder(MDB_DUPSORT, MDB_REVERSEKEY);
+    }
+  }
+
+  @Test
+  void putAbortGet() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      db.put(txn, bb(5), bb(5));
+      txn.abort();
+    }
+
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      assertThat(db.get(txn, bb(5))).isNull();
+    }
+  }
+
+  @Test
+  void putAndGetAndDeleteWithInternalTx() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+
+    db.put(bb(5), bb(5));
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      final ByteBuffer found = db.get(txn, bb(5));
+      assertThat(found).isNotNull();
+      assertThat(txn.val().getInt()).isEqualTo(5);
+    }
+    assertThat(db.delete(bb(5))).isTrue();
+    assertThat(db.delete(bb(5))).isFalse();
+
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      assertThat(db.get(txn, bb(5))).isNull();
+    }
+  }
+
+  @Test
+  void putCommitGet() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      db.put(txn, bb(5), bb(5));
+      txn.commit();
+    }
+
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      final ByteBuffer found = db.get(txn, bb(5));
+      assertThat(found).isNotNull();
+      assertThat(txn.val().getInt()).isEqualTo(5);
+    }
+  }
+
+  @Test
+  void putCommitGetByteArray() {
+    final Path file = tempDir.createTempFile();
+    try (Env<byte[]> envBa =
+        create(PROXY_BA)
+            .setMapSize(MEBIBYTES.toBytes(64))
+            .setMaxReaders(1)
+            .setMaxDbs(2)
+            .open(file.toFile(), MDB_NOSUBDIR)) {
+      final Dbi<byte[]> db = envBa.openDbi(DB_1, MDB_CREATE);
+      try (Txn<byte[]> txn = envBa.txnWrite()) {
+        db.put(txn, ba(5), ba(5));
+        txn.commit();
+      }
+      try (Txn<byte[]> txn = envBa.txnWrite()) {
+        final byte[] found = db.get(txn, ba(5));
+        assertThat(found).isNotNull();
+        assertThat(fromBa(txn.val())).isEqualTo(5);
+      }
+    }
+  }
+
+  @Test
+  void putDelete() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      db.put(txn, bb(5), bb(5));
+      assertThat(db.delete(txn, bb(5))).isTrue();
+
+      assertThat(db.get(txn, bb(5))).isNull();
+      txn.abort();
+    }
+  }
+
+  @Test
+  void putDuplicateDelete() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      db.put(txn, bb(5), bb(5));
+      db.put(txn, bb(5), bb(6));
+      db.put(txn, bb(5), bb(7));
+      assertThat(db.delete(txn, bb(5), bb(6))).isTrue();
+      assertThat(db.delete(txn, bb(5), bb(6))).isFalse();
+      assertThat(db.delete(txn, bb(5), bb(5))).isTrue();
+      assertThat(db.delete(txn, bb(5), bb(5))).isFalse();
+
+      try (Cursor<ByteBuffer> cursor = db.openCursor(txn)) {
+        final ByteBuffer key = bb(5);
+        cursor.get(key, MDB_SET_KEY);
+        assertThat(cursor.count()).isEqualTo(1L);
+      }
+      txn.abort();
+    }
+  }
+
+  @Test
+  void putReserve() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+
+    final ByteBuffer key = bb(5);
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      assertThat(db.get(txn, key)).isNull();
+      final ByteBuffer val = db.reserve(txn, key, 32, MDB_NOOVERWRITE);
+      val.putLong(MAX_VALUE);
+      assertThat(db.get(txn, key)).isNotNull();
+      txn.commit();
+    }
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      final ByteBuffer val = db.get(txn, key);
+      assertThat(val).isNotNull();
+      assertThat(val.capacity()).isEqualTo(32);
+      assertThat(val.getLong()).isEqualTo(MAX_VALUE);
+      assertThat(val.getLong(8)).isEqualTo(0L);
+    }
+  }
+
+  @Test
+  void putZeroByteValueForNonMdbDupSortDatabase() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      final ByteBuffer val = allocateDirect(0);
+      db.put(txn, bb(5), val);
+      txn.commit();
+    }
+
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      final ByteBuffer found = db.get(txn, bb(5));
+      assertThat(found).isNotNull();
+      assertThat(txn.val().capacity()).isEqualTo(0);
+    }
+  }
+
+  @Test
+  void returnValueForNoDupData() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      // ok
+      assertThat(db.put(txn, bb(5), bb(6), MDB_NODUPDATA)).isTrue();
+      assertThat(db.put(txn, bb(5), bb(7), MDB_NODUPDATA)).isTrue();
+      assertThat(db.put(txn, bb(5), bb(6), MDB_NODUPDATA)).isFalse();
+    }
+  }
+
+  @Test
+  void returnValueForNoOverwrite() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+      // ok
+      assertThat(db.put(txn, bb(5), bb(6), MDB_NOOVERWRITE)).isTrue();
+      // fails, but gets exist val
+      assertThat(db.put(txn, bb(5), bb(8), MDB_NOOVERWRITE)).isFalse();
+      assertThat(txn.val().getInt(0)).isEqualTo(6);
+    }
+  }
+
+  @Test
+  void stats() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    db.put(bb(1), bb(42));
+    db.put(bb(2), bb(42));
+    db.put(bb(3), bb(42));
+    final Stat stat;
+    try (Txn<ByteBuffer> txn = env.txnRead()) {
+      stat = db.stat(txn);
+    }
+    assertThat(stat).isNotNull();
+    assertThat(stat.branchPages).isEqualTo(0L);
+    assertThat(stat.depth).isEqualTo(1);
+    assertThat(stat.entries).isEqualTo(3L);
+    assertThat(stat.leafPages).isEqualTo(1L);
+    assertThat(stat.overflowPages).isEqualTo(0L);
+    assertThat(stat.pageSize % 4_096).isEqualTo(0);
+  }
+
+  @Test
+  void testMapFullException() {
+    assertThatThrownBy(
+            () -> {
+              final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+              try (Txn<ByteBuffer> txn = env.txnWrite()) {
+                final ByteBuffer v;
+                try {
+                  v = allocateDirect(1_024 * 1_024 * 1_024);
+                } catch (final OutOfMemoryError e) {
+                  // Travis CI OS X build cannot allocate this much memory, so assume OK
+                  throw new MapFullException();
+                }
+                db.put(txn, bb(1), v);
+              }
+            })
+        .isInstanceOf(MapFullException.class);
+  }
+
+  @Test
+  void testParallelWritesStress() {
+    if (getProperty("os.name").startsWith("Windows")) {
+      return; // Windows VMs run this test too slowly
+    }
+
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+
+    // Travis CI has 1.5 cores for legacy builds
+    nCopies(2, null).parallelStream()
+        .forEach(
+            ignored -> {
+              for (int i = 0; i < 15_000; i++) {
+                db.put(bb(i), bb(i));
+              }
+            });
+  }
+
+  @Test
+  void closedEnvRejectsOpenCall() {
+    assertThatThrownBy(
+            () -> {
+              env.close();
+              env.openDbi(DB_1, MDB_CREATE);
+            })
+        .isInstanceOf(AlreadyClosedException.class);
+  }
+
+  @Test
+  void closedEnvRejectsCloseCall() {
+    assertThatThrownBy(
+            () -> {
+              doEnvClosedTest(null, (db, txn) -> db.close());
+            })
+        .isInstanceOf(AlreadyClosedException.class);
+  }
+
+  @Test
+  void closedEnvRejectsGetCall() {
+    assertThatThrownBy(
+            () -> {
+              doEnvClosedTest(
+                  (db, txn) -> {
+                    final ByteBuffer valBuf = db.get(txn, bb(1));
+                    assertThat(valBuf.getInt()).isEqualTo(10);
+                  },
+                  (db, txn) -> db.get(txn, bb(2)));
+            })
+        .isInstanceOf(AlreadyClosedException.class);
+  }
+
+  @Test
+  void closedEnvRejectsPutCall() {
+    assertThatThrownBy(
+            () -> {
+              doEnvClosedTest(null, (db, txn) -> db.put(bb(5), bb(50)));
+            })
+        .isInstanceOf(AlreadyClosedException.class);
+  }
+
+  @Test
+  void closedEnvRejectsPutWithTxnCall() {
+    assertThatThrownBy(
+            () -> {
+              doEnvClosedTest(
+                  null,
+                  (db, txn) -> {
+                    db.put(txn, bb(5), bb(50));
+                  });
+            })
+        .isInstanceOf(AlreadyClosedException.class);
+  }
+
+  @Test
+  void closedEnvRejectsIterateCall() {
+    assertThatThrownBy(
+            () -> {
+              doEnvClosedTest(null, Dbi::iterate);
+            })
+        .isInstanceOf(AlreadyClosedException.class);
+  }
+
+  @Test
+  void closedEnvRejectsDropCall() {
+    assertThatThrownBy(
+            () -> {
+              doEnvClosedTest(null, Dbi::drop);
+            })
+        .isInstanceOf(AlreadyClosedException.class);
+  }
+
+  @Test
+  void closedEnvRejectsDropAndDeleteCall() {
+    assertThatThrownBy(
+            () -> {
+              doEnvClosedTest(null, (db, txn) -> db.drop(txn, true));
+            })
+        .isInstanceOf(AlreadyClosedException.class);
+  }
+
+  @Test
+  void closedEnvRejectsOpenCursorCall() {
+    assertThatThrownBy(
+            () -> {
+              doEnvClosedTest(null, Dbi::openCursor);
+            })
+        .isInstanceOf(AlreadyClosedException.class);
+  }
+
+  @Test
+  void closedEnvRejectsReserveCall() {
+    assertThatThrownBy(
+            () -> {
+              doEnvClosedTest(null, (db, txn) -> db.reserve(txn, bb(1), 32, MDB_NOOVERWRITE));
+            })
+        .isInstanceOf(AlreadyClosedException.class);
+  }
+
+  @Test
+  void closedEnvRejectsStatCall() {
+    assertThatThrownBy(
+            () -> {
+              doEnvClosedTest(null, Dbi::stat);
+            })
+        .isInstanceOf(AlreadyClosedException.class);
+  }
+
+  private void doEnvClosedTest(
+      final BiConsumer<Dbi<ByteBuffer>, Txn<ByteBuffer>> workBeforeEnvClosed,
+      final BiConsumer<Dbi<ByteBuffer>, Txn<ByteBuffer>> workAfterEnvClose) {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+
+    db.put(bb(1), bb(10));
+    db.put(bb(2), bb(20));
+    db.put(bb(2), bb(30));
+    db.put(bb(4), bb(40));
+
+    try (Txn<ByteBuffer> txn = env.txnWrite()) {
+
+      if (workBeforeEnvClosed != null) {
+        workBeforeEnvClosed.accept(db, txn);
+      }
+
+      env.close();
+
+      if (workAfterEnvClose != null) {
+        workAfterEnvClose.accept(db, txn);
+      }
+    }
+  }
+}
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 553ec02c..9f66e5bb 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -177,9 +177,21 @@ private <T> void doCustomComparator(
   void dbOpenMaxDatabases() {
     assertThatThrownBy(
             () -> {
-              env.openDbi("db1 is OK", MDB_CREATE);
-              env.openDbi("db2 is OK", MDB_CREATE);
-              env.openDbi("db3 fails", MDB_CREATE);
+              env.createDbi()
+                  .setDbName("db1 is OK")
+                  .withDefaultComparator()
+                  .setDbiFlags(MDB_CREATE)
+                  .open();
+              env.createDbi()
+                  .setDbName("db2 is OK")
+                  .withDefaultComparator()
+                  .setDbiFlags(MDB_CREATE)
+                  .open();
+              env.createDbi()
+                  .setDbName("db3 fails")
+                  .withDefaultComparator()
+                  .setDbiFlags(MDB_CREATE)
+                  .open();
             })
         .isInstanceOf(DbFullException.class);
   }
@@ -256,7 +268,8 @@ private <T> void doDbiWithComparatorThreadSafety(
 
   @Test
   void drop() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       db.put(txn, bb(1), bb(42));
       db.put(txn, bb(2), bb(42));
@@ -274,8 +287,14 @@ void drop() {
 
   @Test
   void dropAndDelete() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
-    final Dbi<ByteBuffer> nameDb = env.openDbi((byte[]) null, DbiFlagSet.EMPTY);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
+    final Dbi<ByteBuffer> nameDb =
+        env.createDbi()
+            .setDbName((byte[]) null)
+            .withDefaultComparator()
+            .setDbiFlags(DbiFlagSet.EMPTY)
+            .open();
     final byte[] dbNameBytes = DB_1.getBytes(UTF_8);
     final ByteBuffer dbNameBuffer = allocateDirect(dbNameBytes.length);
     dbNameBuffer.put(dbNameBytes).flip();
@@ -290,8 +309,8 @@ void dropAndDelete() {
 
   @Test
   void dropAndDeleteAnonymousDb() {
-    env.openDbi(DB_1, MDB_CREATE);
-    final Dbi<ByteBuffer> nameDb = env.openDbi((byte[]) null, DbiFlagSet.EMPTY);
+    env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
+    final Dbi<ByteBuffer> nameDb = env.createDbi().withoutDbName().withDefaultComparator().open();
     final byte[] dbNameBytes = DB_1.getBytes(UTF_8);
     final ByteBuffer dbNameBuffer = allocateDirect(dbNameBytes.length);
     dbNameBuffer.put(dbNameBytes).flip();
@@ -308,7 +327,8 @@ void dropAndDeleteAnonymousDb() {
 
   @Test
   void getName() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
     assertThat(db.getName()).isEqualTo(DB_1.getBytes(UTF_8));
   }
 
@@ -316,8 +336,8 @@ void getName() {
   void getNamesWhenDbisPresent() {
     final byte[] dbHello = new byte[] {'h', 'e', 'l', 'l', 'o'};
     final byte[] dbWorld = new byte[] {'w', 'o', 'r', 'l', 'd'};
-    env.openDbi(dbHello, MDB_CREATE);
-    env.openDbi(dbWorld, MDB_CREATE);
+    env.createDbi().setDbName(dbHello).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
+    env.createDbi().setDbName(dbWorld).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
     final List<byte[]> dbiNames = env.getDbiNames();
     assertThat(dbiNames).hasSize(2);
     assertThat(dbiNames.get(0)).isEqualTo(dbHello);
@@ -333,7 +353,11 @@ void getNamesWhenEmpty() {
   @Test
   void listsFlags() {
     final Dbi<ByteBuffer> dbi =
-        env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT, MDB_REVERSEKEY));
+        env.createDbi()
+            .setDbName(DB_1)
+            .withDefaultComparator()
+            .setDbiFlags(MDB_CREATE, MDB_DUPSORT, MDB_REVERSEKEY)
+            .open();
 
     try (Txn<ByteBuffer> txn = env.txnRead()) {
       final List<DbiFlags> flags = dbi.listFlags(txn);
@@ -343,7 +367,8 @@ void listsFlags() {
 
   @Test
   void putAbortGet() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
 
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       db.put(txn, bb(5), bb(5));
@@ -357,7 +382,8 @@ void putAbortGet() {
 
   @Test
   void putAndGetAndDeleteWithInternalTx() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
 
     db.put(bb(5), bb(5));
     try (Txn<ByteBuffer> txn = env.txnRead()) {
@@ -375,7 +401,8 @@ void putAndGetAndDeleteWithInternalTx() {
 
   @Test
   void putCommitGet() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       db.put(txn, bb(5), bb(5));
       txn.commit();
@@ -398,7 +425,8 @@ void putCommitGetByteArray() {
             .setMaxDbs(2)
             .setEnvFlags(MDB_NOSUBDIR)
             .open(file)) {
-      final Dbi<byte[]> db = envBa.openDbi(DB_1, MDB_CREATE);
+      final Dbi<byte[]> db =
+          envBa.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
       try (Txn<byte[]> txn = envBa.txnWrite()) {
         db.put(txn, ba(5), ba(5));
         txn.commit();
@@ -413,7 +441,8 @@ void putCommitGetByteArray() {
 
   @Test
   void putDelete() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
 
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       db.put(txn, bb(5), bb(5));
@@ -426,7 +455,12 @@ void putDelete() {
 
   @Test
   void putDuplicateDelete() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
+    final Dbi<ByteBuffer> db =
+        env.createDbi()
+            .setDbName(DB_1)
+            .withDefaultComparator()
+            .setDbiFlags(MDB_CREATE, MDB_DUPSORT)
+            .open();
 
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       db.put(txn, bb(5), bb(5));
@@ -448,7 +482,8 @@ void putDuplicateDelete() {
 
   @Test
   void putReserve() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
 
     final ByteBuffer key = bb(5);
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
@@ -469,7 +504,8 @@ void putReserve() {
 
   @Test
   void putZeroByteValueForNonMdbDupSortDatabase() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       final ByteBuffer val = allocateDirect(0);
       db.put(txn, bb(5), val);
@@ -485,7 +521,12 @@ void putZeroByteValueForNonMdbDupSortDatabase() {
 
   @Test
   void returnValueForNoDupData() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
+    final Dbi<ByteBuffer> db =
+        env.createDbi()
+            .setDbName(DB_1)
+            .withDefaultComparator()
+            .setDbiFlags(MDB_CREATE, MDB_DUPSORT)
+            .open();
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       // ok
       assertThat(db.put(txn, bb(5), bb(6), MDB_NODUPDATA)).isTrue();
@@ -496,7 +537,8 @@ void returnValueForNoDupData() {
 
   @Test
   void returnValueForNoOverwrite() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       // ok
       assertThat(db.put(txn, bb(5), bb(6), MDB_NOOVERWRITE)).isTrue();
@@ -508,7 +550,8 @@ void returnValueForNoOverwrite() {
 
   @Test
   void stats() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
     db.put(bb(1), bb(42));
     db.put(bb(2), bb(42));
     db.put(bb(3), bb(42));
@@ -529,7 +572,12 @@ void stats() {
   void testMapFullException() {
     assertThatThrownBy(
             () -> {
-              final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+              final Dbi<ByteBuffer> db =
+                  env.createDbi()
+                      .setDbName(DB_1)
+                      .withDefaultComparator()
+                      .setDbiFlags(MDB_CREATE)
+                      .open();
               try (Txn<ByteBuffer> txn = env.txnWrite()) {
                 final ByteBuffer v;
                 try {
@@ -550,7 +598,8 @@ void testParallelWritesStress() {
       return; // Windows VMs run this test too slowly
     }
 
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
 
     // Travis CI has 1.5 cores for legacy builds
     nCopies(2, null).parallelStream()
@@ -567,7 +616,11 @@ void closedEnvRejectsOpenCall() {
     assertThatThrownBy(
             () -> {
               env.close();
-              env.openDbi(DB_1, MDB_CREATE);
+              env.createDbi()
+                  .setDbName(DB_1)
+                  .withDefaultComparator()
+                  .setDbiFlags(MDB_CREATE)
+                  .open();
             })
         .isInstanceOf(AlreadyClosedException.class);
   }
@@ -675,7 +728,8 @@ void closedEnvRejectsStatCall() {
   private void doEnvClosedTest(
       final BiConsumer<Dbi<ByteBuffer>, Txn<ByteBuffer>> workBeforeEnvClosed,
       final BiConsumer<Dbi<ByteBuffer>, Txn<ByteBuffer>> workAfterEnvClose) {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
 
     db.put(bb(1), bb(10));
     db.put(bb(2), bb(20));
diff --git a/src/test/java/org/lmdbjava/EnvDeprecatedTest.java b/src/test/java/org/lmdbjava/EnvDeprecatedTest.java
new file mode 100644
index 00000000..da004cc8
--- /dev/null
+++ b/src/test/java/org/lmdbjava/EnvDeprecatedTest.java
@@ -0,0 +1,383 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.lmdbjava;
+
+import static java.nio.ByteBuffer.allocateDirect;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.lmdbjava.ByteUnit.KIBIBYTES;
+import static org.lmdbjava.ByteUnit.MEBIBYTES;
+import static org.lmdbjava.CopyFlags.MDB_CP_COMPACT;
+import static org.lmdbjava.DbiFlags.MDB_CREATE;
+import static org.lmdbjava.Env.Builder.MAX_READERS_DEFAULT;
+import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
+import static org.lmdbjava.EnvFlags.MDB_RDONLY_ENV;
+import static org.lmdbjava.TestUtils.DB_1;
+import static org.lmdbjava.TestUtils.bb;
+
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.nio.ByteBuffer;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Random;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.lmdbjava.Env.AlreadyClosedException;
+import org.lmdbjava.Env.AlreadyOpenException;
+import org.lmdbjava.Env.Builder;
+import org.lmdbjava.Env.InvalidCopyDestination;
+import org.lmdbjava.Env.MapFullException;
+
+/**
+ * Tests all the deprecated methods in {@link Env}. Essentially a duplicate of {@link EnvTest}. When
+ * all the deprecated methods are deleted we can delete this test class.
+ *
+ * @deprecated Tests all the deprecated methods in {@link Env}.
+ */
+@Deprecated
+public class EnvDeprecatedTest {
+
+  private TempDir tempDir;
+
+  @BeforeEach
+  void beforeEach() {
+    tempDir = new TempDir();
+  }
+
+  @AfterEach
+  void afterEach() {
+    tempDir.cleanup();
+  }
+
+  @Test
+  void byteUnit() {
+    final Path file = tempDir.createTempFile();
+    try (Env<ByteBuffer> env =
+        Env.create()
+            .setMaxReaders(1)
+            .setMapSize(MEBIBYTES.toBytes(1))
+            .open(file.toFile(), MDB_NOSUBDIR)) {
+      final EnvInfo info = env.info();
+      assertThat(info.mapSize).isEqualTo(MEBIBYTES.toBytes(1));
+    }
+  }
+
+  @Test
+  void cannotChangeMapSizeAfterOpen() {
+    assertThatThrownBy(
+            () -> {
+              final Path file = tempDir.createTempFile();
+              final Builder<ByteBuffer> builder = Env.create().setMaxReaders(1);
+              try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
+                builder.setMapSize(1);
+              }
+            })
+        .isInstanceOf(AlreadyOpenException.class);
+  }
+
+  @Test
+  void cannotChangeMaxDbsAfterOpen() {
+    assertThatThrownBy(
+            () -> {
+              final Path file = tempDir.createTempFile();
+              final Builder<ByteBuffer> builder = Env.create().setMaxReaders(1);
+              try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
+                builder.setMaxDbs(1);
+              }
+            })
+        .isInstanceOf(AlreadyOpenException.class);
+  }
+
+  @Test
+  void cannotChangeMaxReadersAfterOpen() {
+    assertThatThrownBy(
+            () -> {
+              final Path file = tempDir.createTempFile();
+              final Builder<ByteBuffer> builder = Env.create().setMaxReaders(1);
+              try (Env<ByteBuffer> env = builder.open(file.toFile(), MDB_NOSUBDIR)) {
+                builder.setMaxReaders(1);
+              }
+            })
+        .isInstanceOf(AlreadyOpenException.class);
+  }
+
+  @Test
+  void cannotInfoOnceClosed() {
+    assertThatThrownBy(
+            () -> {
+              final Path file = tempDir.createTempFile();
+              final Env<ByteBuffer> env =
+                  Env.create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
+              env.close();
+              env.info();
+            })
+        .isInstanceOf(AlreadyClosedException.class);
+  }
+
+  @Test
+  void cannotOpenTwice() {
+    assertThatThrownBy(
+            () -> {
+              final Path file = tempDir.createTempFile();
+              final Builder<ByteBuffer> builder = Env.create().setMaxReaders(1);
+              builder.open(file.toFile(), MDB_NOSUBDIR).close();
+              builder.open(file.toFile(), MDB_NOSUBDIR);
+            })
+        .isInstanceOf(AlreadyOpenException.class);
+  }
+
+  @Test
+  void cannotStatOnceClosed() {
+    assertThatThrownBy(
+            () -> {
+              final Path file = tempDir.createTempFile();
+              final Env<ByteBuffer> env =
+                  Env.create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
+              env.close();
+              env.stat();
+            })
+        .isInstanceOf(AlreadyClosedException.class);
+  }
+
+  @Test
+  void cannotSyncOnceClosed() {
+    assertThatThrownBy(
+            () -> {
+              final Path file = tempDir.createTempFile();
+              final Env<ByteBuffer> env =
+                  Env.create().setMaxReaders(1).open(file.toFile(), MDB_NOSUBDIR);
+              env.close();
+              env.sync(false);
+            })
+        .isInstanceOf(AlreadyClosedException.class);
+  }
+
+  @Test
+  void copyDirectoryBased() {
+    final Path dest = tempDir.createTempDir();
+    final Path src = tempDir.createTempDir();
+    assertThat(Files.exists(dest)).isTrue();
+    assertThat(Files.isDirectory(dest)).isTrue();
+    assertThat(FileUtil.count(dest)).isEqualTo(0);
+    try (Env<ByteBuffer> env = Env.create().setMaxReaders(1).open(src.toFile())) {
+      env.copy(dest.toFile(), MDB_CP_COMPACT);
+      assertThat(FileUtil.count(dest)).isEqualTo(1);
+    }
+  }
+
+  @Test
+  void copyDirectoryRejectsFileDestination() {
+    assertThatThrownBy(
+            () -> {
+              final Path dest = tempDir.createTempDir();
+              final Path src = tempDir.createTempDir();
+              FileUtil.deleteDir(dest);
+              try (Env<ByteBuffer> env = Env.create().setMaxReaders(1).open(src.toFile())) {
+                env.copy(dest.toFile(), MDB_CP_COMPACT);
+              }
+            })
+        .isInstanceOf(InvalidCopyDestination.class);
+  }
+
+  @Test
+  void copyDirectoryRejectsMissingDestination() {
+    final Path dest = tempDir.createTempDir();
+    final Path src = tempDir.createTempDir();
+    assertThatThrownBy(
+            () -> {
+              try {
+                Files.delete(dest);
+                try (Env<ByteBuffer> env = Env.create().setMaxReaders(1).open(src.toFile())) {
+                  env.copy(dest.toFile(), MDB_CP_COMPACT);
+                }
+              } catch (final IOException e) {
+                throw new UncheckedIOException(e);
+              }
+            })
+        .isInstanceOf(InvalidCopyDestination.class);
+  }
+
+  @Test
+  void copyDirectoryRejectsNonEmptyDestination() {
+    final Path dest = tempDir.createTempDir();
+    final Path src = tempDir.createTempDir();
+    assertThatThrownBy(
+            () -> {
+              try {
+                final Path subDir = dest.resolve("hello");
+                Files.createDirectory(subDir);
+                assertThat(Files.isDirectory(subDir)).isTrue();
+                try (Env<ByteBuffer> env = Env.create().setMaxReaders(1).open(src.toFile())) {
+                  env.copy(dest.toFile(), MDB_CP_COMPACT);
+                }
+              } catch (final IOException e) {
+                throw new UncheckedIOException(e);
+              }
+            })
+        .isInstanceOf(InvalidCopyDestination.class);
+  }
+
+  @Test
+  void copyFileBased() {
+    final Path dest = tempDir.createTempFile();
+    final Path src = tempDir.createTempFile();
+    assertThat(Files.exists(dest)).isFalse();
+    try (Env<ByteBuffer> env = Env.create().setMaxReaders(1).open(src.toFile(), MDB_NOSUBDIR)) {
+      env.copy(dest.toFile(), MDB_CP_COMPACT);
+    }
+    assertThat(FileUtil.size(dest)).isGreaterThan(0L);
+  }
+
+  @Test
+  void copyFileRejectsExistingDestination() {
+    final Path dest = tempDir.createTempFile();
+    final Path src = tempDir.createTempFile();
+    assertThatThrownBy(
+            () -> {
+              Files.createFile(dest);
+              assertThat(Files.exists(dest)).isTrue();
+              try (Env<ByteBuffer> env =
+                  Env.create().setMaxReaders(1).open(src.toFile(), MDB_NOSUBDIR)) {
+                env.copy(dest.toFile(), MDB_CP_COMPACT);
+              }
+            })
+        .isInstanceOf(InvalidCopyDestination.class);
+  }
+
+  @Test
+  void createAsFile() {
+    final Path file = tempDir.createTempFile();
+    try (Env<ByteBuffer> env =
+        Env.create()
+            .setMapSize(MEBIBYTES.toBytes(1))
+            .setMaxDbs(1)
+            .setMaxReaders(1)
+            .open(file.toFile(), MDB_NOSUBDIR)) {
+      env.sync(true);
+      assertThat(Files.isRegularFile(file)).isTrue();
+    }
+  }
+
+  @Test
+  void mapFull() {
+    final Path dir = tempDir.createTempDir();
+    assertThatThrownBy(
+            () -> {
+              final byte[] k = new byte[500];
+              final ByteBuffer key = allocateDirect(500);
+              final ByteBuffer val = allocateDirect(1_024);
+              final Random rnd = new Random();
+              try (Env<ByteBuffer> env =
+                  Env.create()
+                      .setMaxReaders(1)
+                      .setMapSize(MEBIBYTES.toBytes(8))
+                      .setMaxDbs(1)
+                      .open(dir.toFile())) {
+                final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+                for (; ; ) {
+                  rnd.nextBytes(k);
+                  key.clear();
+                  key.put(k).flip();
+                  val.clear();
+                  db.put(key, val);
+                }
+              }
+            })
+        .isInstanceOf(MapFullException.class);
+  }
+
+  @Test
+  void readOnlySupported() {
+    final Path dir = tempDir.createTempDir();
+    try (Env<ByteBuffer> rwEnv = Env.create().setMaxReaders(1).open(dir.toFile())) {
+      final Dbi<ByteBuffer> rwDb = rwEnv.openDbi(DB_1, MDB_CREATE);
+      rwDb.put(bb(1), bb(42));
+    }
+    try (Env<ByteBuffer> roEnv = Env.create().setMaxReaders(1).open(dir.toFile(), MDB_RDONLY_ENV)) {
+      final Dbi<ByteBuffer> roDb = roEnv.openDbi(DB_1);
+      try (Txn<ByteBuffer> roTxn = roEnv.txnRead()) {
+        assertThat(roDb.get(roTxn, bb(1))).isNotNull();
+      }
+    }
+  }
+
+  @Test
+  void setMapSize() {
+    final Path dir = tempDir.createTempDir();
+    final byte[] k = new byte[500];
+    final ByteBuffer key = allocateDirect(500);
+    final ByteBuffer val = allocateDirect(1_024);
+    final Random rnd = new Random();
+    try (Env<ByteBuffer> env =
+        Env.create()
+            .setMaxReaders(1)
+            .setMapSize(KIBIBYTES.toBytes(256))
+            .setMaxDbs(1)
+            .open(dir.toFile())) {
+      final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+
+      db.put(bb(1), bb(42));
+      boolean mapFullExThrown = false;
+      try {
+        for (int i = 0; i < 70; i++) {
+          rnd.nextBytes(k);
+          key.clear();
+          key.put(k).flip();
+          val.clear();
+          db.put(key, val);
+        }
+      } catch (final MapFullException mfE) {
+        mapFullExThrown = true;
+      }
+      assertThat(mapFullExThrown).isTrue();
+
+      env.setMapSize(KIBIBYTES.toBytes(1024));
+
+      try (Txn<ByteBuffer> roTxn = env.txnRead()) {
+        final ByteBuffer byteBuffer = db.get(roTxn, bb(1));
+        assertThat(byteBuffer).isNotNull();
+        assertThat(byteBuffer.getInt()).isEqualTo(42);
+      }
+
+      mapFullExThrown = false;
+      try {
+        for (int i = 0; i < 70; i++) {
+          rnd.nextBytes(k);
+          key.clear();
+          key.put(k).flip();
+          val.clear();
+          db.put(key, val);
+        }
+      } catch (final MapFullException mfE) {
+        mapFullExThrown = true;
+      }
+      assertThat(mapFullExThrown).isFalse();
+    }
+  }
+
+  @Test
+  void testDefaultOpen() {
+    final Path dir = tempDir.createTempDir();
+    try (Env<ByteBuffer> env = Env.open(dir.toFile(), 10)) {
+      final EnvInfo info = env.info();
+      assertThat(info.maxReaders).isEqualTo(MAX_READERS_DEFAULT);
+      final Dbi<ByteBuffer> db = env.openDbi("test", MDB_CREATE);
+      db.put(allocateDirect(1), allocateDirect(1));
+    }
+  }
+}
diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index 239a72b1..117ff032 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -361,7 +361,12 @@ void mapFull() {
                       .setMapSize(8, ByteUnit.MEBIBYTES)
                       .setMaxDbs(1)
                       .open(dir)) {
-                final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+                final Dbi<ByteBuffer> db =
+                    env.createDbi()
+                        .setDbName(DB_1)
+                        .withDefaultComparator()
+                        .setDbiFlags(MDB_CREATE)
+                        .open();
                 //noinspection InfiniteLoopStatement // Needs infinite loop to fill the env
                 for (; ; ) {
                   rnd.nextBytes(k);
@@ -379,12 +384,19 @@ void mapFull() {
   void readOnlySupported() {
     final Path dir = tempDir.createTempDir();
     try (Env<ByteBuffer> rwEnv = Env.create().setMaxReaders(1).open(dir)) {
-      final Dbi<ByteBuffer> rwDb = rwEnv.openDbi(DB_1, MDB_CREATE);
+      final Dbi<ByteBuffer> rwDb =
+          rwEnv.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
       rwDb.put(bb(1), bb(42));
     }
     try (Env<ByteBuffer> roEnv =
         Env.create().setMaxReaders(1).setEnvFlags(MDB_RDONLY_ENV).open(dir)) {
-      final Dbi<ByteBuffer> roDb = roEnv.openDbi(DB_1, DbiFlagSet.EMPTY);
+      final Dbi<ByteBuffer> roDb =
+          roEnv
+              .createDbi()
+              .setDbName(DB_1)
+              .withDefaultComparator()
+              .setDbiFlags(DbiFlagSet.EMPTY)
+              .open();
       try (Txn<ByteBuffer> roTxn = roEnv.txnRead()) {
         assertThat(roDb.get(roTxn, bb(1))).isNotNull();
       }
@@ -400,7 +412,8 @@ void setMapSize() {
     final Random rnd = new Random();
     try (Env<ByteBuffer> env =
         Env.create().setMaxReaders(1).setMapSize(256, ByteUnit.KIBIBYTES).setMaxDbs(1).open(dir)) {
-      final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+      final Dbi<ByteBuffer> db =
+          env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
 
       db.put(bb(1), bb(42));
       boolean mapFullExThrown = false;
@@ -469,7 +482,8 @@ void testDefaultOpen() {
     try (Env<ByteBuffer> env = Env.create().setMapSize(10, ByteUnit.MEBIBYTES).open(dir)) {
       final EnvInfo info = env.info();
       assertThat(info.maxReaders).isEqualTo(MAX_READERS_DEFAULT);
-      final Dbi<ByteBuffer> db = env.openDbi("test", MDB_CREATE);
+      final Dbi<ByteBuffer> db =
+          env.createDbi().setDbName("test").withDefaultComparator().setDbiFlags(MDB_CREATE).open();
       db.put(allocateDirect(1), allocateDirect(1));
     }
   }
@@ -480,7 +494,12 @@ void testDefaultOpenNoName1() {
     try (Env<ByteBuffer> env = Env.create().setMapSize(10, ByteUnit.MEBIBYTES).open(dir)) {
       final EnvInfo info = env.info();
       assertThat(info.maxReaders).isEqualTo(MAX_READERS_DEFAULT);
-      final Dbi<ByteBuffer> db = env.openDbi((String) null, MDB_CREATE);
+      final Dbi<ByteBuffer> db =
+          env.createDbi()
+              .setDbName((String) null)
+              .withDefaultComparator()
+              .setDbiFlags(MDB_CREATE)
+              .open();
       db.put(bb("abc"), allocateDirect(1));
       db.put(bb("def"), allocateDirect(1));
 
@@ -498,7 +517,12 @@ void testDefaultOpenNoName2() {
     try (Env<ByteBuffer> env = Env.create().setMapSize(10, ByteUnit.MEBIBYTES).open(dir)) {
       final EnvInfo info = env.info();
       assertThat(info.maxReaders).isEqualTo(MAX_READERS_DEFAULT);
-      final Dbi<ByteBuffer> db = env.openDbi((byte[]) null, MDB_CREATE);
+      final Dbi<ByteBuffer> db =
+          env.createDbi()
+              .setDbName((byte[]) null)
+              .withDefaultComparator()
+              .setDbiFlags(MDB_CREATE)
+              .open();
       db.put(bb("abc"), allocateDirect(1));
       db.put(bb("def"), allocateDirect(1));
 
diff --git a/src/test/java/org/lmdbjava/GarbageCollectionTest.java b/src/test/java/org/lmdbjava/GarbageCollectionTest.java
index e6c8ca88..4aa1245f 100644
--- a/src/test/java/org/lmdbjava/GarbageCollectionTest.java
+++ b/src/test/java/org/lmdbjava/GarbageCollectionTest.java
@@ -38,7 +38,12 @@ void buffersNotGarbageCollectedTest() {
     try (final TempDir tempDir = new TempDir()) {
       final Path dir = tempDir.createTempDir();
       try (Env<ByteBuffer> env = Env.create().setMapSize(2_085_760_999).setMaxDbs(1).open(dir)) {
-        final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
+        final Dbi<ByteBuffer> db =
+            env.createDbi()
+                .setDbName(DB_NAME)
+                .withDefaultComparator()
+                .setDbiFlags(MDB_CREATE)
+                .open();
 
         try (Txn<ByteBuffer> txn = env.txnWrite()) {
           for (int i = 0; i < 5_000; i++) {
diff --git a/src/test/java/org/lmdbjava/TutorialTest.java b/src/test/java/org/lmdbjava/TutorialTest.java
index 096e990b..c2271363 100644
--- a/src/test/java/org/lmdbjava/TutorialTest.java
+++ b/src/test/java/org/lmdbjava/TutorialTest.java
@@ -96,7 +96,8 @@ void tutorial1() {
 
     // We need a Dbi for each DB. A Dbi roughly equates to a sorted map. The
     // MDB_CREATE flag causes the DB to be created if it doesn't already exist.
-    final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_NAME).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
 
     // We want to store some data, so we will need a direct ByteBuffer.
     // Note that LMDB keys cannot exceed maxKeySize bytes (511 bytes by default).
@@ -146,7 +147,8 @@ void tutorial2() {
     final Path dir = tempDir.createTempDir();
     try {
       final Env<ByteBuffer> env = createSimpleEnv(dir);
-      final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
+      final Dbi<ByteBuffer> db =
+          env.createDbi().setDbName(DB_NAME).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
       final ByteBuffer key = ByteBuffer.allocateDirect(env.getMaxKeySize());
       final ByteBuffer val = ByteBuffer.allocateDirect(700);
 
@@ -222,7 +224,8 @@ void tutorial2() {
   void tutorial3() {
     final Path dir = tempDir.createTempDir();
     final Env<ByteBuffer> env = createSimpleEnv(dir);
-    final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_NAME).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
     final ByteBuffer key = ByteBuffer.allocateDirect(env.getMaxKeySize());
     final ByteBuffer val = ByteBuffer.allocateDirect(700);
 
@@ -295,7 +298,8 @@ void tutorial3() {
   void tutorial4() {
     final Path dir = tempDir.createTempDir();
     final Env<ByteBuffer> env = createSimpleEnv(dir);
-    final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_NAME).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
 
     try (Txn<ByteBuffer> txn = env.txnWrite()) {
       final ByteBuffer key = ByteBuffer.allocateDirect(env.getMaxKeySize());
@@ -353,7 +357,12 @@ void tutorial5() {
 
     // This time we're going to tell the Dbi it can store > 1 value per key.
     // There are other flags available if we're storing integers etc.
-    final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, DbiFlagSet.of(MDB_CREATE, MDB_DUPSORT));
+    final Dbi<ByteBuffer> db =
+        env.createDbi()
+            .setDbName(DB_NAME)
+            .withDefaultComparator()
+            .setDbiFlags(MDB_CREATE, MDB_DUPSORT)
+            .open();
 
     // Duplicate support requires both keys and values to be <= max key size.
     final ByteBuffer key = ByteBuffer.allocateDirect(env.getMaxKeySize());
@@ -428,7 +437,8 @@ void tutorial7() {
     final Env<DirectBuffer> env =
         Env.create(PROXY_DB).setMapSize(10, ByteUnit.MEBIBYTES).setMaxDbs(1).open(dir);
 
-    final Dbi<DirectBuffer> db = env.openDbi(DB_NAME, MDB_CREATE);
+    final Dbi<DirectBuffer> db =
+        env.createDbi().setDbName(DB_NAME).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
 
     final ByteBuffer keyBb = ByteBuffer.allocateDirect(env.getMaxKeySize());
     final MutableDirectBuffer key = new UnsafeBuffer(keyBb);
@@ -487,7 +497,12 @@ void tutorial8() {
     // This time we're going to tell the Dbi that all the keys are integers.
     // MDB_INTEGERKEY applies to both int and long keys.
     // LMDB can make optimisations for better performance.
-    final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, DbiFlagSet.of(MDB_CREATE, MDB_INTEGERKEY));
+    final Dbi<ByteBuffer> db =
+        env.createDbi()
+            .setDbName(DB_NAME)
+            .withDefaultComparator()
+            .setDbiFlags(MDB_CREATE, MDB_INTEGERKEY)
+            .open();
 
     // MDB_INTEGERKEY requires that the keys are written/read in native order
     final ByteBuffer key = ByteBuffer.allocateDirect(Long.BYTES).order(ByteOrder.nativeOrder());
@@ -541,7 +556,12 @@ void tutorial9() {
     final Path dir = tempDir.createTempDir();
     final Env<ByteBuffer> env = createSimpleEnv(dir);
 
-    final Dbi<ByteBuffer> db = env.openDbi(DB_NAME, DbiFlagSet.of(MDB_CREATE, MDB_REVERSEKEY));
+    final Dbi<ByteBuffer> db =
+        env.createDbi()
+            .setDbName(DB_NAME)
+            .withDefaultComparator()
+            .setDbiFlags(MDB_CREATE, MDB_REVERSEKEY)
+            .open();
 
     final ByteBuffer key = ByteBuffer.allocateDirect(100);
     final ByteBuffer val = ByteBuffer.allocateDirect(100);
diff --git a/src/test/java/org/lmdbjava/TxnTest.java b/src/test/java/org/lmdbjava/TxnTest.java
index b1898cd4..790d81de 100644
--- a/src/test/java/org/lmdbjava/TxnTest.java
+++ b/src/test/java/org/lmdbjava/TxnTest.java
@@ -82,7 +82,12 @@ void afterEach() {
   void largeKeysRejected() {
     assertThatThrownBy(
             () -> {
-              final Dbi<ByteBuffer> dbi = env.openDbi(DB_1, MDB_CREATE);
+              final Dbi<ByteBuffer> dbi =
+                  env.createDbi()
+                      .setDbName(DB_1)
+                      .withDefaultComparator()
+                      .setDbiFlags(MDB_CREATE)
+                      .open();
               final ByteBuffer key = allocateDirect(env.getMaxKeySize() + 1);
               key.limit(key.capacity());
               dbi.put(key, bb(2));
@@ -92,7 +97,8 @@ void largeKeysRejected() {
 
   @Test
   void rangeSearch() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
 
     final ByteBuffer key = allocateDirect(env.getMaxKeySize());
     key.put("cherry".getBytes(UTF_8)).flip();
@@ -126,7 +132,7 @@ void rangeSearch() {
 
   @Test
   void readOnlyTxnAllowedInReadOnlyEnv() {
-    env.openDbi(DB_1, MDB_CREATE);
+    env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
     try (Env<ByteBuffer> roEnv =
         create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR, MDB_RDONLY_ENV).open(file)) {
       assertThat(roEnv.txnRead()).isNotNull();
@@ -137,7 +143,11 @@ void readOnlyTxnAllowedInReadOnlyEnv() {
   void readWriteTxnDeniedInReadOnlyEnv() {
     assertThatThrownBy(
             () -> {
-              env.openDbi(DB_1, MDB_CREATE);
+              env.createDbi()
+                  .setDbName(DB_1)
+                  .withDefaultComparator()
+                  .setDbiFlags(MDB_CREATE)
+                  .open();
               env.close();
               try (Env<ByteBuffer> roEnv =
                   create().setMaxReaders(1).setEnvFlags(MDB_NOSUBDIR, MDB_RDONLY_ENV).open(file)) {
@@ -183,8 +193,8 @@ void testCheckWritesAllowed() {
 
   @Test
   void testGetId() {
-    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE);
-
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
     final AtomicLong txId1 = new AtomicLong();
     final AtomicLong txId2 = new AtomicLong();
 
@@ -419,7 +429,12 @@ void txResetDeniedForReadWriteTransaction() {
   void zeroByteKeysRejected() {
     assertThatThrownBy(
             () -> {
-              final Dbi<ByteBuffer> dbi = env.openDbi(DB_1, MDB_CREATE);
+              final Dbi<ByteBuffer> dbi =
+                  env.createDbi()
+                      .setDbName(DB_1)
+                      .withDefaultComparator()
+                      .setDbiFlags(MDB_CREATE)
+                      .open();
               final ByteBuffer key = allocateDirect(4);
               key.putInt(1);
               assertThat(key.remaining()).isEqualTo(0); // because key.flip() skipped

From 8c19bf43748c6faf334b1e5e8d6e2e0f2e920bbc Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 14 Nov 2025 15:58:02 +0000
Subject: [PATCH 296/322] Add test coverage

---
 src/main/java/org/lmdbjava/Dbi.java           |  4 ++
 src/main/java/org/lmdbjava/Env.java           | 22 +++++-
 .../org/lmdbjava/AbstractFlagSetTest.java     | 15 ++++
 .../java/org/lmdbjava/CopyFlagSetTest.java    |  7 ++
 .../org/lmdbjava/CursorIterableRangeTest.java | 69 +++++++++++--------
 .../java/org/lmdbjava/DbiFlagSetTest.java     |  7 ++
 .../java/org/lmdbjava/EnvFlagSetTest.java     |  7 ++
 src/test/java/org/lmdbjava/EnvTest.java       | 11 ++-
 .../java/org/lmdbjava/PutFlagSetTest.java     |  7 ++
 .../java/org/lmdbjava/TxnFlagSetTest.java     |  7 ++
 src/test/java/org/lmdbjava/VerifierTest.java  | 16 +++++
 11 files changed, 139 insertions(+), 33 deletions(-)

diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index e5d66568..aff6fff8 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -296,6 +296,10 @@ public String getNameAsString() {
    * @throws RuntimeException if the name can't be decoded.
    */
   public String getNameAsString(final Charset charset) {
+    return getNameAsString(this.name, charset);
+  }
+
+  static String getNameAsString(final byte[] name, final Charset charset) {
     if (name == null) {
       return "";
     } else {
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index eec1c354..3a068ae4 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -37,6 +37,7 @@
 import java.util.Comparator;
 import java.util.List;
 import java.util.Objects;
+import java.util.stream.Collectors;
 import jnr.ffi.Pointer;
 import jnr.ffi.byref.IntByReference;
 import jnr.ffi.byref.PointerByReference;
@@ -230,7 +231,26 @@ public List<byte[]> getDbiNames() {
         } while (cursor.next());
       }
     }
-    return result;
+    return Collections.unmodifiableList(result);
+  }
+
+  /**
+   * Obtain the DBI names.
+   *
+   * <p>This method is only compatible with {@link Env}s that use named databases. If an unnamed
+   * {@link Dbi} is being used to store data, this method will attempt to return all such keys from
+   * the unnamed database.
+   *
+   * <p>This method must not be called from concurrent threads.
+   *
+   * @return a list of DBI names (never null)
+   */
+  public List<String> getDbiNames(final Charset charset) {
+    final List<byte[]> dbiNames = getDbiNames();
+    return dbiNames.stream()
+        .map(nameBytes ->
+            Dbi.getNameAsString(nameBytes, charset))
+        .collect(Collectors.toList());
   }
 
   /**
diff --git a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
index bef97911..c2887e93 100644
--- a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
@@ -20,9 +20,12 @@
 import java.lang.reflect.Array;
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.EnumSet;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
+import java.util.function.Function;
+import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 public abstract class AbstractFlagSetTest<
@@ -42,6 +45,8 @@ public abstract class AbstractFlagSetTest<
 
   abstract Class<T> getFlagType();
 
+  abstract Function<EnumSet<T>, F> getConstructor();
+
   T getFirst() {
     return getAllFlags().get(0);
   }
@@ -75,6 +80,7 @@ void testSingleFlagSet() {
       assertThat(flagSet.areAnySet(flag)).isTrue();
       assertThat(flagSet.areAnySet(null)).isFalse();
       assertThat(flagSet.areAnySet(getEmptyFlagSet())).isFalse();
+      assertThat(flagSet.isSet(null)).isFalse();
       assertThat(flagSet.isSet(getFirst())).isEqualTo(getFirst() == flag);
       if (getFirst() == flag) {
         assertThat(flagSet.getMask()).isEqualTo(MaskedFlag.mask(getFirst()));
@@ -155,6 +161,15 @@ void testClearBuilder() {
     assertThat(flagSet.isEmpty()).isTrue();
   }
 
+  @Test
+  void testConstructor() {
+    final Function<EnumSet<T>, F> constructor = getConstructor();
+    EnumSet<T> set = EnumSet.allOf(getFlagType());
+    final F flagSet = constructor.apply(set);
+    Assertions.assertThat(flagSet.getFlags())
+        .containsExactlyInAnyOrderElementsOf(getAllFlags());
+  }
+
   private T[] toArray(final int cnt) {
     //noinspection unchecked
     return (T[]) Array.newInstance(getFlagType(), cnt);
diff --git a/src/test/java/org/lmdbjava/CopyFlagSetTest.java b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
index 96203af9..90ced57a 100644
--- a/src/test/java/org/lmdbjava/CopyFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
@@ -17,7 +17,9 @@
 
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.EnumSet;
 import java.util.List;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.Test;
@@ -65,4 +67,9 @@ CopyFlagSet getFlagSet(CopyFlags flag) {
   Class<CopyFlags> getFlagType() {
     return CopyFlags.class;
   }
+
+  @Override
+  Function<EnumSet<CopyFlags>, CopyFlagSet> getConstructor() {
+    return CopyFlagSetImpl::new;
+  }
 }
diff --git a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
index 66d534a5..5f88a012 100644
--- a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
@@ -31,13 +31,17 @@
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.function.BiConsumer;
 import java.util.function.Function;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.CsvFileSource;
 import org.lmdbjava.CursorIterable.KeyVal;
 
-/** Test {@link CursorIterable}. */
+/**
+ * Test {@link CursorIterable}.
+ */
 public final class CursorIterableRangeTest {
 
   private static final DbiFlagSet FLAGSET_DUPSORT =
@@ -210,29 +214,36 @@ private void testCSV(
       final String expectedKV,
       final int keyLen,
       final ByteOrder byteOrder) {
-    // First test with our default iterator comparator
-    testCSV(
-        DbiBuilder.Stage2::withDefaultComparator,
-        dbPopulator,
-        dbiFlags,
-        keyType,
-        startKey,
-        stopKey,
-        expectedKV,
-        keyLen,
-        byteOrder);
 
+    // We want to assert that the behaviour of all 4 comparator functions
+    // is identical.
+
+    final List<Function<DbiBuilder.Stage2<ByteBuffer>, DbiBuilder.Stage3<ByteBuffer>>> comparatorFuncs =
+        new ArrayList<>();
+
+    // First test with our default iterator comparator
+    comparatorFuncs.add(DbiBuilder.Stage2::withDefaultComparator);
     // Now test with mdp_cmp doing all comparisons, should be the same
-    testCSV(
-        DbiBuilder.Stage2::withNativeComparator,
-        dbPopulator,
-        dbiFlags,
-        keyType,
-        startKey,
-        stopKey,
-        expectedKV,
-        keyLen,
-        byteOrder);
+    comparatorFuncs.add(DbiBuilder.Stage2::withNativeComparator);
+    // Now test with the java callback comparator doing all the work
+    comparatorFuncs.add(byteBufferStage2 ->
+        byteBufferStage2.withCallbackComparator(ByteBufferProxy.PROXY_OPTIMAL::getComparator));
+    // Now test with the java comparator for iteration only
+    comparatorFuncs.add(byteBufferStage2 ->
+        byteBufferStage2.withIteratorComparator(ByteBufferProxy.PROXY_OPTIMAL::getComparator));
+
+    for (Function<DbiBuilder.Stage2<ByteBuffer>, DbiBuilder.Stage3<ByteBuffer>> comparatorFunc : comparatorFuncs) {
+      testCSV(
+          comparatorFunc,
+          dbPopulator,
+          dbiFlags,
+          keyType,
+          startKey,
+          stopKey,
+          expectedKV,
+          keyLen,
+          byteOrder);
+    }
   }
 
   private void testCSV(
@@ -248,12 +259,12 @@ private void testCSV(
     try (final TempDir tempDir = new TempDir()) {
       final Path file = tempDir.createTempFile();
       try (final Env<ByteBuffer> env =
-          create()
-              .setMapSize(256, ByteUnit.KIBIBYTES)
-              .setMaxReaders(1)
-              .setMaxDbs(1)
-              .setEnvFlags(EnvFlags.MDB_NOSUBDIR)
-              .open(file)) {
+               create()
+                   .setMapSize(256, ByteUnit.KIBIBYTES)
+                   .setMaxReaders(1)
+                   .setMaxDbs(1)
+                   .setEnvFlags(EnvFlags.MDB_NOSUBDIR)
+                   .open(file)) {
 
         final DbiBuilder.Stage2<ByteBuffer> builderStage2 = env.createDbi().setDbName(DB_1);
         final DbiBuilder.Stage3<ByteBuffer> builderStage3 = comparatorFunc.apply(builderStage2);
@@ -267,7 +278,7 @@ private void testCSV(
 
           final KeyRange<ByteBuffer> keyRange = new KeyRange<>(keyRangeType, start, stop);
           try (Txn<ByteBuffer> txn = env.txnRead();
-              CursorIterable<ByteBuffer> c = dbi.iterate(txn, keyRange)) {
+               CursorIterable<ByteBuffer> c = dbi.iterate(txn, keyRange)) {
             for (final KeyVal<ByteBuffer> kv : c) {
               final long key = getLong(kv.key(), byteOrder);
               final long val = getLong(kv.val(), ByteOrder.BIG_ENDIAN);
diff --git a/src/test/java/org/lmdbjava/DbiFlagSetTest.java b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
index 5be7bc60..f9f591a5 100644
--- a/src/test/java/org/lmdbjava/DbiFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
@@ -17,7 +17,9 @@
 
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.EnumSet;
 import java.util.List;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.Test;
@@ -65,4 +67,9 @@ DbiFlagSet getFlagSet(DbiFlags[] flags) {
   DbiFlagSet getFlagSet(DbiFlags flag) {
     return DbiFlagSet.of(flag);
   }
+
+  @Override
+  Function<EnumSet<DbiFlags>, DbiFlagSet> getConstructor() {
+    return DbiFlagSetImpl::new;
+  }
 }
diff --git a/src/test/java/org/lmdbjava/EnvFlagSetTest.java b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
index 24300c1f..1124a91d 100644
--- a/src/test/java/org/lmdbjava/EnvFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
@@ -17,7 +17,9 @@
 
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.EnumSet;
 import java.util.List;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.Test;
@@ -65,4 +67,9 @@ EnvFlagSet getFlagSet(EnvFlags flag) {
   Class<EnvFlags> getFlagType() {
     return EnvFlags.class;
   }
+
+  @Override
+  Function<EnumSet<EnvFlags>, EnvFlagSet> getConstructor() {
+    return EnvFlagSetImpl::new;
+  }
 }
diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index 117ff032..b333f6f8 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -504,10 +504,15 @@ void testDefaultOpenNoName1() {
       db.put(bb("def"), allocateDirect(1));
 
       // As this is the unnamed database it returns all keys in the unnamed db
-      final List<byte[]> dbiNames = env.getDbiNames();
+      final List<byte[]> dbiNamesBytes = env.getDbiNames();
+      assertThat(dbiNamesBytes).hasSize(2);
+      assertThat(dbiNamesBytes.get(0)).isEqualTo("abc".getBytes(Env.DEFAULT_NAME_CHARSET));
+      assertThat(dbiNamesBytes.get(1)).isEqualTo("def".getBytes(Env.DEFAULT_NAME_CHARSET));
+
+      final List<String> dbiNames = env.getDbiNames(Env.DEFAULT_NAME_CHARSET);
       assertThat(dbiNames).hasSize(2);
-      assertThat(dbiNames.get(0)).isEqualTo("abc".getBytes(Env.DEFAULT_NAME_CHARSET));
-      assertThat(dbiNames.get(1)).isEqualTo("def".getBytes(Env.DEFAULT_NAME_CHARSET));
+      assertThat(dbiNames.get(0)).isEqualTo("abc");
+      assertThat(dbiNames.get(1)).isEqualTo("def");
     }
   }
 
diff --git a/src/test/java/org/lmdbjava/PutFlagSetTest.java b/src/test/java/org/lmdbjava/PutFlagSetTest.java
index 93d3aab0..9fe858f0 100644
--- a/src/test/java/org/lmdbjava/PutFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/PutFlagSetTest.java
@@ -19,7 +19,9 @@
 import java.time.Instant;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.EnumSet;
 import java.util.List;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 import org.assertj.core.api.Assertions;
@@ -69,6 +71,11 @@ Class<PutFlags> getFlagType() {
     return PutFlags.class;
   }
 
+  @Override
+  Function<EnumSet<PutFlags>, PutFlagSet> getConstructor() {
+    return PutFlagSetImpl::new;
+  }
+
   @Test
   public void testAddFlagVsCheckPresence() {
 
diff --git a/src/test/java/org/lmdbjava/TxnFlagSetTest.java b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
index 2d700525..5390ed66 100644
--- a/src/test/java/org/lmdbjava/TxnFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
@@ -17,7 +17,9 @@
 
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.EnumSet;
 import java.util.List;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.Test;
@@ -65,4 +67,9 @@ TxnFlagSet getFlagSet(TxnFlags flag) {
   Class<TxnFlags> getFlagType() {
     return TxnFlags.class;
   }
+
+  @Override
+  Function<EnumSet<TxnFlags>, TxnFlagSet> getConstructor() {
+    return TxnFlagSetImpl::new;
+  }
 }
diff --git a/src/test/java/org/lmdbjava/VerifierTest.java b/src/test/java/org/lmdbjava/VerifierTest.java
index f2d95930..28b48ae4 100644
--- a/src/test/java/org/lmdbjava/VerifierTest.java
+++ b/src/test/java/org/lmdbjava/VerifierTest.java
@@ -23,6 +23,7 @@
 import java.nio.ByteBuffer;
 import java.nio.file.Path;
 import java.util.concurrent.TimeUnit;
+import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 /** Test {@link Verifier}. */
@@ -39,7 +40,22 @@ void verification() {
               .setMapSize(10, ByteUnit.MEBIBYTES)
               .setEnvFlags(MDB_NOSUBDIR)
               .open(file)) {
+
+        // Create a DB to ensure that the verifier can c
+        env.createDbi()
+            .setDbName("db1")
+            .withDefaultComparator()
+            .setDbiFlags(DbiFlags.MDB_CREATE)
+            .open();
+
+        Assertions.assertThat(env.getDbiNames(Env.DEFAULT_NAME_CHARSET))
+            .containsExactly("db1");
+
         final Verifier v = new Verifier(env);
+
+        Assertions.assertThat(env.getDbiNames(Env.DEFAULT_NAME_CHARSET))
+            .doesNotContain("db1");
+
         final int seconds = Integer.getInteger("verificationSeconds", 2);
         assertThat(v.runFor(seconds, TimeUnit.SECONDS)).isGreaterThan(1L);
       }

From 496e5eaad1b88f350d1b5b6a2a6ea72751f5fb72 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 14 Nov 2025 16:02:01 +0000
Subject: [PATCH 297/322] Add test coverage

---
 src/test/java/org/lmdbjava/EnvTest.java | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index b333f6f8..13a0bfd1 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -204,6 +204,19 @@ void copyDirectoryBased() {
     }
   }
 
+  @Test
+  void copyDirectoryBased_noFlags() {
+    final Path dest = tempDir.createTempDir();
+    assertThat(Files.exists(dest)).isTrue();
+    assertThat(Files.isDirectory(dest)).isTrue();
+    assertThat(FileUtil.count(dest)).isEqualTo(0);
+    final Path src = tempDir.createTempDir();
+    try (Env<ByteBuffer> env = Env.create().setMaxReaders(1).open(src)) {
+      env.copy(dest);
+      assertThat(FileUtil.count(dest)).isEqualTo(1);
+    }
+  }
+
   @Test
   void copyDirectoryRejectsFileDestination() {
     assertThatThrownBy(
@@ -436,6 +449,12 @@ void setMapSize() {
               })
           .isInstanceOf(IllegalArgumentException.class);
 
+      assertThatThrownBy(
+          () -> {
+            env.setMapSize(-1);
+          })
+          .isInstanceOf(IllegalArgumentException.class);
+
       env.setMapSize(1024, ByteUnit.KIBIBYTES);
 
       try (Txn<ByteBuffer> roTxn = env.txnRead()) {

From 7bd33324dae5af17acdc7366f4e3fbc470786d20 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 14 Nov 2025 16:02:17 +0000
Subject: [PATCH 298/322] Auto format

---
 src/main/java/org/lmdbjava/Env.java           |  3 +-
 .../org/lmdbjava/AbstractFlagSetTest.java     |  3 +-
 .../org/lmdbjava/CursorIterableRangeTest.java | 35 ++++++++++---------
 src/test/java/org/lmdbjava/EnvTest.java       |  6 ++--
 src/test/java/org/lmdbjava/VerifierTest.java  |  6 ++--
 5 files changed, 25 insertions(+), 28 deletions(-)

diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 3a068ae4..af3a6596 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -248,8 +248,7 @@ public List<byte[]> getDbiNames() {
   public List<String> getDbiNames(final Charset charset) {
     final List<byte[]> dbiNames = getDbiNames();
     return dbiNames.stream()
-        .map(nameBytes ->
-            Dbi.getNameAsString(nameBytes, charset))
+        .map(nameBytes -> Dbi.getNameAsString(nameBytes, charset))
         .collect(Collectors.toList());
   }
 
diff --git a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
index c2887e93..4c7efa1c 100644
--- a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
@@ -166,8 +166,7 @@ void testConstructor() {
     final Function<EnumSet<T>, F> constructor = getConstructor();
     EnumSet<T> set = EnumSet.allOf(getFlagType());
     final F flagSet = constructor.apply(set);
-    Assertions.assertThat(flagSet.getFlags())
-        .containsExactlyInAnyOrderElementsOf(getAllFlags());
+    Assertions.assertThat(flagSet.getFlags()).containsExactlyInAnyOrderElementsOf(getAllFlags());
   }
 
   private T[] toArray(final int cnt) {
diff --git a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
index 5f88a012..ab76d3fc 100644
--- a/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
+++ b/src/test/java/org/lmdbjava/CursorIterableRangeTest.java
@@ -39,9 +39,7 @@
 import org.junit.jupiter.params.provider.CsvFileSource;
 import org.lmdbjava.CursorIterable.KeyVal;
 
-/**
- * Test {@link CursorIterable}.
- */
+/** Test {@link CursorIterable}. */
 public final class CursorIterableRangeTest {
 
   private static final DbiFlagSet FLAGSET_DUPSORT =
@@ -218,21 +216,24 @@ private void testCSV(
     // We want to assert that the behaviour of all 4 comparator functions
     // is identical.
 
-    final List<Function<DbiBuilder.Stage2<ByteBuffer>, DbiBuilder.Stage3<ByteBuffer>>> comparatorFuncs =
-        new ArrayList<>();
+    final List<Function<DbiBuilder.Stage2<ByteBuffer>, DbiBuilder.Stage3<ByteBuffer>>>
+        comparatorFuncs = new ArrayList<>();
 
     // First test with our default iterator comparator
     comparatorFuncs.add(DbiBuilder.Stage2::withDefaultComparator);
     // Now test with mdp_cmp doing all comparisons, should be the same
     comparatorFuncs.add(DbiBuilder.Stage2::withNativeComparator);
     // Now test with the java callback comparator doing all the work
-    comparatorFuncs.add(byteBufferStage2 ->
-        byteBufferStage2.withCallbackComparator(ByteBufferProxy.PROXY_OPTIMAL::getComparator));
+    comparatorFuncs.add(
+        byteBufferStage2 ->
+            byteBufferStage2.withCallbackComparator(ByteBufferProxy.PROXY_OPTIMAL::getComparator));
     // Now test with the java comparator for iteration only
-    comparatorFuncs.add(byteBufferStage2 ->
-        byteBufferStage2.withIteratorComparator(ByteBufferProxy.PROXY_OPTIMAL::getComparator));
+    comparatorFuncs.add(
+        byteBufferStage2 ->
+            byteBufferStage2.withIteratorComparator(ByteBufferProxy.PROXY_OPTIMAL::getComparator));
 
-    for (Function<DbiBuilder.Stage2<ByteBuffer>, DbiBuilder.Stage3<ByteBuffer>> comparatorFunc : comparatorFuncs) {
+    for (Function<DbiBuilder.Stage2<ByteBuffer>, DbiBuilder.Stage3<ByteBuffer>> comparatorFunc :
+        comparatorFuncs) {
       testCSV(
           comparatorFunc,
           dbPopulator,
@@ -259,12 +260,12 @@ private void testCSV(
     try (final TempDir tempDir = new TempDir()) {
       final Path file = tempDir.createTempFile();
       try (final Env<ByteBuffer> env =
-               create()
-                   .setMapSize(256, ByteUnit.KIBIBYTES)
-                   .setMaxReaders(1)
-                   .setMaxDbs(1)
-                   .setEnvFlags(EnvFlags.MDB_NOSUBDIR)
-                   .open(file)) {
+          create()
+              .setMapSize(256, ByteUnit.KIBIBYTES)
+              .setMaxReaders(1)
+              .setMaxDbs(1)
+              .setEnvFlags(EnvFlags.MDB_NOSUBDIR)
+              .open(file)) {
 
         final DbiBuilder.Stage2<ByteBuffer> builderStage2 = env.createDbi().setDbName(DB_1);
         final DbiBuilder.Stage3<ByteBuffer> builderStage3 = comparatorFunc.apply(builderStage2);
@@ -278,7 +279,7 @@ private void testCSV(
 
           final KeyRange<ByteBuffer> keyRange = new KeyRange<>(keyRangeType, start, stop);
           try (Txn<ByteBuffer> txn = env.txnRead();
-               CursorIterable<ByteBuffer> c = dbi.iterate(txn, keyRange)) {
+              CursorIterable<ByteBuffer> c = dbi.iterate(txn, keyRange)) {
             for (final KeyVal<ByteBuffer> kv : c) {
               final long key = getLong(kv.key(), byteOrder);
               final long val = getLong(kv.val(), ByteOrder.BIG_ENDIAN);
diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index 13a0bfd1..38d8aa53 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -450,9 +450,9 @@ void setMapSize() {
           .isInstanceOf(IllegalArgumentException.class);
 
       assertThatThrownBy(
-          () -> {
-            env.setMapSize(-1);
-          })
+              () -> {
+                env.setMapSize(-1);
+              })
           .isInstanceOf(IllegalArgumentException.class);
 
       env.setMapSize(1024, ByteUnit.KIBIBYTES);
diff --git a/src/test/java/org/lmdbjava/VerifierTest.java b/src/test/java/org/lmdbjava/VerifierTest.java
index 28b48ae4..ee396084 100644
--- a/src/test/java/org/lmdbjava/VerifierTest.java
+++ b/src/test/java/org/lmdbjava/VerifierTest.java
@@ -48,13 +48,11 @@ void verification() {
             .setDbiFlags(DbiFlags.MDB_CREATE)
             .open();
 
-        Assertions.assertThat(env.getDbiNames(Env.DEFAULT_NAME_CHARSET))
-            .containsExactly("db1");
+        Assertions.assertThat(env.getDbiNames(Env.DEFAULT_NAME_CHARSET)).containsExactly("db1");
 
         final Verifier v = new Verifier(env);
 
-        Assertions.assertThat(env.getDbiNames(Env.DEFAULT_NAME_CHARSET))
-            .doesNotContain("db1");
+        Assertions.assertThat(env.getDbiNames(Env.DEFAULT_NAME_CHARSET)).doesNotContain("db1");
 
         final int seconds = Integer.getInteger("verificationSeconds", 2);
         assertThat(v.runFor(seconds, TimeUnit.SECONDS)).isGreaterThan(1L);

From 06523f92d02d788c0cda1cf4a28466ff740a278a Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 14 Nov 2025 16:18:09 +0000
Subject: [PATCH 299/322] Add more tests

---
 src/test/java/org/lmdbjava/EnvTest.java | 88 +++++++++++++++++++++++++
 1 file changed, 88 insertions(+)

diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index 38d8aa53..a54225d8 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -23,6 +23,7 @@
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
 import static org.lmdbjava.Env.Builder.MAX_READERS_DEFAULT;
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
+import static org.lmdbjava.EnvFlags.MDB_NOTLS;
 import static org.lmdbjava.EnvFlags.MDB_RDONLY_ENV;
 import static org.lmdbjava.TestUtils.DB_1;
 import static org.lmdbjava.TestUtils.bb;
@@ -32,8 +33,10 @@
 import java.nio.ByteBuffer;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.util.Collection;
 import java.util.List;
 import java.util.Random;
+import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -557,4 +560,89 @@ void testDefaultOpenNoName2() {
       assertThat(dbiNames.get(1)).isEqualTo("def".getBytes(Env.DEFAULT_NAME_CHARSET));
     }
   }
+
+  @Test
+  void addEnvFlag() {
+    final Path file = tempDir.createTempFile();
+    try (Env<ByteBuffer> env =
+             Env.create()
+                 .setMapSize(1, ByteUnit.MEBIBYTES)
+                 .setMaxDbs(1)
+                 .setMaxReaders(1)
+                 .addEnvFlag(MDB_NOSUBDIR)
+                 .addEnvFlag(MDB_NOTLS) // Should not overwrite the existing one
+                 .open(file)) {
+      env.sync(true);
+      assertThat(Files.isRegularFile(file)).isTrue();
+    }
+  }
+
+  @Test
+  void addEnvFlags() {
+    final Path file = tempDir.createTempFile();
+    try (Env<ByteBuffer> env =
+             Env.create()
+                 .setMapSize(1, ByteUnit.MEBIBYTES)
+                 .setMaxDbs(1)
+                 .setMaxReaders(1)
+                 .addEnvFlags(EnvFlagSet.of(MDB_NOSUBDIR, MDB_NOTLS))
+                 .addEnvFlag(MDB_NOTLS) // Should not overwrite the existing one
+                 .addEnvFlag(null) // no-op
+                 .addEnvFlags(null) // no-op
+                 .open(file)) {
+      env.sync(true);
+      assertThat(Files.isRegularFile(file)).isTrue();
+    }
+  }
+
+  @Test
+  void setEnvFlags_null1() {
+    final Path file = tempDir.createTempFile();
+    // MDB_NOSUBDIR is cleared out so it will error as file is a file not a dir
+    Assertions.assertThatThrownBy(() -> {
+      try (Env<ByteBuffer> env =
+               Env.create()
+                   .setMapSize(1, ByteUnit.MEBIBYTES)
+                   .setMaxDbs(1)
+                   .setMaxReaders(1)
+                   .addEnvFlag(MDB_NOSUBDIR)
+                   .setEnvFlags((Collection<EnvFlags>) null) // Clears the flags
+                   .open(file)) {
+      }
+    }).isInstanceOf(LmdbNativeException.class);
+  }
+
+  @Test
+  void setEnvFlags_null2() {
+    final Path file = tempDir.createTempFile();
+    // MDB_NOSUBDIR is cleared out so it will error as file is a file not a dir
+    Assertions.assertThatThrownBy(() -> {
+      try (Env<ByteBuffer> env =
+               Env.create()
+                   .setMapSize(1, ByteUnit.MEBIBYTES)
+                   .setMaxDbs(1)
+                   .setMaxReaders(1)
+                   .addEnvFlag(MDB_NOSUBDIR)
+                   .setEnvFlags((EnvFlags) null) // Clears the flags
+                   .open(file)) {
+      }
+    }).isInstanceOf(LmdbNativeException.class);
+  }
+
+  @Test
+  void setEnvFlags_null3() {
+    final Path file = tempDir.createTempFile();
+    // MDB_NOSUBDIR is cleared out so it will error as file is a file not a dir
+    Assertions.assertThatThrownBy(() -> {
+      try (Env<ByteBuffer> env =
+               Env.create()
+                   .setMapSize(1, ByteUnit.MEBIBYTES)
+                   .setMaxDbs(1)
+                   .setMaxReaders(1)
+                   .addEnvFlag(MDB_NOSUBDIR)
+                   .setEnvFlags((EnvFlagSet) null) // Clears the flags
+                   .open(file)) {
+      }
+    }).isInstanceOf(LmdbNativeException.class);
+  }
 }

From fe4133869e80afd01f6bba37f2650887eab8e156 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 14 Nov 2025 16:39:46 +0000
Subject: [PATCH 300/322] Add test coverage

---
 .../org/lmdbjava/AbstractFlagSetTest.java     |   7 ++
 src/test/java/org/lmdbjava/EnvTest.java       | 101 +++++++++---------
 2 files changed, 59 insertions(+), 49 deletions(-)

diff --git a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
index 4c7efa1c..54f168cc 100644
--- a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
@@ -90,7 +90,14 @@ void testSingleFlagSet() {
       }
       assertThat(flagSet.toString()).isNotNull();
       assertThat(flag.name()).isNotNull();
+      assertThat(flag.isSet(flag)).isTrue();
+      assertThat(flag.isSet(null)).isFalse();
       assertThat(flagSet.getMaskWith(null)).isEqualTo(flagSet.getMask());
+      assertThat(flag.isEmpty()).isFalse();
+      assertThat(flag.size()).isEqualTo(1);
+
+      assertThat(flag.getFlags()).containsExactlyElementsOf(getFlagSet(flag).getFlags());
+      assertThat(flag.getMask()).isEqualTo(getFlagSet(flag).getMask());
     }
   }
 
diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index a54225d8..3f60076a 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -565,13 +565,13 @@ void testDefaultOpenNoName2() {
   void addEnvFlag() {
     final Path file = tempDir.createTempFile();
     try (Env<ByteBuffer> env =
-             Env.create()
-                 .setMapSize(1, ByteUnit.MEBIBYTES)
-                 .setMaxDbs(1)
-                 .setMaxReaders(1)
-                 .addEnvFlag(MDB_NOSUBDIR)
-                 .addEnvFlag(MDB_NOTLS) // Should not overwrite the existing one
-                 .open(file)) {
+        Env.create()
+            .setMapSize(1, ByteUnit.MEBIBYTES)
+            .setMaxDbs(1)
+            .setMaxReaders(1)
+            .addEnvFlag(MDB_NOSUBDIR)
+            .addEnvFlag(MDB_NOTLS) // Should not overwrite the existing one
+            .open(file)) {
       env.sync(true);
       assertThat(Files.isRegularFile(file)).isTrue();
     }
@@ -581,15 +581,15 @@ void addEnvFlag() {
   void addEnvFlags() {
     final Path file = tempDir.createTempFile();
     try (Env<ByteBuffer> env =
-             Env.create()
-                 .setMapSize(1, ByteUnit.MEBIBYTES)
-                 .setMaxDbs(1)
-                 .setMaxReaders(1)
-                 .addEnvFlags(EnvFlagSet.of(MDB_NOSUBDIR, MDB_NOTLS))
-                 .addEnvFlag(MDB_NOTLS) // Should not overwrite the existing one
-                 .addEnvFlag(null) // no-op
-                 .addEnvFlags(null) // no-op
-                 .open(file)) {
+        Env.create()
+            .setMapSize(1, ByteUnit.MEBIBYTES)
+            .setMaxDbs(1)
+            .setMaxReaders(1)
+            .addEnvFlags(EnvFlagSet.of(MDB_NOSUBDIR, MDB_NOTLS))
+            .addEnvFlag(MDB_NOTLS) // Should not overwrite the existing one
+            .addEnvFlag(null) // no-op
+            .addEnvFlags(null) // no-op
+            .open(file)) {
       env.sync(true);
       assertThat(Files.isRegularFile(file)).isTrue();
     }
@@ -599,50 +599,53 @@ void addEnvFlags() {
   void setEnvFlags_null1() {
     final Path file = tempDir.createTempFile();
     // MDB_NOSUBDIR is cleared out so it will error as file is a file not a dir
-    Assertions.assertThatThrownBy(() -> {
-      try (Env<ByteBuffer> env =
-               Env.create()
-                   .setMapSize(1, ByteUnit.MEBIBYTES)
-                   .setMaxDbs(1)
-                   .setMaxReaders(1)
-                   .addEnvFlag(MDB_NOSUBDIR)
-                   .setEnvFlags((Collection<EnvFlags>) null) // Clears the flags
-                   .open(file)) {
-      }
-    }).isInstanceOf(LmdbNativeException.class);
+    Assertions.assertThatThrownBy(
+            () -> {
+              try (Env<ByteBuffer> env =
+                  Env.create()
+                      .setMapSize(1, ByteUnit.MEBIBYTES)
+                      .setMaxDbs(1)
+                      .setMaxReaders(1)
+                      .addEnvFlag(MDB_NOSUBDIR)
+                      .setEnvFlags((Collection<EnvFlags>) null) // Clears the flags
+                      .open(file)) {}
+            })
+        .isInstanceOf(LmdbNativeException.class);
   }
 
   @Test
   void setEnvFlags_null2() {
     final Path file = tempDir.createTempFile();
     // MDB_NOSUBDIR is cleared out so it will error as file is a file not a dir
-    Assertions.assertThatThrownBy(() -> {
-      try (Env<ByteBuffer> env =
-               Env.create()
-                   .setMapSize(1, ByteUnit.MEBIBYTES)
-                   .setMaxDbs(1)
-                   .setMaxReaders(1)
-                   .addEnvFlag(MDB_NOSUBDIR)
-                   .setEnvFlags((EnvFlags) null) // Clears the flags
-                   .open(file)) {
-      }
-    }).isInstanceOf(LmdbNativeException.class);
+    Assertions.assertThatThrownBy(
+            () -> {
+              try (Env<ByteBuffer> env =
+                  Env.create()
+                      .setMapSize(1, ByteUnit.MEBIBYTES)
+                      .setMaxDbs(1)
+                      .setMaxReaders(1)
+                      .addEnvFlag(MDB_NOSUBDIR)
+                      .setEnvFlags((EnvFlags) null) // Clears the flags
+                      .open(file)) {}
+            })
+        .isInstanceOf(LmdbNativeException.class);
   }
 
   @Test
   void setEnvFlags_null3() {
     final Path file = tempDir.createTempFile();
     // MDB_NOSUBDIR is cleared out so it will error as file is a file not a dir
-    Assertions.assertThatThrownBy(() -> {
-      try (Env<ByteBuffer> env =
-               Env.create()
-                   .setMapSize(1, ByteUnit.MEBIBYTES)
-                   .setMaxDbs(1)
-                   .setMaxReaders(1)
-                   .addEnvFlag(MDB_NOSUBDIR)
-                   .setEnvFlags((EnvFlagSet) null) // Clears the flags
-                   .open(file)) {
-      }
-    }).isInstanceOf(LmdbNativeException.class);
+    Assertions.assertThatThrownBy(
+            () -> {
+              try (Env<ByteBuffer> env =
+                  Env.create()
+                      .setMapSize(1, ByteUnit.MEBIBYTES)
+                      .setMaxDbs(1)
+                      .setMaxReaders(1)
+                      .addEnvFlag(MDB_NOSUBDIR)
+                      .setEnvFlags((EnvFlagSet) null) // Clears the flags
+                      .open(file)) {}
+            })
+        .isInstanceOf(LmdbNativeException.class);
   }
 }

From 38eac0d5b4791ae40c2ee23d093819a7c26f02ad Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 14 Nov 2025 17:42:58 +0000
Subject: [PATCH 301/322] Add ByteBufProxyTest, refactor some test classes

---
 .../java/org/lmdbjava/ByteBufProxyTest.java   | 150 ++++++++++++++++++
 .../org/lmdbjava/ByteBufferProxyTest.java     |  61 ++++++-
 .../lmdbjava/ComparatorIntegerKeyTest.java    |  73 +++++----
 .../java/org/lmdbjava/ComparatorResult.java   |  25 +++
 .../java/org/lmdbjava/ComparatorTest.java     | 113 +++++++------
 src/test/java/org/lmdbjava/CompareType.java   |   8 +
 src/test/java/org/lmdbjava/TestUtils.java     |   7 +
 7 files changed, 347 insertions(+), 90 deletions(-)
 create mode 100644 src/test/java/org/lmdbjava/ByteBufProxyTest.java
 create mode 100644 src/test/java/org/lmdbjava/ComparatorResult.java
 create mode 100644 src/test/java/org/lmdbjava/CompareType.java

diff --git a/src/test/java/org/lmdbjava/ByteBufProxyTest.java b/src/test/java/org/lmdbjava/ByteBufProxyTest.java
new file mode 100644
index 00000000..245c7b4d
--- /dev/null
+++ b/src/test/java/org/lmdbjava/ByteBufProxyTest.java
@@ -0,0 +1,150 @@
+package org.lmdbjava;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.PooledByteBufAllocator;
+import java.nio.ByteOrder;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.Random;
+import java.util.Set;
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+class ByteBufProxyTest {
+
+  @Test
+  public void verifyComparators_int() {
+    final Random random = new Random(203948);
+    final ByteBufProxy byteBufProxy = new ByteBufProxy(PooledByteBufAllocator.DEFAULT);
+    final ByteBuf buffer1native = byteBufProxy.allocate().capacity(Integer.BYTES);
+    final ByteBuf buffer2native = byteBufProxy.allocate().capacity(Integer.BYTES);
+    final ByteBuf buffer1be = byteBufProxy.allocate().capacity(Integer.BYTES);
+    final ByteBuf buffer2be = byteBufProxy.allocate().capacity(Integer.BYTES);
+    final int[] values = random.ints().filter(i -> i >= 0).limit(5_000_000).toArray();
+
+    final LinkedHashMap<CompareType, Comparator<ByteBuf>> comparators = new LinkedHashMap<>();
+    comparators.put(CompareType.INTEGER_KEY, ByteBufProxy::compareAsIntegerKeys);
+    comparators.put(CompareType.LEXICOGRAPHIC, ByteBufProxy::compareLexicographically);
+
+    final LinkedHashMap<CompareType, ComparatorResult> results =
+        new LinkedHashMap<>(comparators.size());
+    final Set<ComparatorResult> uniqueResults = new HashSet<>(comparators.size());
+
+    for (int i = 1; i < values.length; i++) {
+      resetBuffer(buffer1native);
+      resetBuffer(buffer2native);
+      resetBuffer(buffer1be);
+      resetBuffer(buffer2be);
+
+      final int val1 = values[i - 1];
+      final int val2 = values[i];
+      if (ByteOrder.nativeOrder() == ByteOrder.LITTLE_ENDIAN) {
+        buffer1native.writeIntLE(val1);
+        buffer2native.writeIntLE(val2);
+      } else {
+        buffer1native.writeInt(val1);
+        buffer2native.writeInt(val2);
+      }
+      buffer1be.writeInt(val1);
+      buffer2be.writeInt(val2);
+
+      Assertions.assertThat(buffer1native.readableBytes()).isEqualTo(Integer.BYTES);
+      Assertions.assertThat(buffer2native.readableBytes()).isEqualTo(Integer.BYTES);
+      Assertions.assertThat(buffer1be.readableBytes()).isEqualTo(Integer.BYTES);
+      Assertions.assertThat(buffer2be.readableBytes()).isEqualTo(Integer.BYTES);
+
+      uniqueResults.clear();
+
+      // Make sure all comparators give the same result for the same inputs
+      comparators.forEach(
+          (compareType, comparator) -> {
+            final ComparatorResult result;
+            // IntegerKey comparator expects keys to have been written in native order so need
+            // different buffers.
+            if (compareType == CompareType.INTEGER_KEY) {
+              result = TestUtils.compare(comparator, buffer1native, buffer2native);
+            } else {
+              result = TestUtils.compare(comparator, buffer1be, buffer2be);
+            }
+            results.put(compareType, result);
+            uniqueResults.add(result);
+          });
+
+      if (uniqueResults.size() != 1) {
+        Assertions.fail(
+            "Comparator mismatch for values: " + val1 + " and " + val2 + ". Results: " + results);
+      }
+    }
+  }
+
+  @Test
+  public void verifyComparators_long() {
+    final Random random = new Random(203948);
+    final ByteBufProxy byteBufProxy = new ByteBufProxy(PooledByteBufAllocator.DEFAULT);
+    final ByteBuf buffer1native = byteBufProxy.allocate().capacity(Long.BYTES);
+    final ByteBuf buffer2native = byteBufProxy.allocate().capacity(Long.BYTES);
+    final ByteBuf buffer1be = byteBufProxy.allocate().capacity(Long.BYTES);
+    final ByteBuf buffer2be = byteBufProxy.allocate().capacity(Long.BYTES);
+    final long[] values = random.longs().filter(i -> i >= 0).limit(5_000_000).toArray();
+
+    final LinkedHashMap<CompareType, Comparator<ByteBuf>> comparators = new LinkedHashMap<>();
+    comparators.put(CompareType.INTEGER_KEY, ByteBufProxy::compareAsIntegerKeys);
+    comparators.put(CompareType.LEXICOGRAPHIC, ByteBufProxy::compareLexicographically);
+
+    final LinkedHashMap<CompareType, ComparatorResult> results =
+        new LinkedHashMap<>(comparators.size());
+    final Set<ComparatorResult> uniqueResults = new HashSet<>(comparators.size());
+
+    for (int i = 1; i < values.length; i++) {
+      resetBuffer(buffer1native);
+      resetBuffer(buffer2native);
+      resetBuffer(buffer1be);
+      resetBuffer(buffer2be);
+
+      final long val1 = values[i - 1];
+      final long val2 = values[i];
+      if (ByteOrder.nativeOrder() == ByteOrder.LITTLE_ENDIAN) {
+        buffer1native.writeLongLE(val1);
+        buffer2native.writeLongLE(val2);
+      } else {
+        buffer1native.writeLong(val1);
+        buffer2native.writeLong(val2);
+      }
+      buffer1be.writeLong(val1);
+      buffer2be.writeLong(val2);
+
+      Assertions.assertThat(buffer1native.readableBytes()).isEqualTo(Long.BYTES);
+      Assertions.assertThat(buffer2native.readableBytes()).isEqualTo(Long.BYTES);
+      Assertions.assertThat(buffer1be.readableBytes()).isEqualTo(Long.BYTES);
+      Assertions.assertThat(buffer2be.readableBytes()).isEqualTo(Long.BYTES);
+
+      uniqueResults.clear();
+
+      // Make sure all comparators give the same result for the same inputs
+      comparators.forEach(
+          (compareType, comparator) -> {
+            final ComparatorResult result;
+            // IntegerKey comparator expects keys to have been written in native order so need
+            // different buffers.
+            if (compareType == CompareType.INTEGER_KEY) {
+              result = TestUtils.compare(comparator, buffer1native, buffer2native);
+            } else {
+              result = TestUtils.compare(comparator, buffer1be, buffer2be);
+            }
+            results.put(compareType, result);
+            uniqueResults.add(result);
+          });
+
+      if (uniqueResults.size() != 1) {
+        Assertions.fail(
+            "Comparator mismatch for values: " + val1 + " and " + val2 + ". Results: " + results);
+      }
+    }
+  }
+
+  private static void resetBuffer(ByteBuf buffer1native) {
+    buffer1native.resetReaderIndex();
+    buffer1native.resetWriterIndex();
+  }
+}
diff --git a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
index b72393dc..2e4ed823 100644
--- a/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
+++ b/src/test/java/org/lmdbjava/ByteBufferProxyTest.java
@@ -191,7 +191,66 @@ public void comparatorPerformance() {
   }
 
   @Test
-  public void verifyComparators() {
+  public void verifyComparators_int() {
+    final Random random = new Random(203948);
+    final ByteBuffer buffer1native =
+        ByteBuffer.allocateDirect(Integer.BYTES).order(ByteOrder.nativeOrder());
+    final ByteBuffer buffer2native =
+        ByteBuffer.allocateDirect(Integer.BYTES).order(ByteOrder.nativeOrder());
+    final ByteBuffer buffer1be = ByteBuffer.allocateDirect(Integer.BYTES).order(BIG_ENDIAN);
+    final ByteBuffer buffer2be = ByteBuffer.allocateDirect(Integer.BYTES).order(BIG_ENDIAN);
+    buffer1native.limit(Integer.BYTES);
+    buffer2native.limit(Integer.BYTES);
+    buffer1be.limit(Integer.BYTES);
+    buffer2be.limit(Integer.BYTES);
+    final int[] values = random.ints().filter(i -> i >= 0).limit(5_000_000).toArray();
+    //    System.out.println("stats: " + Arrays.stream(values)
+    //        .summaryStatistics()
+    //        .toString());
+
+    final LinkedHashMap<String, Comparator<ByteBuffer>> comparators = new LinkedHashMap<>();
+    comparators.put(
+        "compareAsIntegerKeys", ByteBufferProxy.AbstractByteBufferProxy::compareAsIntegerKeys);
+    comparators.put(
+        "compareLexicographically",
+        ByteBufferProxy.AbstractByteBufferProxy::compareLexicographically);
+
+    final LinkedHashMap<String, Integer> results = new LinkedHashMap<>(comparators.size());
+    final Set<Integer> uniqueResults = new HashSet<>(comparators.size());
+
+    for (int i = 1; i < values.length; i++) {
+      final int val1 = values[i - 1];
+      final int val2 = values[i];
+      buffer1native.putInt(0, val1);
+      buffer2native.putInt(0, val2);
+      buffer1be.putInt(0, val1);
+      buffer2be.putInt(0, val2);
+      uniqueResults.clear();
+
+      // Make sure all comparators give the same result for the same inputs
+      comparators.forEach(
+          (name, comparator) -> {
+            final int result;
+            // IntegerKey comparator expects keys to have been written in native order so need
+            // different buffers.
+            if (name.equals("compareAsIntegerKeys")) {
+              result = comparator.compare(buffer1native, buffer2native);
+            } else {
+              result = comparator.compare(buffer1be, buffer2be);
+            }
+            results.put(name, result);
+            uniqueResults.add(result);
+          });
+
+      if (uniqueResults.size() != 1) {
+        Assertions.fail(
+            "Comparator mismatch for values: " + val1 + " and " + val2 + ". Results: " + results);
+      }
+    }
+  }
+
+  @Test
+  public void verifyComparators_long() {
     final Random random = new Random(203948);
     final ByteBuffer buffer1native =
         ByteBuffer.allocateDirect(Long.BYTES).order(ByteOrder.nativeOrder());
diff --git a/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java b/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java
index dbe00fa0..66aaaede 100644
--- a/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java
+++ b/src/test/java/org/lmdbjava/ComparatorIntegerKeyTest.java
@@ -20,10 +20,9 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.lmdbjava.ByteBufProxy.PROXY_NETTY;
 import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
-import static org.lmdbjava.ComparatorTest.ComparatorResult.EQUAL_TO;
-import static org.lmdbjava.ComparatorTest.ComparatorResult.GREATER_THAN;
-import static org.lmdbjava.ComparatorTest.ComparatorResult.LESS_THAN;
-import static org.lmdbjava.ComparatorTest.ComparatorResult.get;
+import static org.lmdbjava.ComparatorResult.EQUAL_TO;
+import static org.lmdbjava.ComparatorResult.GREATER_THAN;
+import static org.lmdbjava.ComparatorResult.LESS_THAN;
 import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
 
 import io.netty.buffer.ByteBuf;
@@ -57,40 +56,50 @@ private static byte[] buffer(final int... bytes) {
     return array;
   }
 
+  private ComparatorResult compare(
+      final ComparatorRunner comparatorRunner, final long o1, final long o2) {
+    return ComparatorResult.get(comparatorRunner.compare(o1, o2));
+  }
+
+  private ComparatorResult compare(
+      final ComparatorRunner comparatorRunner, final int o1, final int o2) {
+    return ComparatorResult.get(comparatorRunner.compare(o1, o2));
+  }
+
   @ParameterizedTest
   @MethodSource("comparatorProvider")
   void testLong(final ComparatorRunner comparator) {
 
-    assertThat(get(comparator.compare(0L, 0L))).isEqualTo(EQUAL_TO);
-    assertThat(get(comparator.compare(Long.MAX_VALUE, Long.MAX_VALUE))).isEqualTo(EQUAL_TO);
+    assertThat(compare(comparator, 0L, 0L)).isEqualTo(EQUAL_TO);
+    assertThat(compare(comparator, Long.MAX_VALUE, Long.MAX_VALUE)).isEqualTo(EQUAL_TO);
 
-    assertThat(get(comparator.compare(0L, 1L))).isEqualTo(LESS_THAN);
-    assertThat(get(comparator.compare(0L, Long.MAX_VALUE))).isEqualTo(LESS_THAN);
-    assertThat(get(comparator.compare(0L, 10L))).isEqualTo(LESS_THAN);
-    assertThat(get(comparator.compare(10L, 100L))).isEqualTo(LESS_THAN);
-    assertThat(get(comparator.compare(10L, 100L))).isEqualTo(LESS_THAN);
-    assertThat(get(comparator.compare(10L, 1000L))).isEqualTo(LESS_THAN);
+    assertThat(compare(comparator, 0L, 1L)).isEqualTo(LESS_THAN);
+    assertThat(compare(comparator, 0L, Long.MAX_VALUE)).isEqualTo(LESS_THAN);
+    assertThat(compare(comparator, 0L, 10L)).isEqualTo(LESS_THAN);
+    assertThat(compare(comparator, 10L, 100L)).isEqualTo(LESS_THAN);
+    assertThat(compare(comparator, 10L, 100L)).isEqualTo(LESS_THAN);
+    assertThat(compare(comparator, 10L, 1000L)).isEqualTo(LESS_THAN);
 
-    assertThat(get(comparator.compare(1L, 0L))).isEqualTo(GREATER_THAN);
-    assertThat(get(comparator.compare(Long.MAX_VALUE, 0L))).isEqualTo(GREATER_THAN);
+    assertThat(compare(comparator, 1L, 0L)).isEqualTo(GREATER_THAN);
+    assertThat(compare(comparator, Long.MAX_VALUE, 0L)).isEqualTo(GREATER_THAN);
   }
 
   @ParameterizedTest
   @MethodSource("comparatorProvider")
   void testInt(final ComparatorRunner comparator) {
 
-    assertThat(get(comparator.compare(0, 0))).isEqualTo(EQUAL_TO);
-    assertThat(get(comparator.compare(Integer.MAX_VALUE, Integer.MAX_VALUE))).isEqualTo(EQUAL_TO);
+    assertThat(compare(comparator, 0, 0)).isEqualTo(EQUAL_TO);
+    assertThat(compare(comparator, Integer.MAX_VALUE, Integer.MAX_VALUE)).isEqualTo(EQUAL_TO);
 
-    assertThat(get(comparator.compare(0, 1))).isEqualTo(LESS_THAN);
-    assertThat(get(comparator.compare(0, Integer.MAX_VALUE))).isEqualTo(LESS_THAN);
-    assertThat(get(comparator.compare(0, 10))).isEqualTo(LESS_THAN);
-    assertThat(get(comparator.compare(10, 100))).isEqualTo(LESS_THAN);
-    assertThat(get(comparator.compare(10, 100))).isEqualTo(LESS_THAN);
-    assertThat(get(comparator.compare(10, 1000))).isEqualTo(LESS_THAN);
+    assertThat(compare(comparator, 0, 1)).isEqualTo(LESS_THAN);
+    assertThat(compare(comparator, 0, Integer.MAX_VALUE)).isEqualTo(LESS_THAN);
+    assertThat(compare(comparator, 0, 10)).isEqualTo(LESS_THAN);
+    assertThat(compare(comparator, 10, 100)).isEqualTo(LESS_THAN);
+    assertThat(compare(comparator, 10, 100)).isEqualTo(LESS_THAN);
+    assertThat(compare(comparator, 10, 1000)).isEqualTo(LESS_THAN);
 
-    assertThat(get(comparator.compare(1, 0))).isEqualTo(GREATER_THAN);
-    assertThat(get(comparator.compare(Integer.MAX_VALUE, 0))).isEqualTo(GREATER_THAN);
+    assertThat(compare(comparator, 1, 0)).isEqualTo(GREATER_THAN);
+    assertThat(compare(comparator, Integer.MAX_VALUE, 0)).isEqualTo(GREATER_THAN);
   }
 
   @ParameterizedTest
@@ -105,8 +114,8 @@ void testRandomLong(final ComparatorRunner runner) {
       final long long1 = values[i - 1];
       final long long2 = values[i];
       // Make sure the comparator under test gives the same outcome as just comparing two longs
-      final ComparatorTest.ComparatorResult result = get(runner.compare(long1, long2));
-      final ComparatorTest.ComparatorResult expectedResult = get(Long.compare(long1, long2));
+      final ComparatorResult result = ComparatorResult.get(runner.compare(long1, long2));
+      final ComparatorResult expectedResult = ComparatorResult.get(Long.compare(long1, long2));
 
       assertThat(result)
           .withFailMessage(
@@ -121,8 +130,8 @@ void testRandomLong(final ComparatorRunner runner) {
                       + result)
           .isEqualTo(expectedResult);
 
-      final ComparatorTest.ComparatorResult result2 = get(runner.compare(long2, long1));
-      final ComparatorTest.ComparatorResult expectedResult2 = expectedResult.opposite();
+      final ComparatorResult result2 = ComparatorResult.get(runner.compare(long2, long1));
+      final ComparatorResult expectedResult2 = expectedResult.opposite();
 
       assertThat(result)
           .withFailMessage(
@@ -151,8 +160,8 @@ void testRandomInt(final ComparatorRunner runner) {
       final int int1 = values[i - 1];
       final int int2 = values[i];
       // Make sure the comparator under test gives the same outcome as just comparing two ints
-      final ComparatorTest.ComparatorResult result = get(runner.compare(int1, int2));
-      final ComparatorTest.ComparatorResult expectedResult = get(Integer.compare(int1, int2));
+      final ComparatorResult result = ComparatorResult.get(runner.compare(int1, int2));
+      final ComparatorResult expectedResult = ComparatorResult.get(Integer.compare(int1, int2));
 
       assertThat(result)
           .withFailMessage(
@@ -167,8 +176,8 @@ void testRandomInt(final ComparatorRunner runner) {
                       + result)
           .isEqualTo(expectedResult);
 
-      final ComparatorTest.ComparatorResult result2 = get(runner.compare(int2, int1));
-      final ComparatorTest.ComparatorResult expectedResult2 = expectedResult.opposite();
+      final ComparatorResult result2 = ComparatorResult.get(runner.compare(int2, int1));
+      final ComparatorResult expectedResult2 = expectedResult.opposite();
 
       assertThat(result)
           .withFailMessage(
diff --git a/src/test/java/org/lmdbjava/ComparatorResult.java b/src/test/java/org/lmdbjava/ComparatorResult.java
new file mode 100644
index 00000000..ac7feb12
--- /dev/null
+++ b/src/test/java/org/lmdbjava/ComparatorResult.java
@@ -0,0 +1,25 @@
+package org.lmdbjava;
+
+/** Converts an integer result code into its contractual meaning. */
+enum ComparatorResult {
+  LESS_THAN,
+  EQUAL_TO,
+  GREATER_THAN;
+
+  static ComparatorResult get(final int comparatorResult) {
+    if (comparatorResult == 0) {
+      return EQUAL_TO;
+    }
+    return comparatorResult < 0 ? LESS_THAN : GREATER_THAN;
+  }
+
+  ComparatorResult opposite() {
+    if (this == LESS_THAN) {
+      return GREATER_THAN;
+    } else if (this == GREATER_THAN) {
+      return LESS_THAN;
+    } else {
+      return EQUAL_TO;
+    }
+  }
+}
diff --git a/src/test/java/org/lmdbjava/ComparatorTest.java b/src/test/java/org/lmdbjava/ComparatorTest.java
index f255ec2a..fbde37c3 100644
--- a/src/test/java/org/lmdbjava/ComparatorTest.java
+++ b/src/test/java/org/lmdbjava/ComparatorTest.java
@@ -22,10 +22,9 @@
 import static org.lmdbjava.ByteArrayProxy.PROXY_BA;
 import static org.lmdbjava.ByteBufProxy.PROXY_NETTY;
 import static org.lmdbjava.ByteBufferProxy.PROXY_OPTIMAL;
-import static org.lmdbjava.ComparatorTest.ComparatorResult.EQUAL_TO;
-import static org.lmdbjava.ComparatorTest.ComparatorResult.GREATER_THAN;
-import static org.lmdbjava.ComparatorTest.ComparatorResult.LESS_THAN;
-import static org.lmdbjava.ComparatorTest.ComparatorResult.get;
+import static org.lmdbjava.ComparatorResult.EQUAL_TO;
+import static org.lmdbjava.ComparatorResult.GREATER_THAN;
+import static org.lmdbjava.ComparatorResult.LESS_THAN;
 import static org.lmdbjava.DirectBufferProxy.PROXY_DB;
 
 import com.google.common.primitives.SignedBytes;
@@ -87,52 +86,52 @@ private static byte[] buffer(final int... bytes) {
   @ParameterizedTest
   @ArgumentsSource(MyArgumentProvider.class)
   void atLeastOneBufferHasEightBytes(final ComparatorRunner comparator) {
-    assertThat(get(comparator.compare(HLLLLLLL, LLLLLLLL))).isEqualTo(GREATER_THAN);
-    assertThat(get(comparator.compare(LLLLLLLL, HLLLLLLL))).isEqualTo(LESS_THAN);
+    assertThat(TestUtils.compare(comparator, HLLLLLLL, LLLLLLLL)).isEqualTo(GREATER_THAN);
+    assertThat(TestUtils.compare(comparator, LLLLLLLL, HLLLLLLL)).isEqualTo(LESS_THAN);
 
-    assertThat(get(comparator.compare(LHLLLLLL, LLLLLLLL))).isEqualTo(GREATER_THAN);
-    assertThat(get(comparator.compare(LLLLLLLL, LHLLLLLL))).isEqualTo(LESS_THAN);
+    assertThat(TestUtils.compare(comparator, LHLLLLLL, LLLLLLLL)).isEqualTo(GREATER_THAN);
+    assertThat(TestUtils.compare(comparator, LLLLLLLL, LHLLLLLL)).isEqualTo(LESS_THAN);
 
-    assertThat(get(comparator.compare(LLLLLLLL, LLLLLLLX))).isEqualTo(GREATER_THAN);
-    assertThat(get(comparator.compare(LLLLLLLX, LLLLLLLL))).isEqualTo(LESS_THAN);
+    assertThat(TestUtils.compare(comparator, LLLLLLLL, LLLLLLLX)).isEqualTo(GREATER_THAN);
+    assertThat(TestUtils.compare(comparator, LLLLLLLX, LLLLLLLL)).isEqualTo(LESS_THAN);
 
-    assertThat(get(comparator.compare(HLLLLLLL, HLLLLLLX))).isEqualTo(GREATER_THAN);
-    assertThat(get(comparator.compare(HLLLLLLX, HLLLLLLL))).isEqualTo(LESS_THAN);
+    assertThat(TestUtils.compare(comparator, HLLLLLLL, HLLLLLLX)).isEqualTo(GREATER_THAN);
+    assertThat(TestUtils.compare(comparator, HLLLLLLX, HLLLLLLL)).isEqualTo(LESS_THAN);
 
-    assertThat(get(comparator.compare(HLLLLLLX, LHLLLLLL))).isEqualTo(GREATER_THAN);
-    assertThat(get(comparator.compare(LHLLLLLL, HLLLLLLX))).isEqualTo(LESS_THAN);
+    assertThat(TestUtils.compare(comparator, HLLLLLLX, LHLLLLLL)).isEqualTo(GREATER_THAN);
+    assertThat(TestUtils.compare(comparator, LHLLLLLL, HLLLLLLX)).isEqualTo(LESS_THAN);
   }
 
   @ParameterizedTest
   @ArgumentsSource(MyArgumentProvider.class)
   void buffersOfTwoBytes(final ComparatorRunner comparator) {
-    assertThat(get(comparator.compare(LL, XX))).isEqualTo(GREATER_THAN);
-    assertThat(get(comparator.compare(XX, LL))).isEqualTo(LESS_THAN);
+    assertThat(TestUtils.compare(comparator, LL, XX)).isEqualTo(GREATER_THAN);
+    assertThat(TestUtils.compare(comparator, XX, LL)).isEqualTo(LESS_THAN);
 
-    assertThat(get(comparator.compare(LL, LX))).isEqualTo(GREATER_THAN);
-    assertThat(get(comparator.compare(LX, LL))).isEqualTo(LESS_THAN);
+    assertThat(TestUtils.compare(comparator, LL, LX)).isEqualTo(GREATER_THAN);
+    assertThat(TestUtils.compare(comparator, LX, LL)).isEqualTo(LESS_THAN);
 
-    assertThat(get(comparator.compare(LH, LX))).isEqualTo(GREATER_THAN);
-    assertThat(get(comparator.compare(LX, HL))).isEqualTo(LESS_THAN);
+    assertThat(TestUtils.compare(comparator, LH, LX)).isEqualTo(GREATER_THAN);
+    assertThat(TestUtils.compare(comparator, LX, HL)).isEqualTo(LESS_THAN);
 
-    assertThat(get(comparator.compare(HX, LL))).isEqualTo(GREATER_THAN);
-    assertThat(get(comparator.compare(LH, HX))).isEqualTo(LESS_THAN);
+    assertThat(TestUtils.compare(comparator, HX, LL)).isEqualTo(GREATER_THAN);
+    assertThat(TestUtils.compare(comparator, LH, HX)).isEqualTo(LESS_THAN);
   }
 
   @ParameterizedTest
   @ArgumentsSource(MyArgumentProvider.class)
   void equalBuffers(final ComparatorRunner comparator) {
-    assertThat(get(comparator.compare(LL, LL))).isEqualTo(EQUAL_TO);
-    assertThat(get(comparator.compare(HX, HX))).isEqualTo(EQUAL_TO);
-    assertThat(get(comparator.compare(LH, LH))).isEqualTo(EQUAL_TO);
-    assertThat(get(comparator.compare(LL, LL))).isEqualTo(EQUAL_TO);
-    assertThat(get(comparator.compare(LX, LX))).isEqualTo(EQUAL_TO);
-
-    assertThat(get(comparator.compare(HLLLLLLL, HLLLLLLL))).isEqualTo(EQUAL_TO);
-    assertThat(get(comparator.compare(HLLLLLLX, HLLLLLLX))).isEqualTo(EQUAL_TO);
-    assertThat(get(comparator.compare(LHLLLLLL, LHLLLLLL))).isEqualTo(EQUAL_TO);
-    assertThat(get(comparator.compare(LLLLLLLL, LLLLLLLL))).isEqualTo(EQUAL_TO);
-    assertThat(get(comparator.compare(LLLLLLLX, LLLLLLLX))).isEqualTo(EQUAL_TO);
+    assertThat(TestUtils.compare(comparator, LL, LL)).isEqualTo(EQUAL_TO);
+    assertThat(TestUtils.compare(comparator, HX, HX)).isEqualTo(EQUAL_TO);
+    assertThat(TestUtils.compare(comparator, LH, LH)).isEqualTo(EQUAL_TO);
+    assertThat(TestUtils.compare(comparator, LL, LL)).isEqualTo(EQUAL_TO);
+    assertThat(TestUtils.compare(comparator, LX, LX)).isEqualTo(EQUAL_TO);
+
+    assertThat(TestUtils.compare(comparator, HLLLLLLL, HLLLLLLL)).isEqualTo(EQUAL_TO);
+    assertThat(TestUtils.compare(comparator, HLLLLLLX, HLLLLLLX)).isEqualTo(EQUAL_TO);
+    assertThat(TestUtils.compare(comparator, LHLLLLLL, LHLLLLLL)).isEqualTo(EQUAL_TO);
+    assertThat(TestUtils.compare(comparator, LLLLLLLL, LLLLLLLL)).isEqualTo(EQUAL_TO);
+    assertThat(TestUtils.compare(comparator, LLLLLLLX, LLLLLLLX)).isEqualTo(EQUAL_TO);
   }
 
   /** Tests {@link ByteArrayProxy}. */
@@ -257,32 +256,32 @@ public int compare(final byte[] o1, final byte[] o2) {
     }
   }
 
-  /** Converts an integer result code into its contractual meaning. */
-  enum ComparatorResult {
-    LESS_THAN,
-    EQUAL_TO,
-    GREATER_THAN;
-
-    static ComparatorResult get(final int comparatorResult) {
-      if (comparatorResult == 0) {
-        return EQUAL_TO;
-      }
-      return comparatorResult < 0 ? LESS_THAN : GREATER_THAN;
-    }
-
-    ComparatorResult opposite() {
-      if (this == LESS_THAN) {
-        return GREATER_THAN;
-      } else if (this == GREATER_THAN) {
-        return LESS_THAN;
-      } else {
-        return EQUAL_TO;
-      }
-    }
-  }
+  //  /** Converts an integer result code into its contractual meaning. */
+  //  enum ComparatorResult {
+  //    LESS_THAN,
+  //    EQUAL_TO,
+  //    GREATER_THAN;
+  //
+  //    static ComparatorResult get(final int comparatorResult) {
+  //      if (comparatorResult == 0) {
+  //        return EQUAL_TO;
+  //      }
+  //      return comparatorResult < 0 ? LESS_THAN : GREATER_THAN;
+  //    }
+  //
+  //    ComparatorResult opposite() {
+  //      if (this == LESS_THAN) {
+  //        return GREATER_THAN;
+  //      } else if (this == GREATER_THAN) {
+  //        return LESS_THAN;
+  //      } else {
+  //        return EQUAL_TO;
+  //      }
+  //    }
+  //  }
 
   /** Interface that can test a {@link BufferProxy} <code>compare</code> method. */
-  private interface ComparatorRunner {
+  private interface ComparatorRunner extends Comparator<byte[]> {
 
     /**
      * Convert the passed byte arrays into the proxy's relevant buffer type and then invoke the
diff --git a/src/test/java/org/lmdbjava/CompareType.java b/src/test/java/org/lmdbjava/CompareType.java
new file mode 100644
index 00000000..22023815
--- /dev/null
+++ b/src/test/java/org/lmdbjava/CompareType.java
@@ -0,0 +1,8 @@
+package org.lmdbjava;
+
+enum CompareType {
+  /** int and long keys */
+  INTEGER_KEY,
+  LEXICOGRAPHIC,
+  ;
+}
diff --git a/src/test/java/org/lmdbjava/TestUtils.java b/src/test/java/org/lmdbjava/TestUtils.java
index 1dd04d50..a15dc6b2 100644
--- a/src/test/java/org/lmdbjava/TestUtils.java
+++ b/src/test/java/org/lmdbjava/TestUtils.java
@@ -24,6 +24,7 @@
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 import java.nio.charset.StandardCharsets;
+import java.util.Comparator;
 import java.util.Objects;
 import java.util.function.Consumer;
 import java.util.function.Function;
@@ -195,4 +196,10 @@ static <T, R> R getWithWriteTxn(final Env<T> env, final Function<Txn<T>, R> work
       return work.apply(readTxn);
     }
   }
+
+  static <T> ComparatorResult compare(final Comparator<T> comparator, final T o1, final T o2) {
+    Objects.requireNonNull(comparator);
+    final int result = comparator.compare(o1, o2);
+    return ComparatorResult.get(result);
+  }
 }

From 53ac34d8ca049a8730d552868afc2982fc5a765e Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 14 Nov 2025 17:45:26 +0000
Subject: [PATCH 302/322] Add missing licences

---
 src/test/java/org/lmdbjava/ByteBufProxyTest.java | 15 +++++++++++++++
 src/test/java/org/lmdbjava/ComparatorResult.java | 15 +++++++++++++++
 src/test/java/org/lmdbjava/CompareType.java      | 15 +++++++++++++++
 3 files changed, 45 insertions(+)

diff --git a/src/test/java/org/lmdbjava/ByteBufProxyTest.java b/src/test/java/org/lmdbjava/ByteBufProxyTest.java
index 245c7b4d..92a6b493 100644
--- a/src/test/java/org/lmdbjava/ByteBufProxyTest.java
+++ b/src/test/java/org/lmdbjava/ByteBufProxyTest.java
@@ -1,3 +1,18 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package org.lmdbjava;
 
 import io.netty.buffer.ByteBuf;
diff --git a/src/test/java/org/lmdbjava/ComparatorResult.java b/src/test/java/org/lmdbjava/ComparatorResult.java
index ac7feb12..56140752 100644
--- a/src/test/java/org/lmdbjava/ComparatorResult.java
+++ b/src/test/java/org/lmdbjava/ComparatorResult.java
@@ -1,3 +1,18 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package org.lmdbjava;
 
 /** Converts an integer result code into its contractual meaning. */
diff --git a/src/test/java/org/lmdbjava/CompareType.java b/src/test/java/org/lmdbjava/CompareType.java
index 22023815..bd40bbf4 100644
--- a/src/test/java/org/lmdbjava/CompareType.java
+++ b/src/test/java/org/lmdbjava/CompareType.java
@@ -1,3 +1,18 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package org.lmdbjava;
 
 enum CompareType {

From 5ad4f0c7ee1daa7ce704970a9a95087b08a1801f Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Fri, 14 Nov 2025 17:58:25 +0000
Subject: [PATCH 303/322] Add test assert

---
 src/test/java/org/lmdbjava/AbstractFlagSetTest.java | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
index 54f168cc..a886d9e1 100644
--- a/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/AbstractFlagSetTest.java
@@ -97,6 +97,7 @@ void testSingleFlagSet() {
       assertThat(flag.size()).isEqualTo(1);
 
       assertThat(flag.getFlags()).containsExactlyElementsOf(getFlagSet(flag).getFlags());
+      assertThat(flag.getFlags()).hasSize(1);
       assertThat(flag.getMask()).isEqualTo(getFlagSet(flag).getMask());
     }
   }

From a0503d3dc2eadf9ee603b19c43d1d061875d03d8 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Mon, 17 Nov 2025 12:53:14 +0000
Subject: [PATCH 304/322] Add TxnDeprecatedTest for more coverage

---
 .../java/org/lmdbjava/TxnDeprecatedTest.java  | 119 ++++++++++++++++++
 src/test/java/org/lmdbjava/TxnTest.java       |  18 +++
 2 files changed, 137 insertions(+)
 create mode 100644 src/test/java/org/lmdbjava/TxnDeprecatedTest.java

diff --git a/src/test/java/org/lmdbjava/TxnDeprecatedTest.java b/src/test/java/org/lmdbjava/TxnDeprecatedTest.java
new file mode 100644
index 00000000..c497ff84
--- /dev/null
+++ b/src/test/java/org/lmdbjava/TxnDeprecatedTest.java
@@ -0,0 +1,119 @@
+/*
+ * Copyright © 2016-2025 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.lmdbjava;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.lmdbjava.Env.create;
+import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
+import static org.lmdbjava.TxnFlags.MDB_RDONLY_TXN;
+
+import java.nio.ByteBuffer;
+import java.nio.file.Path;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.lmdbjava.Env.AlreadyClosedException;
+import org.lmdbjava.Txn.IncompatibleParent;
+
+/**
+ * Tests all the deprecated txn related methods in {@link Env}. Essentially a duplicate of {@link TxnTest}. When
+ * all the deprecated methods are deleted we can delete this test class.
+ *
+ * @deprecated Tests all the deprecated txn related methods in {@link Env}.
+ */
+@Deprecated
+public final class TxnDeprecatedTest {
+
+  private Path file;
+  private Env<ByteBuffer> env;
+
+  private TempDir tempDir;
+
+  @BeforeEach
+  void beforeEach() {
+    tempDir = new TempDir();
+    file = tempDir.createTempFile();
+    env =
+        create()
+            .setMapSize(256, ByteUnit.KIBIBYTES)
+            .setMaxReaders(1)
+            .setMaxDbs(2)
+            .setEnvFlags(MDB_NOSUBDIR)
+            .open(file);
+  }
+
+  @AfterEach
+  void afterEach() {
+    env.close();
+    tempDir.cleanup();
+  }
+
+  @Test
+  public void txParent() {
+    try (Txn<ByteBuffer> txRoot = env.txnWrite();
+        Txn<ByteBuffer> txChild = env.txn(txRoot, new TxnFlags[0])) {
+      assertThat(txRoot.getParent()).isNull();
+      assertThat(txChild.getParent()).isEqualTo(txRoot);
+    }
+  }
+
+  @Test
+  public void txParent2() {
+    try (Txn<ByteBuffer> txRoot = env.txnWrite();
+         Txn<ByteBuffer> txChild = env.txn(txRoot, (TxnFlags[]) null)) {
+      assertThat(txRoot.getParent()).isNull();
+      assertThat(txChild.getParent()).isEqualTo(txRoot);
+    }
+  }
+
+  @Test
+  void txParentDeniedIfEnvClosed() {
+    assertThatThrownBy(
+            () -> {
+              try (Txn<ByteBuffer> txRoot = env.txnWrite();
+                  Txn<ByteBuffer> txChild = env.txn(txRoot, new TxnFlags[0])) {
+                env.close();
+                assertThat(txChild.getParent()).isEqualTo(txRoot);
+              }
+            })
+        .isInstanceOf(AlreadyClosedException.class);
+  }
+
+  @Test
+  void txParentROChildRWIncompatible() {
+    assertThatThrownBy(
+            () -> {
+              try (Txn<ByteBuffer> txRoot = env.txnRead()) {
+                env.txn(txRoot, new TxnFlags[0]); // error
+              }
+            })
+        .isInstanceOf(IncompatibleParent.class);
+  }
+
+  @Test
+  void txParentRWChildROIncompatible() {
+    assertThatThrownBy(
+            () -> {
+              try (Txn<ByteBuffer> txRoot = env.txnWrite()) {
+                TxnFlags[] flags = new TxnFlags[]{MDB_RDONLY_TXN};
+                env.txn(txRoot, flags); // error
+              }
+            })
+        .isInstanceOf(IncompatibleParent.class);
+  }
+}
diff --git a/src/test/java/org/lmdbjava/TxnTest.java b/src/test/java/org/lmdbjava/TxnTest.java
index 790d81de..5936d4de 100644
--- a/src/test/java/org/lmdbjava/TxnTest.java
+++ b/src/test/java/org/lmdbjava/TxnTest.java
@@ -321,6 +321,24 @@ public void txParent() {
     }
   }
 
+  @Test
+  public void txParent2() {
+    try (Txn<ByteBuffer> txRoot = env.txnWrite();
+         Txn<ByteBuffer> txChild = env.txn(txRoot, (TxnFlagSet) null)) {
+      assertThat(txRoot.getParent()).isNull();
+      assertThat(txChild.getParent()).isEqualTo(txRoot);
+    }
+  }
+
+  @Test
+  public void txParent3() {
+    try (Txn<ByteBuffer> txRoot = env.txnWrite();
+         Txn<ByteBuffer> txChild = env.txn(txRoot, TxnFlagSet.EMPTY)) {
+      assertThat(txRoot.getParent()).isNull();
+      assertThat(txChild.getParent()).isEqualTo(txRoot);
+    }
+  }
+
   @Test
   void txParentDeniedIfEnvClosed() {
     assertThatThrownBy(

From 29d5ba2cc1ef9acfa1d8e806cbfbd9926ec15393 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Mon, 17 Nov 2025 12:53:40 +0000
Subject: [PATCH 305/322] Auto format

---
 src/test/java/org/lmdbjava/TxnDeprecatedTest.java | 8 ++++----
 src/test/java/org/lmdbjava/TxnTest.java           | 4 ++--
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/test/java/org/lmdbjava/TxnDeprecatedTest.java b/src/test/java/org/lmdbjava/TxnDeprecatedTest.java
index c497ff84..387e9fef 100644
--- a/src/test/java/org/lmdbjava/TxnDeprecatedTest.java
+++ b/src/test/java/org/lmdbjava/TxnDeprecatedTest.java
@@ -31,8 +31,8 @@
 import org.lmdbjava.Txn.IncompatibleParent;
 
 /**
- * Tests all the deprecated txn related methods in {@link Env}. Essentially a duplicate of {@link TxnTest}. When
- * all the deprecated methods are deleted we can delete this test class.
+ * Tests all the deprecated txn related methods in {@link Env}. Essentially a duplicate of {@link
+ * TxnTest}. When all the deprecated methods are deleted we can delete this test class.
  *
  * @deprecated Tests all the deprecated txn related methods in {@link Env}.
  */
@@ -75,7 +75,7 @@ public void txParent() {
   @Test
   public void txParent2() {
     try (Txn<ByteBuffer> txRoot = env.txnWrite();
-         Txn<ByteBuffer> txChild = env.txn(txRoot, (TxnFlags[]) null)) {
+        Txn<ByteBuffer> txChild = env.txn(txRoot, (TxnFlags[]) null)) {
       assertThat(txRoot.getParent()).isNull();
       assertThat(txChild.getParent()).isEqualTo(txRoot);
     }
@@ -110,7 +110,7 @@ void txParentRWChildROIncompatible() {
     assertThatThrownBy(
             () -> {
               try (Txn<ByteBuffer> txRoot = env.txnWrite()) {
-                TxnFlags[] flags = new TxnFlags[]{MDB_RDONLY_TXN};
+                TxnFlags[] flags = new TxnFlags[] {MDB_RDONLY_TXN};
                 env.txn(txRoot, flags); // error
               }
             })
diff --git a/src/test/java/org/lmdbjava/TxnTest.java b/src/test/java/org/lmdbjava/TxnTest.java
index 5936d4de..7dd9ca71 100644
--- a/src/test/java/org/lmdbjava/TxnTest.java
+++ b/src/test/java/org/lmdbjava/TxnTest.java
@@ -324,7 +324,7 @@ public void txParent() {
   @Test
   public void txParent2() {
     try (Txn<ByteBuffer> txRoot = env.txnWrite();
-         Txn<ByteBuffer> txChild = env.txn(txRoot, (TxnFlagSet) null)) {
+        Txn<ByteBuffer> txChild = env.txn(txRoot, (TxnFlagSet) null)) {
       assertThat(txRoot.getParent()).isNull();
       assertThat(txChild.getParent()).isEqualTo(txRoot);
     }
@@ -333,7 +333,7 @@ public void txParent2() {
   @Test
   public void txParent3() {
     try (Txn<ByteBuffer> txRoot = env.txnWrite();
-         Txn<ByteBuffer> txChild = env.txn(txRoot, TxnFlagSet.EMPTY)) {
+        Txn<ByteBuffer> txChild = env.txn(txRoot, TxnFlagSet.EMPTY)) {
       assertThat(txRoot.getParent()).isNull();
       assertThat(txChild.getParent()).isEqualTo(txRoot);
     }

From 1312e102ec343a776e8329531cc40f4723a31e21 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Mon, 17 Nov 2025 13:03:52 +0000
Subject: [PATCH 306/322] Add tests for XxxFlags.isSet

---
 .../java/org/lmdbjava/CopyFlagSetTest.java    | 15 +++++++++++++++
 .../java/org/lmdbjava/DbiFlagSetTest.java     | 17 +++++++++++++++++
 .../java/org/lmdbjava/EnvFlagSetTest.java     | 17 +++++++++++++++++
 .../java/org/lmdbjava/PutFlagSetTest.java     | 17 +++++++++++++++++
 .../java/org/lmdbjava/TxnFlagSetTest.java     | 19 +++++++++++++++++--
 5 files changed, 83 insertions(+), 2 deletions(-)

diff --git a/src/test/java/org/lmdbjava/CopyFlagSetTest.java b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
index 90ced57a..2bbf08e2 100644
--- a/src/test/java/org/lmdbjava/CopyFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
@@ -15,6 +15,8 @@
  */
 package org.lmdbjava;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.EnumSet;
@@ -72,4 +74,17 @@ Class<CopyFlags> getFlagType() {
   Function<EnumSet<CopyFlags>, CopyFlagSet> getConstructor() {
     return CopyFlagSetImpl::new;
   }
+
+  /**
+   * {@link FlagSet#isSet(MaskedFlag)} on the flag enum is tested in {@link AbstractFlagSetTest} but the coverage check
+   * doesn't seem to notice it.
+   */
+  @Test
+  void testIsSet() {
+    assertThat(CopyFlags.MDB_CP_COMPACT.isSet(CopyFlags.MDB_CP_COMPACT))
+        .isTrue();
+    //noinspection ConstantValue
+    assertThat(CopyFlags.MDB_CP_COMPACT.isSet(null))
+        .isFalse();
+  }
 }
diff --git a/src/test/java/org/lmdbjava/DbiFlagSetTest.java b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
index f9f591a5..c727f21c 100644
--- a/src/test/java/org/lmdbjava/DbiFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
@@ -15,6 +15,8 @@
  */
 package org.lmdbjava;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.EnumSet;
@@ -72,4 +74,19 @@ DbiFlagSet getFlagSet(DbiFlags flag) {
   Function<EnumSet<DbiFlags>, DbiFlagSet> getConstructor() {
     return DbiFlagSetImpl::new;
   }
+
+  /**
+   * {@link FlagSet#isSet(MaskedFlag)} on the flag enum is tested in {@link AbstractFlagSetTest} but the coverage check
+   * doesn't seem to notice it.
+   */
+  @Test
+  void testIsSet() {
+    assertThat(DbiFlags.MDB_CREATE.isSet(DbiFlags.MDB_CREATE))
+        .isTrue();
+    assertThat(DbiFlags.MDB_CREATE.isSet(DbiFlags.MDB_REVERSEKEY))
+        .isFalse();
+    //noinspection ConstantValue
+    assertThat(DbiFlags.MDB_CREATE.isSet(null))
+        .isFalse();
+  }
 }
diff --git a/src/test/java/org/lmdbjava/EnvFlagSetTest.java b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
index 1124a91d..e1835818 100644
--- a/src/test/java/org/lmdbjava/EnvFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
@@ -15,6 +15,8 @@
  */
 package org.lmdbjava;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.EnumSet;
@@ -72,4 +74,19 @@ Class<EnvFlags> getFlagType() {
   Function<EnumSet<EnvFlags>, EnvFlagSet> getConstructor() {
     return EnvFlagSetImpl::new;
   }
+
+  /**
+   * {@link FlagSet#isSet(MaskedFlag)} on the flag enum is tested in {@link AbstractFlagSetTest} but the coverage check
+   * doesn't seem to notice it.
+   */
+  @Test
+  void testIsSet() {
+    assertThat(EnvFlags.MDB_RDONLY_ENV.isSet(EnvFlags.MDB_RDONLY_ENV))
+        .isTrue();
+    assertThat(EnvFlags.MDB_RDONLY_ENV.isSet(EnvFlags.MDB_WRITEMAP))
+        .isFalse();
+    //noinspection ConstantValue
+    assertThat(EnvFlags.MDB_RDONLY_ENV.isSet(null))
+        .isFalse();
+  }
 }
diff --git a/src/test/java/org/lmdbjava/PutFlagSetTest.java b/src/test/java/org/lmdbjava/PutFlagSetTest.java
index 9fe858f0..0213cde2 100644
--- a/src/test/java/org/lmdbjava/PutFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/PutFlagSetTest.java
@@ -15,6 +15,8 @@
  */
 package org.lmdbjava;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
 import java.time.Duration;
 import java.time.Instant;
 import java.util.Arrays;
@@ -76,6 +78,21 @@ Function<EnumSet<PutFlags>, PutFlagSet> getConstructor() {
     return PutFlagSetImpl::new;
   }
 
+  /**
+   * {@link FlagSet#isSet(MaskedFlag)} on the flag enum is tested in {@link AbstractFlagSetTest} but the coverage check
+   * doesn't seem to notice it.
+   */
+  @Test
+  void testIsSet() {
+    assertThat(PutFlags.MDB_APPEND.isSet(PutFlags.MDB_APPEND))
+        .isTrue();
+    assertThat(PutFlags.MDB_APPEND.isSet(PutFlags.MDB_MULTIPLE))
+        .isFalse();
+    //noinspection ConstantValue
+    assertThat(PutFlags.MDB_APPEND.isSet(null))
+        .isFalse();
+  }
+
   @Test
   public void testAddFlagVsCheckPresence() {
 
diff --git a/src/test/java/org/lmdbjava/TxnFlagSetTest.java b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
index 5390ed66..7be45289 100644
--- a/src/test/java/org/lmdbjava/TxnFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
@@ -15,13 +15,15 @@
  */
 package org.lmdbjava;
 
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.lmdbjava.TxnFlags.MDB_RDONLY_TXN;
+
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.EnumSet;
 import java.util.List;
 import java.util.function.Function;
 import java.util.stream.Collectors;
-import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 class TxnFlagSetTest extends AbstractFlagSetTest<TxnFlags, TxnFlagSet> {
@@ -30,7 +32,7 @@ class TxnFlagSetTest extends AbstractFlagSetTest<TxnFlags, TxnFlagSet> {
   void test() {
     // This is here purely to stop CodeQL moaning that this class is unused.
     // All the actual tests are in the superclass
-    Assertions.assertThat(getAllFlags()).isNotNull();
+    assertThat(getAllFlags()).isNotNull();
   }
 
   @Override
@@ -72,4 +74,17 @@ Class<TxnFlags> getFlagType() {
   Function<EnumSet<TxnFlags>, TxnFlagSet> getConstructor() {
     return TxnFlagSetImpl::new;
   }
+
+  /**
+   * {@link FlagSet#isSet(MaskedFlag)} on the flag enum is tested in {@link AbstractFlagSetTest} but the coverage check
+   * doesn't seem to notice it.
+   */
+  @Test
+  void testIsSet() {
+    assertThat(MDB_RDONLY_TXN.isSet(MDB_RDONLY_TXN))
+        .isTrue();
+    //noinspection ConstantValue
+    assertThat(MDB_RDONLY_TXN.isSet(null))
+        .isFalse();
+  }
 }

From 0216c92fe95b221e86bc8f885dd3211613cafc03 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Mon, 17 Nov 2025 13:10:34 +0000
Subject: [PATCH 307/322] Add more test coverage

---
 .../java/org/lmdbjava/CopyFlagSetTest.java    | 10 ++--
 .../org/lmdbjava/CursorDeprecatedTest.java    | 44 +++++++++++++++--
 src/test/java/org/lmdbjava/CursorTest.java    | 48 +++++++++++++++++++
 .../java/org/lmdbjava/DbiFlagSetTest.java     | 13 ++---
 .../java/org/lmdbjava/EnvFlagSetTest.java     | 13 ++---
 .../java/org/lmdbjava/PutFlagSetTest.java     | 13 ++---
 .../java/org/lmdbjava/TxnFlagSetTest.java     | 10 ++--
 7 files changed, 112 insertions(+), 39 deletions(-)

diff --git a/src/test/java/org/lmdbjava/CopyFlagSetTest.java b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
index 2bbf08e2..7606682b 100644
--- a/src/test/java/org/lmdbjava/CopyFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/CopyFlagSetTest.java
@@ -76,15 +76,13 @@ Function<EnumSet<CopyFlags>, CopyFlagSet> getConstructor() {
   }
 
   /**
-   * {@link FlagSet#isSet(MaskedFlag)} on the flag enum is tested in {@link AbstractFlagSetTest} but the coverage check
-   * doesn't seem to notice it.
+   * {@link FlagSet#isSet(MaskedFlag)} on the flag enum is tested in {@link AbstractFlagSetTest} but
+   * the coverage check doesn't seem to notice it.
    */
   @Test
   void testIsSet() {
-    assertThat(CopyFlags.MDB_CP_COMPACT.isSet(CopyFlags.MDB_CP_COMPACT))
-        .isTrue();
+    assertThat(CopyFlags.MDB_CP_COMPACT.isSet(CopyFlags.MDB_CP_COMPACT)).isTrue();
     //noinspection ConstantValue
-    assertThat(CopyFlags.MDB_CP_COMPACT.isSet(null))
-        .isFalse();
+    assertThat(CopyFlags.MDB_CP_COMPACT.isSet(null)).isFalse();
   }
 }
diff --git a/src/test/java/org/lmdbjava/CursorDeprecatedTest.java b/src/test/java/org/lmdbjava/CursorDeprecatedTest.java
index cff118fa..a4528577 100644
--- a/src/test/java/org/lmdbjava/CursorDeprecatedTest.java
+++ b/src/test/java/org/lmdbjava/CursorDeprecatedTest.java
@@ -138,7 +138,7 @@ void cursorFirstLastNextPrev() {
   }
 
   @Test
-  void delete() {
+  void delete1() {
     final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
     try (Txn<ByteBuffer> txn = env.txnWrite();
         Cursor<ByteBuffer> c = db.openCursor(txn)) {
@@ -147,11 +147,49 @@ void delete() {
       assertThat(c.seek(MDB_FIRST)).isTrue();
       assertThat(c.key().getInt()).isEqualTo(1);
       assertThat(c.val().getInt()).isEqualTo(2);
-      c.delete();
+      c.delete(new PutFlags[0]);
       assertThat(c.seek(MDB_FIRST)).isTrue();
       assertThat(c.key().getInt()).isEqualTo(3);
       assertThat(c.val().getInt()).isEqualTo(4);
-      c.delete();
+      c.delete(new PutFlags[0]);
+      assertThat(c.seek(MDB_FIRST)).isFalse();
+    }
+  }
+
+  @Test
+  void delete2() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+    try (Txn<ByteBuffer> txn = env.txnWrite();
+        Cursor<ByteBuffer> c = db.openCursor(txn)) {
+      c.put(bb(1), bb(2), MDB_NOOVERWRITE);
+      c.put(bb(3), bb(4), new PutFlags[0]);
+      assertThat(c.seek(MDB_FIRST)).isTrue();
+      assertThat(c.key().getInt()).isEqualTo(1);
+      assertThat(c.val().getInt()).isEqualTo(2);
+      c.delete((PutFlags[]) null);
+      assertThat(c.seek(MDB_FIRST)).isTrue();
+      assertThat(c.key().getInt()).isEqualTo(3);
+      assertThat(c.val().getInt()).isEqualTo(4);
+      c.delete((PutFlags[]) null);
+      assertThat(c.seek(MDB_FIRST)).isFalse();
+    }
+  }
+
+  @Test
+  void delete3() {
+    final Dbi<ByteBuffer> db = env.openDbi(DB_1, MDB_CREATE, MDB_DUPSORT);
+    try (Txn<ByteBuffer> txn = env.txnWrite();
+        Cursor<ByteBuffer> c = db.openCursor(txn)) {
+      c.put(bb(1), bb(2), MDB_NOOVERWRITE);
+      c.put(bb(3), bb(4), new PutFlags[0]);
+      assertThat(c.seek(MDB_FIRST)).isTrue();
+      assertThat(c.key().getInt()).isEqualTo(1);
+      assertThat(c.val().getInt()).isEqualTo(2);
+      c.delete((PutFlags) null);
+      assertThat(c.seek(MDB_FIRST)).isTrue();
+      assertThat(c.key().getInt()).isEqualTo(3);
+      assertThat(c.val().getInt()).isEqualTo(4);
+      c.delete((PutFlags) null);
       assertThat(c.seek(MDB_FIRST)).isFalse();
     }
   }
diff --git a/src/test/java/org/lmdbjava/CursorTest.java b/src/test/java/org/lmdbjava/CursorTest.java
index 97f9d706..81f5ca2b 100644
--- a/src/test/java/org/lmdbjava/CursorTest.java
+++ b/src/test/java/org/lmdbjava/CursorTest.java
@@ -276,6 +276,54 @@ void delete() {
     }
   }
 
+  @Test
+  void delete2() {
+    final Dbi<ByteBuffer> db =
+        env.createDbi()
+            .setDbName(DB_1)
+            .withDefaultComparator()
+            .setDbiFlags(MDB_CREATE, MDB_DUPSORT)
+            .open();
+    try (Txn<ByteBuffer> txn = env.txnWrite();
+        Cursor<ByteBuffer> c = db.openCursor(txn)) {
+      c.put(bb(1), bb(2), MDB_NOOVERWRITE);
+      c.put(bb(3), bb(4));
+      assertThat(c.seek(MDB_FIRST)).isTrue();
+      assertThat(c.key().getInt()).isEqualTo(1);
+      assertThat(c.val().getInt()).isEqualTo(2);
+      c.delete(PutFlags.EMPTY);
+      assertThat(c.seek(MDB_FIRST)).isTrue();
+      assertThat(c.key().getInt()).isEqualTo(3);
+      assertThat(c.val().getInt()).isEqualTo(4);
+      c.delete(PutFlags.EMPTY);
+      assertThat(c.seek(MDB_FIRST)).isFalse();
+    }
+  }
+
+  @Test
+  void delete3() {
+    final Dbi<ByteBuffer> db =
+        env.createDbi()
+            .setDbName(DB_1)
+            .withDefaultComparator()
+            .setDbiFlags(MDB_CREATE, MDB_DUPSORT)
+            .open();
+    try (Txn<ByteBuffer> txn = env.txnWrite();
+        Cursor<ByteBuffer> c = db.openCursor(txn)) {
+      c.put(bb(1), bb(2), MDB_NOOVERWRITE);
+      c.put(bb(3), bb(4));
+      assertThat(c.seek(MDB_FIRST)).isTrue();
+      assertThat(c.key().getInt()).isEqualTo(1);
+      assertThat(c.val().getInt()).isEqualTo(2);
+      c.delete((PutFlagSet) null);
+      assertThat(c.seek(MDB_FIRST)).isTrue();
+      assertThat(c.key().getInt()).isEqualTo(3);
+      assertThat(c.val().getInt()).isEqualTo(4);
+      c.delete((PutFlagSet) null);
+      assertThat(c.seek(MDB_FIRST)).isFalse();
+    }
+  }
+
   @Test
   void getKeyVal() {
     final Dbi<ByteBuffer> db =
diff --git a/src/test/java/org/lmdbjava/DbiFlagSetTest.java b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
index c727f21c..460ca0f2 100644
--- a/src/test/java/org/lmdbjava/DbiFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/DbiFlagSetTest.java
@@ -76,17 +76,14 @@ Function<EnumSet<DbiFlags>, DbiFlagSet> getConstructor() {
   }
 
   /**
-   * {@link FlagSet#isSet(MaskedFlag)} on the flag enum is tested in {@link AbstractFlagSetTest} but the coverage check
-   * doesn't seem to notice it.
+   * {@link FlagSet#isSet(MaskedFlag)} on the flag enum is tested in {@link AbstractFlagSetTest} but
+   * the coverage check doesn't seem to notice it.
    */
   @Test
   void testIsSet() {
-    assertThat(DbiFlags.MDB_CREATE.isSet(DbiFlags.MDB_CREATE))
-        .isTrue();
-    assertThat(DbiFlags.MDB_CREATE.isSet(DbiFlags.MDB_REVERSEKEY))
-        .isFalse();
+    assertThat(DbiFlags.MDB_CREATE.isSet(DbiFlags.MDB_CREATE)).isTrue();
+    assertThat(DbiFlags.MDB_CREATE.isSet(DbiFlags.MDB_REVERSEKEY)).isFalse();
     //noinspection ConstantValue
-    assertThat(DbiFlags.MDB_CREATE.isSet(null))
-        .isFalse();
+    assertThat(DbiFlags.MDB_CREATE.isSet(null)).isFalse();
   }
 }
diff --git a/src/test/java/org/lmdbjava/EnvFlagSetTest.java b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
index e1835818..a06334af 100644
--- a/src/test/java/org/lmdbjava/EnvFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/EnvFlagSetTest.java
@@ -76,17 +76,14 @@ Function<EnumSet<EnvFlags>, EnvFlagSet> getConstructor() {
   }
 
   /**
-   * {@link FlagSet#isSet(MaskedFlag)} on the flag enum is tested in {@link AbstractFlagSetTest} but the coverage check
-   * doesn't seem to notice it.
+   * {@link FlagSet#isSet(MaskedFlag)} on the flag enum is tested in {@link AbstractFlagSetTest} but
+   * the coverage check doesn't seem to notice it.
    */
   @Test
   void testIsSet() {
-    assertThat(EnvFlags.MDB_RDONLY_ENV.isSet(EnvFlags.MDB_RDONLY_ENV))
-        .isTrue();
-    assertThat(EnvFlags.MDB_RDONLY_ENV.isSet(EnvFlags.MDB_WRITEMAP))
-        .isFalse();
+    assertThat(EnvFlags.MDB_RDONLY_ENV.isSet(EnvFlags.MDB_RDONLY_ENV)).isTrue();
+    assertThat(EnvFlags.MDB_RDONLY_ENV.isSet(EnvFlags.MDB_WRITEMAP)).isFalse();
     //noinspection ConstantValue
-    assertThat(EnvFlags.MDB_RDONLY_ENV.isSet(null))
-        .isFalse();
+    assertThat(EnvFlags.MDB_RDONLY_ENV.isSet(null)).isFalse();
   }
 }
diff --git a/src/test/java/org/lmdbjava/PutFlagSetTest.java b/src/test/java/org/lmdbjava/PutFlagSetTest.java
index 0213cde2..e6a86a96 100644
--- a/src/test/java/org/lmdbjava/PutFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/PutFlagSetTest.java
@@ -79,18 +79,15 @@ Function<EnumSet<PutFlags>, PutFlagSet> getConstructor() {
   }
 
   /**
-   * {@link FlagSet#isSet(MaskedFlag)} on the flag enum is tested in {@link AbstractFlagSetTest} but the coverage check
-   * doesn't seem to notice it.
+   * {@link FlagSet#isSet(MaskedFlag)} on the flag enum is tested in {@link AbstractFlagSetTest} but
+   * the coverage check doesn't seem to notice it.
    */
   @Test
   void testIsSet() {
-    assertThat(PutFlags.MDB_APPEND.isSet(PutFlags.MDB_APPEND))
-        .isTrue();
-    assertThat(PutFlags.MDB_APPEND.isSet(PutFlags.MDB_MULTIPLE))
-        .isFalse();
+    assertThat(PutFlags.MDB_APPEND.isSet(PutFlags.MDB_APPEND)).isTrue();
+    assertThat(PutFlags.MDB_APPEND.isSet(PutFlags.MDB_MULTIPLE)).isFalse();
     //noinspection ConstantValue
-    assertThat(PutFlags.MDB_APPEND.isSet(null))
-        .isFalse();
+    assertThat(PutFlags.MDB_APPEND.isSet(null)).isFalse();
   }
 
   @Test
diff --git a/src/test/java/org/lmdbjava/TxnFlagSetTest.java b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
index 7be45289..37068202 100644
--- a/src/test/java/org/lmdbjava/TxnFlagSetTest.java
+++ b/src/test/java/org/lmdbjava/TxnFlagSetTest.java
@@ -76,15 +76,13 @@ Function<EnumSet<TxnFlags>, TxnFlagSet> getConstructor() {
   }
 
   /**
-   * {@link FlagSet#isSet(MaskedFlag)} on the flag enum is tested in {@link AbstractFlagSetTest} but the coverage check
-   * doesn't seem to notice it.
+   * {@link FlagSet#isSet(MaskedFlag)} on the flag enum is tested in {@link AbstractFlagSetTest} but
+   * the coverage check doesn't seem to notice it.
    */
   @Test
   void testIsSet() {
-    assertThat(MDB_RDONLY_TXN.isSet(MDB_RDONLY_TXN))
-        .isTrue();
+    assertThat(MDB_RDONLY_TXN.isSet(MDB_RDONLY_TXN)).isTrue();
     //noinspection ConstantValue
-    assertThat(MDB_RDONLY_TXN.isSet(null))
-        .isFalse();
+    assertThat(MDB_RDONLY_TXN.isSet(null)).isFalse();
   }
 }

From 8b60f29869827d74863a5034fa34b5d3a04c8c8c Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Mon, 17 Nov 2025 15:13:25 +0000
Subject: [PATCH 308/322] Change FlagSet args to be requireNonNull

---
 src/main/java/org/lmdbjava/Cursor.java     | 24 +++---
 src/main/java/org/lmdbjava/Dbi.java        | 11 +--
 src/main/java/org/lmdbjava/Env.java        |  1 +
 src/main/java/org/lmdbjava/Txn.java        | 10 ++-
 src/test/java/org/lmdbjava/CursorTest.java | 89 ++++++++++++++++++----
 src/test/java/org/lmdbjava/TxnTest.java    | 10 ++-
 6 files changed, 105 insertions(+), 40 deletions(-)

diff --git a/src/main/java/org/lmdbjava/Cursor.java b/src/main/java/org/lmdbjava/Cursor.java
index 09c461e2..0e320930 100644
--- a/src/main/java/org/lmdbjava/Cursor.java
+++ b/src/main/java/org/lmdbjava/Cursor.java
@@ -294,6 +294,7 @@ public boolean put(final T key, final T val, final PutFlagSet flags) {
     if (SHOULD_CHECK) {
       requireNonNull(key);
       requireNonNull(val);
+      requireNonNull(flags);
       env.checkNotClosed();
       checkNotClosed();
       txn.checkReady();
@@ -301,13 +302,11 @@ public boolean put(final T key, final T val, final PutFlagSet flags) {
     }
     final Pointer transientKey = kv.keyIn(key);
     final Pointer transientVal = kv.valIn(val);
-    final PutFlagSet putFlagSet = flags != null ? flags : PutFlagSet.EMPTY;
-    final int rc =
-        LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(), putFlagSet.getMask());
+    final int rc = LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(), flags.getMask());
     if (rc == MDB_KEYEXIST) {
-      if (putFlagSet.isSet(MDB_NOOVERWRITE)) {
+      if (flags.isSet(MDB_NOOVERWRITE)) {
         kv.valOut(); // marked as in,out in LMDB C docs
-      } else if (!putFlagSet.isSet(MDB_NODUPDATA)) {
+      } else if (!flags.isSet(MDB_NODUPDATA)) {
         checkRc(rc);
       }
       return false;
@@ -375,15 +374,14 @@ public void putMultiple(final T key, final T val, final int elements, final PutF
       env.checkNotClosed();
       txn.checkReady();
       txn.checkWritesAllowed();
+      if (!flags.isSet(MDB_MULTIPLE)) {
+        throw new IllegalArgumentException("Must set " + MDB_MULTIPLE + " flag");
+      }
     }
-    final PutFlagSet putFlagSet = flags != null ? flags : PutFlagSet.EMPTY;
-    if (SHOULD_CHECK && !putFlagSet.isSet(MDB_MULTIPLE)) {
-      throw new IllegalArgumentException("Must set " + MDB_MULTIPLE + " flag");
-    }
+
     final Pointer transientKey = txn.kv().keyIn(key);
     final Pointer dataPtr = txn.kv().valInMulti(val, elements);
-    final int rc =
-        LIB.mdb_cursor_put(ptrCursor, txn.kv().pointerKey(), dataPtr, putFlagSet.getMask());
+    final int rc = LIB.mdb_cursor_put(ptrCursor, txn.kv().pointerKey(), dataPtr, flags.getMask());
     checkRc(rc);
     ReferenceUtil.reachabilityFence0(transientKey);
     ReferenceUtil.reachabilityFence0(dataPtr);
@@ -466,6 +464,7 @@ public T reserve(final T key, final int size) {
   public T reserve(final T key, final int size, final PutFlagSet flags) {
     if (SHOULD_CHECK) {
       requireNonNull(key);
+      requireNonNull(flags);
       env.checkNotClosed();
       checkNotClosed();
       txn.checkReady();
@@ -473,9 +472,8 @@ public T reserve(final T key, final int size, final PutFlagSet flags) {
     }
     final Pointer transientKey = kv.keyIn(key);
     final Pointer transientVal = kv.valIn(size);
-    final PutFlagSet putFlagSet = flags != null ? flags : PutFlagSet.EMPTY;
     // This is inconsistent with putMultiple which require MDB_MULTIPLE to be in the set.
-    final int flagsMask = putFlagSet.getMaskWith(MDB_RESERVE);
+    final int flagsMask = flags.getMaskWith(MDB_RESERVE);
     checkRc(LIB.mdb_cursor_put(ptrCursor, kv.pointerKey(), kv.pointerVal(), flagsMask));
     kv.valOut();
     ReferenceUtil.reachabilityFence0(transientKey);
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index aff6fff8..e36cc2e1 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -83,13 +83,14 @@ public final class Dbi<T> {
         throw new IllegalArgumentException("Is nativeCb is true, you must supply a comparator");
       }
       requireNonNull(txn);
+      requireNonNull(dbiFlagSet);
       txn.checkReady();
     }
     this.env = env;
     this.name = name == null ? null : Arrays.copyOf(name, name.length);
     this.proxy = proxy;
     this.comparator = comparator;
-    this.dbiFlagSet = dbiFlagSet == null ? DbiFlagSet.EMPTY : dbiFlagSet;
+    this.dbiFlagSet = dbiFlagSet;
     final Pointer dbiPtr = allocateDirect(RUNTIME, ADDRESS);
     checkRc(LIB.mdb_dbi_open(txn.pointer(), name, this.dbiFlagSet.getMask(), dbiPtr));
     ptr = dbiPtr.getPointer(0);
@@ -457,20 +458,20 @@ public boolean put(final Txn<T> txn, final T key, final T val, final PutFlagSet
       requireNonNull(txn);
       requireNonNull(key);
       requireNonNull(val);
+      requireNonNull(flags);
       env.checkNotClosed();
       txn.checkReady();
       txn.checkWritesAllowed();
     }
-    final PutFlagSet flagSet = flags != null ? flags : PutFlagSet.empty();
     final Pointer transientKey = txn.kv().keyIn(key);
     final Pointer transientVal = txn.kv().valIn(val);
     final int rc =
         LIB.mdb_put(
-            txn.pointer(), ptr, txn.kv().pointerKey(), txn.kv().pointerVal(), flagSet.getMask());
+            txn.pointer(), ptr, txn.kv().pointerKey(), txn.kv().pointerVal(), flags.getMask());
     if (rc == MDB_KEYEXIST) {
-      if (flagSet.isSet(MDB_NOOVERWRITE)) {
+      if (flags.isSet(MDB_NOOVERWRITE)) {
         txn.kv().valOut(); // marked as in,out in LMDB C docs
-      } else if (!flagSet.isSet(MDB_NODUPDATA)) {
+      } else if (!flags.isSet(MDB_NODUPDATA)) {
         checkRc(rc);
       }
       return false;
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index af3a6596..0d4afe7e 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -201,6 +201,7 @@ public void copy(final Path path) {
    */
   public void copy(final Path path, final CopyFlagSet flags) {
     requireNonNull(path);
+    requireNonNull(flags);
     validatePath(path);
     checkRc(LIB.mdb_env_copy2(ptr, path.toAbsolutePath().toString(), flags.getMask()));
   }
diff --git a/src/main/java/org/lmdbjava/Txn.java b/src/main/java/org/lmdbjava/Txn.java
index 432b47a8..7e9aacf9 100644
--- a/src/main/java/org/lmdbjava/Txn.java
+++ b/src/main/java/org/lmdbjava/Txn.java
@@ -27,6 +27,7 @@
 import static org.lmdbjava.Txn.State.RESET;
 import static org.lmdbjava.TxnFlags.MDB_RDONLY_TXN;
 
+import java.util.Objects;
 import jnr.ffi.Pointer;
 
 /**
@@ -42,14 +43,15 @@ public final class Txn<T> implements AutoCloseable {
   private final Pointer ptr;
   private final boolean readOnly;
   private final Env<T> env;
-  private final TxnFlagSet flags;
   private State state;
 
   Txn(final Env<T> env, final Txn<T> parent, final BufferProxy<T> proxy, final TxnFlagSet flags) {
-    this.flags = flags != null ? flags : TxnFlagSet.EMPTY;
+    if (SHOULD_CHECK) {
+      Objects.requireNonNull(flags);
+    }
     this.proxy = proxy;
     this.keyVal = proxy.keyVal();
-    this.readOnly = this.flags.isSet(MDB_RDONLY_TXN);
+    this.readOnly = flags.isSet(MDB_RDONLY_TXN);
     if (env.isReadOnly() && !this.readOnly) {
       throw new EnvIsReadOnly();
     }
@@ -60,7 +62,7 @@ public final class Txn<T> implements AutoCloseable {
     }
     final Pointer txnPtr = allocateDirect(RUNTIME, ADDRESS);
     final Pointer txnParentPtr = parent == null ? null : parent.ptr;
-    checkRc(LIB.mdb_txn_begin(env.pointer(), txnParentPtr, this.flags.getMask(), txnPtr));
+    checkRc(LIB.mdb_txn_begin(env.pointer(), txnParentPtr, flags.getMask(), txnPtr));
     ptr = txnPtr.getPointer(0);
 
     state = READY;
diff --git a/src/test/java/org/lmdbjava/CursorTest.java b/src/test/java/org/lmdbjava/CursorTest.java
index 81f5ca2b..deb75622 100644
--- a/src/test/java/org/lmdbjava/CursorTest.java
+++ b/src/test/java/org/lmdbjava/CursorTest.java
@@ -41,6 +41,7 @@
 import java.nio.ByteBuffer;
 import java.nio.file.Path;
 import java.util.function.Consumer;
+import org.assertj.core.api.Assertions;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -179,7 +180,7 @@ void closedEnvRejectsDeleteCall() {
   }
 
   @Test
-  void count() {
+  void countWithDupsort() {
     final Dbi<ByteBuffer> db =
         env.createDbi()
             .setDbName(DB_1)
@@ -199,6 +200,30 @@ void count() {
     }
   }
 
+  @Test
+  void countWithoutDupsort() {
+    final Dbi<ByteBuffer> db =
+        env.createDbi().setDbName(DB_1).withDefaultComparator().setDbiFlags(MDB_CREATE).open();
+    try (Txn<ByteBuffer> txn = env.txnWrite();
+        Cursor<ByteBuffer> c = db.openCursor(txn)) {
+      assertThat(c.put(bb(1), bb(2), MDB_NOOVERWRITE)).isTrue();
+      assertThat(c.put(bb(1), bb(4))).isTrue();
+      assertThat(c.put(bb(1), bb(6), PutFlagSet.EMPTY)).isTrue();
+      assertThat(c.put(bb(1), bb(8), MDB_NOOVERWRITE)).isFalse();
+      assertThat(c.put(bb(2), bb(1), MDB_NOOVERWRITE)).isTrue();
+      assertThat(c.put(bb(2), bb(2))).isTrue();
+      Assertions.assertThatThrownBy(
+              () -> {
+                c.put(bb(2), bb(2), (PutFlagSet) null);
+              })
+          .isInstanceOf(NullPointerException.class);
+      assertThat(c.put(bb(2), bb(2))).isTrue();
+
+      final Stat stat = db.stat(txn);
+      assertThat(stat.entries).isEqualTo(2);
+    }
+  }
+
   @Test
   void cursorCannotCloseIfTransactionCommitted() {
     assertThatThrownBy(
@@ -377,20 +402,56 @@ void putMultiple() {
 
   @Test
   void putMultipleWithoutMdbMultipleFlag() {
-    assertThatThrownBy(
-            () -> {
-              final Dbi<ByteBuffer> db =
-                  env.createDbi()
-                      .setDbName(DB_1)
-                      .withDefaultComparator()
-                      .setDbiFlags(MDB_CREATE, MDB_DUPSORT)
-                      .open();
-              try (Txn<ByteBuffer> txn = env.txnWrite();
-                  Cursor<ByteBuffer> c = db.openCursor(txn)) {
+    final Dbi<ByteBuffer> db =
+        env.createDbi()
+            .setDbName(DB_1)
+            .withDefaultComparator()
+            .setDbiFlags(MDB_CREATE, MDB_DUPSORT)
+            .open();
+    try (Txn<ByteBuffer> txn = env.txnWrite();
+        Cursor<ByteBuffer> c = db.openCursor(txn)) {
+      assertThatThrownBy(
+              () -> {
                 c.putMultiple(bb(100), bb(1), 1);
-              }
-            })
-        .isInstanceOf(IllegalArgumentException.class);
+              })
+          .isInstanceOf(IllegalArgumentException.class);
+    }
+  }
+
+  @Test
+  void putMultipleWithoutMdbMultipleFlag2() {
+    final Dbi<ByteBuffer> db =
+        env.createDbi()
+            .setDbName(DB_1)
+            .withDefaultComparator()
+            .setDbiFlags(MDB_CREATE, MDB_DUPSORT)
+            .open();
+    try (Txn<ByteBuffer> txn = env.txnWrite();
+        Cursor<ByteBuffer> c = db.openCursor(txn)) {
+      assertThatThrownBy(
+              () -> {
+                c.putMultiple(bb(100), bb(1), 1, PutFlags.EMPTY);
+              })
+          .isInstanceOf(IllegalArgumentException.class);
+    }
+  }
+
+  @Test
+  void putMultipleWithoutMdbMultipleFlag3() {
+    final Dbi<ByteBuffer> db =
+        env.createDbi()
+            .setDbName(DB_1)
+            .withDefaultComparator()
+            .setDbiFlags(MDB_CREATE, MDB_DUPSORT)
+            .open();
+    try (Txn<ByteBuffer> txn = env.txnWrite();
+        Cursor<ByteBuffer> c = db.openCursor(txn)) {
+      assertThatThrownBy(
+              () -> {
+                c.putMultiple(bb(100), bb(1), 1, (PutFlagSet) null);
+              })
+          .isInstanceOf(NullPointerException.class);
+    }
   }
 
   @Test
diff --git a/src/test/java/org/lmdbjava/TxnTest.java b/src/test/java/org/lmdbjava/TxnTest.java
index 7dd9ca71..7210b613 100644
--- a/src/test/java/org/lmdbjava/TxnTest.java
+++ b/src/test/java/org/lmdbjava/TxnTest.java
@@ -323,10 +323,12 @@ public void txParent() {
 
   @Test
   public void txParent2() {
-    try (Txn<ByteBuffer> txRoot = env.txnWrite();
-        Txn<ByteBuffer> txChild = env.txn(txRoot, (TxnFlagSet) null)) {
-      assertThat(txRoot.getParent()).isNull();
-      assertThat(txChild.getParent()).isEqualTo(txRoot);
+    try (Txn<ByteBuffer> txRoot = env.txnWrite()) {
+      assertThatThrownBy(
+              () -> {
+                env.txn(txRoot, (TxnFlagSet) null);
+              })
+          .isInstanceOf(NullPointerException.class);
     }
   }
 

From e53956d8bcf8f2fe8c3d071374c8871ab6c5bf5f Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Mon, 17 Nov 2025 15:29:13 +0000
Subject: [PATCH 309/322] Add requireNonNull checks to Dbi

---
 src/main/java/org/lmdbjava/Dbi.java     |  3 ++
 src/test/java/org/lmdbjava/DbiTest.java | 72 +++++++++++++++++++++++++
 2 files changed, 75 insertions(+)

diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index e36cc2e1..f5d76ba1 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -78,11 +78,14 @@ public final class Dbi<T> {
       final boolean nativeCb,
       final BufferProxy<T> proxy,
       final DbiFlagSet dbiFlagSet) {
+
     if (SHOULD_CHECK) {
       if (nativeCb && comparator == null) {
         throw new IllegalArgumentException("Is nativeCb is true, you must supply a comparator");
       }
+      requireNonNull(env);
       requireNonNull(txn);
+      requireNonNull(proxy);
       requireNonNull(dbiFlagSet);
       txn.checkReady();
     }
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index 9f66e5bb..fa4cbc83 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -120,6 +120,78 @@ void close() {
         .isInstanceOf(ConstantDerivedException.class);
   }
 
+  @Test
+  void constructorArgsNullEnv() {
+    assertThatThrownBy(
+            () -> {
+              try (Txn<ByteBuffer> txn = env.txnWrite()) {
+                new Dbi<>(
+                    null,
+                    txn,
+                    "foo".getBytes(Env.DEFAULT_NAME_CHARSET),
+                    PROXY_OPTIMAL,
+                    DbiFlagSet.EMPTY);
+              }
+            })
+        .isInstanceOf(NullPointerException.class);
+  }
+
+  @Test
+  void constructorArgsNullTxn() {
+    assertThatThrownBy(
+            () -> {
+              new Dbi<>(
+                  env,
+                  null,
+                  "foo".getBytes(Env.DEFAULT_NAME_CHARSET),
+                  PROXY_OPTIMAL,
+                  DbiFlagSet.EMPTY);
+            })
+        .isInstanceOf(NullPointerException.class);
+  }
+
+  @Test
+  void constructorArgsNullProxy() {
+    assertThatThrownBy(
+            () -> {
+              try (Txn<ByteBuffer> txn = env.txnWrite()) {
+                new Dbi<>(
+                    env, txn, "foo".getBytes(Env.DEFAULT_NAME_CHARSET), null, DbiFlagSet.EMPTY);
+              }
+            })
+        .isInstanceOf(NullPointerException.class);
+  }
+
+  @Test
+  void constructorArgsNullFlags() {
+    assertThatThrownBy(
+            () -> {
+              try (Txn<ByteBuffer> txn = env.txnWrite()) {
+                new Dbi<>(env, txn, "foo".getBytes(Env.DEFAULT_NAME_CHARSET), PROXY_OPTIMAL, null);
+              }
+            })
+        .isInstanceOf(NullPointerException.class);
+  }
+
+  @Test
+  void constructorArgsNullNativeCallbackComparator() {
+    assertThatThrownBy(
+            () -> {
+              try (Txn<ByteBuffer> txn = env.txnWrite()) {
+                new Dbi<>(
+                    env,
+                    txn,
+                    "foo".getBytes(Env.DEFAULT_NAME_CHARSET),
+                    null,
+                    true,
+                    PROXY_OPTIMAL,
+                    DbiFlagSet.EMPTY);
+              }
+            })
+        .isInstanceOf(IllegalArgumentException.class)
+        .hasMessageContaining("Is nativeCb is true, you must supply a comparator");
+  }
+
   @Test
   void customComparator() {
     final Comparator<ByteBuffer> reverseOrder =

From 654a5bcd622b81996c61116b4374492f25a5b3b2 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Mon, 17 Nov 2025 16:36:30 +0000
Subject: [PATCH 310/322] Add more coverage

---
 src/main/java/org/lmdbjava/CopyFlags.java |  2 +-
 src/main/java/org/lmdbjava/Dbi.java       | 10 +++
 src/main/java/org/lmdbjava/DbiFlags.java  |  2 +-
 src/main/java/org/lmdbjava/Env.java       | 92 +++++++++++++++--------
 src/main/java/org/lmdbjava/EnvFlags.java  |  2 +-
 src/main/java/org/lmdbjava/PutFlags.java  |  2 +-
 src/main/java/org/lmdbjava/TxnFlags.java  |  2 +-
 src/test/java/org/lmdbjava/DbiTest.java   |  8 ++
 src/test/java/org/lmdbjava/EnvTest.java   | 92 ++++++++++++++++++++++-
 9 files changed, 173 insertions(+), 39 deletions(-)

diff --git a/src/main/java/org/lmdbjava/CopyFlags.java b/src/main/java/org/lmdbjava/CopyFlags.java
index d2d7b0e2..e3677baf 100644
--- a/src/main/java/org/lmdbjava/CopyFlags.java
+++ b/src/main/java/org/lmdbjava/CopyFlags.java
@@ -43,7 +43,7 @@ public Set<CopyFlags> getFlags() {
 
   @Override
   public boolean isSet(final CopyFlags flag) {
-    return flag != null && mask == flag.getMask();
+    return this == flag;
   }
 
   @Override
diff --git a/src/main/java/org/lmdbjava/Dbi.java b/src/main/java/org/lmdbjava/Dbi.java
index f5d76ba1..d2afdf8f 100644
--- a/src/main/java/org/lmdbjava/Dbi.java
+++ b/src/main/java/org/lmdbjava/Dbi.java
@@ -281,6 +281,16 @@ public byte[] getName() {
     return name == null ? null : Arrays.copyOf(name, name.length);
   }
 
+  /**
+   * Convert the passed name into bytes using the default {@link Charset}.
+   *
+   * @param name The name to convert.
+   * @return The name as a byte[] or null if name is null.
+   */
+  public static byte[] getNameBytes(final String name) {
+    return name == null ? null : name.getBytes(Env.DEFAULT_NAME_CHARSET);
+  }
+
   /**
    * Obtains the name of this database, using the {@link Env#DEFAULT_NAME_CHARSET} {@link Charset}.
    *
diff --git a/src/main/java/org/lmdbjava/DbiFlags.java b/src/main/java/org/lmdbjava/DbiFlags.java
index e1e66a31..9426db0f 100644
--- a/src/main/java/org/lmdbjava/DbiFlags.java
+++ b/src/main/java/org/lmdbjava/DbiFlags.java
@@ -101,7 +101,7 @@ public Set<DbiFlags> getFlags() {
 
   @Override
   public boolean isSet(final DbiFlags flag) {
-    return flag != null && mask == flag.getMask();
+    return this == flag;
   }
 
   @Override
diff --git a/src/main/java/org/lmdbjava/Env.java b/src/main/java/org/lmdbjava/Env.java
index 0d4afe7e..4bc6cca8 100644
--- a/src/main/java/org/lmdbjava/Env.java
+++ b/src/main/java/org/lmdbjava/Env.java
@@ -73,18 +73,24 @@ public final class Env<T> implements AutoCloseable {
   private final BufferProxy<T> proxy;
   private final Pointer ptr;
   private final boolean readOnly;
+  private final Path path;
+  private final EnvFlagSet envFlagSet;
 
   private Env(
       final BufferProxy<T> proxy,
       final Pointer ptr,
       final boolean readOnly,
-      final boolean noSubDir) {
+      final boolean noSubDir,
+      final Path path,
+      final EnvFlagSet envFlagSet) {
     this.proxy = proxy;
     this.readOnly = readOnly;
     this.noSubDir = noSubDir;
     this.ptr = ptr;
     // cache max key size to avoid further JNI calls
     this.maxKeySize = LIB.mdb_env_get_maxkeysize(ptr);
+    this.path = path;
+    this.envFlagSet = envFlagSet;
   }
 
   /**
@@ -353,7 +359,7 @@ public DbiBuilder<T> createDbi() {
    */
   @Deprecated()
   public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
-    return createDbi().setDbName(name).withDefaultComparator().setDbiFlags(flags).open();
+    return openDbi(Dbi.getNameBytes(name), null, false, flags);
   }
 
   /**
@@ -374,13 +380,7 @@ public Dbi<T> openDbi(final String name, final DbiFlags... flags) {
   @Deprecated()
   public Dbi<T> openDbi(
       final String name, final Comparator<T> comparator, final DbiFlags... flags) {
-    final byte[] nameBytes = name == null ? null : name.getBytes(DEFAULT_NAME_CHARSET);
-    try (Txn<T> txn = readOnly ? txnRead() : txnWrite()) {
-      final Dbi<T> dbi =
-          new Dbi<>(this, txn, nameBytes, comparator, false, proxy, DbiFlagSet.of(flags));
-      txn.commit(); // even RO Txns require a commit to retain Dbi in Env
-      return dbi;
-    }
+    return openDbi(Dbi.getNameBytes(name), comparator, false, flags);
   }
 
   /**
@@ -403,13 +403,7 @@ public Dbi<T> openDbi(
       final Comparator<T> comparator,
       final boolean nativeCb,
       final DbiFlags... flags) {
-    final byte[] nameBytes = name == null ? null : name.getBytes(DEFAULT_NAME_CHARSET);
-    try (Txn<T> txn = readOnly ? txnRead() : txnWrite()) {
-      final Dbi<T> dbi =
-          new Dbi<>(this, txn, nameBytes, comparator, nativeCb, proxy, DbiFlagSet.of(flags));
-      txn.commit(); // even RO Txns require a commit to retain Dbi in Env
-      return dbi;
-    }
+    return openDbi(Dbi.getNameBytes(name), comparator, nativeCb, flags);
   }
 
   /**
@@ -422,7 +416,7 @@ public Dbi<T> openDbi(
    */
   @Deprecated()
   public Dbi<T> openDbi(final byte[] name, final DbiFlags... flags) {
-    return createDbi().setDbName(name).withDefaultComparator().setDbiFlags(flags).open();
+    return openDbi(name, null, false, flags);
   }
 
   /**
@@ -437,12 +431,7 @@ public Dbi<T> openDbi(final byte[] name, final DbiFlags... flags) {
   @Deprecated()
   public Dbi<T> openDbi(
       final byte[] name, final Comparator<T> comparator, final DbiFlags... flags) {
-    requireNonNull(comparator);
-    return createDbi()
-        .setDbName(name)
-        .withIteratorComparator(ignored -> comparator)
-        .setDbiFlags(flags)
-        .open();
+    return openDbi(name, comparator, false, flags);
   }
 
   /**
@@ -640,6 +629,29 @@ public int readerCheck() {
     return resultPtr.intValue();
   }
 
+  /** For testing use. */
+  EnvFlagSet getEnvFlagSet() {
+    return envFlagSet;
+  }
+
+  @Override
+  public String toString() {
+    return "Env{"
+        + "closed="
+        + closed
+        + ", maxKeySize="
+        + maxKeySize
+        + ", noSubDir="
+        + noSubDir
+        + ", readOnly="
+        + readOnly
+        + ", path="
+        + path
+        + ", envFlagSet="
+        + envFlagSet
+        + '}';
+  }
+
   /** Object has already been closed and the operation is therefore prohibited. */
   public static final class AlreadyClosedException extends LmdbException {
 
@@ -754,7 +766,7 @@ public Env<T> open(final Path path) {
         final boolean readOnly = flags.isSet(MDB_RDONLY_ENV);
         final boolean noSubDir = flags.isSet(MDB_NOSUBDIR);
         checkRc(LIB.mdb_env_open(ptr, path.toAbsolutePath().toString(), flags.getMask(), mode));
-        return new Env<>(proxy, ptr, readOnly, noSubDir);
+        return new Env<>(proxy, ptr, readOnly, noSubDir, path, flags);
       } catch (final LmdbNativeException e) {
         LIB.mdb_env_close(ptr);
         throw e;
@@ -846,7 +858,7 @@ public Builder<T> setFilePermissions(final int mode) {
     public Builder<T> setEnvFlags(final Collection<EnvFlags> envFlags) {
       flagSetBuilder.clear();
       if (envFlags != null) {
-        envFlags.stream().filter(Objects::nonNull).forEach(envFlags::add);
+        envFlags.stream().filter(Objects::nonNull).forEach(flagSetBuilder::addFlag);
       }
       return this;
     }
@@ -884,23 +896,37 @@ public Builder<T> setEnvFlags(final EnvFlagSet envFlagSet) {
     /**
      * Adds a single {@link EnvFlags} to any existing flags.
      *
-     * @param dbiFlag The flag to add to any existing flags. A null value is a no-op.
+     * @param envFlag The flag to add to any existing flags. A null value is a no-op.
+     * @return this builder instance.
+     */
+    public Builder<T> addEnvFlag(final EnvFlags envFlag) {
+      this.flagSetBuilder.addFlag(envFlag);
+      return this;
+    }
+
+    /**
+     * Adds the contents of an {@link EnvFlagSet} to any existing flags.
+     *
+     * @param envFlagSet The set of flags to add to any existing flags. A null value is a no-op.
      * @return this builder instance.
      */
-    public Builder<T> addEnvFlag(final EnvFlags dbiFlag) {
-      this.flagSetBuilder.addFlag(dbiFlag);
+    public Builder<T> addEnvFlags(final EnvFlagSet envFlagSet) {
+      if (envFlagSet != null) {
+        flagSetBuilder.addFlags(envFlagSet.getFlags());
+      }
       return this;
     }
 
     /**
-     * Adds a set of {@link EnvFlags} to any existing flags.
+     * Adds a {@link Collection} of {@link EnvFlags} to any existing flags.
      *
-     * @param dbiFlagSet The set of flags to add to any existing flags. A null value is a no-op.
+     * @param envFlags The {@link Collection} of flags to add to any existing flags. A null value is
+     *     a no-op.
      * @return this builder instance.
      */
-    public Builder<T> addEnvFlags(final EnvFlagSet dbiFlagSet) {
-      if (dbiFlagSet != null) {
-        flagSetBuilder.addFlags(dbiFlagSet.getFlags());
+    public Builder<T> addEnvFlags(final Collection<EnvFlags> envFlags) {
+      if (envFlags != null) {
+        flagSetBuilder.addFlags(envFlags);
       }
       return this;
     }
diff --git a/src/main/java/org/lmdbjava/EnvFlags.java b/src/main/java/org/lmdbjava/EnvFlags.java
index 7fb4a29b..1d5c9214 100644
--- a/src/main/java/org/lmdbjava/EnvFlags.java
+++ b/src/main/java/org/lmdbjava/EnvFlags.java
@@ -155,7 +155,7 @@ public Set<EnvFlags> getFlags() {
 
   @Override
   public boolean isSet(final EnvFlags flag) {
-    return flag != null && mask == flag.getMask();
+    return this == flag;
   }
 
   @Override
diff --git a/src/main/java/org/lmdbjava/PutFlags.java b/src/main/java/org/lmdbjava/PutFlags.java
index 03fa916a..2c400bae 100644
--- a/src/main/java/org/lmdbjava/PutFlags.java
+++ b/src/main/java/org/lmdbjava/PutFlags.java
@@ -60,7 +60,7 @@ public Set<PutFlags> getFlags() {
 
   @Override
   public boolean isSet(PutFlags flag) {
-    return flag != null && mask == flag.getMask();
+    return this == flag;
   }
 
   @Override
diff --git a/src/main/java/org/lmdbjava/TxnFlags.java b/src/main/java/org/lmdbjava/TxnFlags.java
index 94112957..866e1f65 100644
--- a/src/main/java/org/lmdbjava/TxnFlags.java
+++ b/src/main/java/org/lmdbjava/TxnFlags.java
@@ -42,7 +42,7 @@ public Set<TxnFlags> getFlags() {
 
   @Override
   public boolean isSet(final TxnFlags flag) {
-    return flag != null && mask == flag.getMask();
+    return this == flag;
   }
 
   @Override
diff --git a/src/test/java/org/lmdbjava/DbiTest.java b/src/test/java/org/lmdbjava/DbiTest.java
index fa4cbc83..575937f5 100644
--- a/src/test/java/org/lmdbjava/DbiTest.java
+++ b/src/test/java/org/lmdbjava/DbiTest.java
@@ -821,4 +821,12 @@ private void doEnvClosedTest(
       }
     }
   }
+
+  @Test
+  void getNameBytes() {
+    //noinspection ConstantValue
+    assertThat(Dbi.getNameBytes(null)).isNull();
+    ;
+    assertThat(Dbi.getNameBytes("foo")).isEqualTo("foo".getBytes(Env.DEFAULT_NAME_CHARSET));
+  }
 }
diff --git a/src/test/java/org/lmdbjava/EnvTest.java b/src/test/java/org/lmdbjava/EnvTest.java
index 3f60076a..69a5ea4e 100644
--- a/src/test/java/org/lmdbjava/EnvTest.java
+++ b/src/test/java/org/lmdbjava/EnvTest.java
@@ -23,6 +23,7 @@
 import static org.lmdbjava.DbiFlags.MDB_CREATE;
 import static org.lmdbjava.Env.Builder.MAX_READERS_DEFAULT;
 import static org.lmdbjava.EnvFlags.MDB_NOSUBDIR;
+import static org.lmdbjava.EnvFlags.MDB_NOSYNC;
 import static org.lmdbjava.EnvFlags.MDB_NOTLS;
 import static org.lmdbjava.EnvFlags.MDB_RDONLY_ENV;
 import static org.lmdbjava.TestUtils.DB_1;
@@ -33,7 +34,9 @@
 import java.nio.ByteBuffer;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.List;
 import java.util.Random;
 import org.assertj.core.api.Assertions;
@@ -90,6 +93,20 @@ void cannotChangeMapSizeAfterOpen() {
         .isInstanceOf(AlreadyOpenException.class);
   }
 
+  @Test
+  void cannotChangePermissionsAfterOpen() {
+    assertThatThrownBy(
+            () -> {
+              final Path file = tempDir.createTempFile();
+              final Builder<ByteBuffer> builder =
+                  Env.create().setFilePermissions(0666).setEnvFlags(MDB_NOSUBDIR);
+              try (Env<ByteBuffer> ignored = builder.setEnvFlags(MDB_NOSUBDIR).open(file)) {
+                builder.setFilePermissions(0664);
+              }
+            })
+        .isInstanceOf(AlreadyOpenException.class);
+  }
+
   @Test
   void cannotChangeMaxDbsAfterOpen() {
     assertThatThrownBy(
@@ -168,6 +185,16 @@ void negativeMapSize() {
         .isInstanceOf(IllegalArgumentException.class);
   }
 
+  @Test
+  void negativeMapSize2() {
+    assertThatThrownBy(
+            () -> {
+              final Builder<ByteBuffer> builder = Env.create().setMaxReaders(1);
+              builder.setMapSize(-1, ByteUnit.MEBIBYTES);
+            })
+        .isInstanceOf(IllegalArgumentException.class);
+  }
+
   @Test
   void cannotStatOnceClosed() {
     assertThatThrownBy(
@@ -574,6 +601,8 @@ void addEnvFlag() {
             .open(file)) {
       env.sync(true);
       assertThat(Files.isRegularFile(file)).isTrue();
+      assertThat(env.getEnvFlagSet().getFlags())
+          .containsExactlyInAnyOrderElementsOf(EnvFlagSet.of(MDB_NOSUBDIR, MDB_NOTLS).getFlags());
     }
   }
 
@@ -588,10 +617,71 @@ void addEnvFlags() {
             .addEnvFlags(EnvFlagSet.of(MDB_NOSUBDIR, MDB_NOTLS))
             .addEnvFlag(MDB_NOTLS) // Should not overwrite the existing one
             .addEnvFlag(null) // no-op
-            .addEnvFlags(null) // no-op
+            .addEnvFlags((EnvFlagSet) null) // no-op
+            .addEnvFlags((Collection<EnvFlags>) null) // no-op
+            .open(file)) {
+      env.sync(true);
+      assertThat(env.getEnvFlagSet().getFlags())
+          .containsExactlyInAnyOrderElementsOf(EnvFlagSet.of(MDB_NOSUBDIR, MDB_NOTLS).getFlags());
+      assertThat(Files.isRegularFile(file)).isTrue();
+    }
+  }
+
+  @Test
+  void addEnvFlags2() {
+    final Path file = tempDir.createTempFile();
+    try (Env<ByteBuffer> env =
+        Env.create()
+            .setMapSize(1, ByteUnit.MEBIBYTES)
+            .setMaxDbs(1)
+            .setMaxReaders(1)
+            .addEnvFlags(Arrays.asList(MDB_NOSUBDIR, MDB_NOTLS))
+            .addEnvFlags(Collections.singleton(MDB_NOSYNC))
+            .open(file)) {
+      env.sync(true);
+      assertThat(env.getEnvFlagSet().getFlags())
+          .containsExactlyInAnyOrderElementsOf(
+              EnvFlagSet.of(MDB_NOSUBDIR, MDB_NOTLS, MDB_NOSYNC).getFlags());
+      assertThat(Files.isRegularFile(file)).isTrue();
+    }
+  }
+
+  @Test
+  void setEnvFlags() {
+    final Path file = tempDir.createTempFile();
+    try (Env<ByteBuffer> env =
+        Env.create()
+            .setMapSize(1, ByteUnit.MEBIBYTES)
+            .setMaxDbs(1)
+            .setMaxReaders(1)
+            .setEnvFlags((EnvFlagSet) null) // No-op
+            .setEnvFlags((EnvFlags) null) // No-op
+            .setEnvFlags((EnvFlags[]) null) // No-op
+            .setEnvFlags((Collection<EnvFlags>) null) // No-op
+            .setEnvFlags(MDB_NOSYNC) // Will be overwritten
+            .setEnvFlags(Arrays.asList(MDB_NOSUBDIR, MDB_NOTLS))
             .open(file)) {
       env.sync(true);
       assertThat(Files.isRegularFile(file)).isTrue();
+      assertThat(env.getEnvFlagSet().getFlags())
+          .containsExactlyInAnyOrderElementsOf(EnvFlagSet.of(MDB_NOSUBDIR, MDB_NOTLS).getFlags());
+    }
+  }
+
+  @Test
+  void setEnvFlags2() {
+    final Path dir = tempDir.createTempDir();
+    try (Env<ByteBuffer> env =
+        Env.create()
+            .setMapSize(1, ByteUnit.MEBIBYTES)
+            .setMaxDbs(1)
+            .setMaxReaders(1)
+            .setEnvFlags(MDB_NOSUBDIR, MDB_NOTLS)
+            .setEnvFlags(Collections.emptySet()) // Clears them
+            .open(dir)) {
+      env.sync(true);
+      assertThat(env.getEnvFlagSet().getFlags()).isEmpty();
+      assertThat(Files.isDirectory(dir));
     }
   }
 

From 850c4e2d1ec533c8c9fffc799131a457729744cd Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Mon, 17 Nov 2025 17:29:17 +0000
Subject: [PATCH 311/322] Add DirectBufferProxyTest

---
 .../org/lmdbjava/DirectBufferProxyTest.java   | 114 ++++++++++++++++++
 1 file changed, 114 insertions(+)
 create mode 100644 src/test/java/org/lmdbjava/DirectBufferProxyTest.java

diff --git a/src/test/java/org/lmdbjava/DirectBufferProxyTest.java b/src/test/java/org/lmdbjava/DirectBufferProxyTest.java
new file mode 100644
index 00000000..73389c0d
--- /dev/null
+++ b/src/test/java/org/lmdbjava/DirectBufferProxyTest.java
@@ -0,0 +1,114 @@
+package org.lmdbjava;
+
+import java.nio.ByteOrder;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.Random;
+import java.util.Set;
+import org.agrona.DirectBuffer;
+import org.agrona.MutableDirectBuffer;
+import org.agrona.concurrent.UnsafeBuffer;
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+class DirectBufferProxyTest {
+
+  @Test
+  public void verifyComparators_int() {
+    final Random random = new Random(203948);
+    final MutableDirectBuffer buffer1native = new UnsafeBuffer(new byte[Integer.BYTES]);
+    final MutableDirectBuffer buffer2native = new UnsafeBuffer(new byte[Integer.BYTES]);
+    final MutableDirectBuffer buffer1be = new UnsafeBuffer(new byte[Integer.BYTES]);
+    final MutableDirectBuffer buffer2be = new UnsafeBuffer(new byte[Integer.BYTES]);
+    final int[] values = random.ints().filter(i -> i >= 0).limit(5_000_000).toArray();
+
+    final LinkedHashMap<CompareType, Comparator<DirectBuffer>> comparators = new LinkedHashMap<>();
+    comparators.put(CompareType.INTEGER_KEY, DirectBufferProxy::compareAsIntegerKeys);
+    comparators.put(CompareType.LEXICOGRAPHIC, DirectBufferProxy::compareLexicographically);
+
+    final LinkedHashMap<CompareType, ComparatorResult> results =
+        new LinkedHashMap<>(comparators.size());
+    final Set<ComparatorResult> uniqueResults = new HashSet<>(comparators.size());
+
+    for (int i = 1; i < values.length; i++) {
+      final int val1 = values[i - 1];
+      final int val2 = values[i];
+      buffer1native.putInt(0, val1, ByteOrder.nativeOrder());
+      buffer2native.putInt(0, val2, ByteOrder.nativeOrder());
+      buffer1be.putInt(0, val1, ByteOrder.BIG_ENDIAN);
+      buffer2be.putInt(0, val2, ByteOrder.BIG_ENDIAN);
+
+      uniqueResults.clear();
+
+      // Make sure all comparators give the same result for the same inputs
+      comparators.forEach(
+          (compareType, comparator) -> {
+            final ComparatorResult result;
+            // IntegerKey comparator expects keys to have been written in native order so need
+            // different buffers.
+            if (compareType == CompareType.INTEGER_KEY) {
+              result = TestUtils.compare(comparator, buffer1native, buffer2native);
+            } else {
+              result = TestUtils.compare(comparator, buffer1be, buffer2be);
+            }
+            results.put(compareType, result);
+            uniqueResults.add(result);
+          });
+
+      if (uniqueResults.size() != 1) {
+        Assertions.fail(
+            "Comparator mismatch for values: " + val1 + " and " + val2 + ". Results: " + results);
+      }
+    }
+  }
+
+  @Test
+  public void verifyComparators_long() {
+    final Random random = new Random(203948);
+    final MutableDirectBuffer buffer1native = new UnsafeBuffer(new byte[Long.BYTES]);
+    final MutableDirectBuffer buffer2native = new UnsafeBuffer(new byte[Long.BYTES]);
+    final MutableDirectBuffer buffer1be = new UnsafeBuffer(new byte[Long.BYTES]);
+    final MutableDirectBuffer buffer2be = new UnsafeBuffer(new byte[Long.BYTES]);
+    final long[] values = random.longs().filter(i -> i >= 0).limit(5_000_000).toArray();
+
+    final LinkedHashMap<CompareType, Comparator<DirectBuffer>> comparators = new LinkedHashMap<>();
+    comparators.put(CompareType.INTEGER_KEY, DirectBufferProxy::compareAsIntegerKeys);
+    comparators.put(CompareType.LEXICOGRAPHIC, DirectBufferProxy::compareLexicographically);
+
+    final LinkedHashMap<CompareType, ComparatorResult> results =
+        new LinkedHashMap<>(comparators.size());
+    final Set<ComparatorResult> uniqueResults = new HashSet<>(comparators.size());
+
+    for (int i = 1; i < values.length; i++) {
+      final long val1 = values[i - 1];
+      final long val2 = values[i];
+      buffer1native.putLong(0, val1, ByteOrder.nativeOrder());
+      buffer2native.putLong(0, val2, ByteOrder.nativeOrder());
+      buffer1be.putLong(0, val1, ByteOrder.BIG_ENDIAN);
+      buffer2be.putLong(0, val2, ByteOrder.BIG_ENDIAN);
+
+      uniqueResults.clear();
+
+      // Make sure all comparators give the same result for the same inputs
+      comparators.forEach(
+          (compareType, comparator) -> {
+            final ComparatorResult result;
+            // IntegerKey comparator expects keys to have been written in native order so need
+            // different buffers.
+            if (compareType == CompareType.INTEGER_KEY) {
+              result = TestUtils.compare(comparator, buffer1native, buffer2native);
+            } else {
+              result = TestUtils.compare(comparator, buffer1be, buffer2be);
+            }
+            results.put(compareType, result);
+            uniqueResults.add(result);
+          });
+
+      if (uniqueResults.size() != 1) {
+        Assertions.fail(
+            "Comparator mismatch for values: " + val1 + " and " + val2 + ". Results: " + results);
+      }
+    }
+  }
+}

From 8eb95d05da415557cfd6efc6b491fe9ea1f0cbb0 Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Wed, 19 Nov 2025 11:43:02 +1100
Subject: [PATCH 312/322] Support musl system library and LmdbJava Native
 0.9.33-3 (#280)

---
 pom.xml                                       |  2 +-
 src/main/java/org/lmdbjava/TargetName.java    | 19 ++++++++++++++++++-
 .../java/org/lmdbjava/TargetNameTest.java     |  8 ++++++--
 3 files changed, 25 insertions(+), 4 deletions(-)

diff --git a/pom.xml b/pom.xml
index e7772ad9..2e2ed69d 100644
--- a/pom.xml
+++ b/pom.xml
@@ -38,7 +38,7 @@
     <jnr-ffi.version>2.2.18</jnr-ffi.version>
     <junit.version>5.14.1</junit.version>
     <license-maven-plugin.version>4.6</license-maven-plugin.version>
-    <lmdbjava-native.version>0.9.33-2</lmdbjava-native.version>
+    <lmdbjava-native.version>0.9.33-3</lmdbjava-native.version>
     <maven-clean-plugin.version>3.5.0</maven-clean-plugin.version>
     <maven-compiler-plugin.version>3.14.1</maven-compiler-plugin.version>
     <maven-dependency-plugin.version>3.9.0</maven-dependency-plugin.version>
diff --git a/src/main/java/org/lmdbjava/TargetName.java b/src/main/java/org/lmdbjava/TargetName.java
index e3bb5db0..ef22bd20 100644
--- a/src/main/java/org/lmdbjava/TargetName.java
+++ b/src/main/java/org/lmdbjava/TargetName.java
@@ -18,6 +18,10 @@
 import static java.lang.System.getProperty;
 import static java.util.Locale.ENGLISH;
 
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
 /**
  * Determines the name of the target LMDB native library.
  *
@@ -160,6 +164,19 @@ private static String resolveOs(final String os) {
   }
 
   private static String resolveToolchain(final String os) {
-    return check(os, "Mac OS") ? "none" : "gnu";
+    if (check(os, "Mac OS")) {
+      return "none";
+    }
+    return isMuslLibc() ? "musl" : "gnu";
+  }
+
+  private static boolean isMuslLibc() {
+    try {
+      return Files.lines(Paths.get("/proc/self/maps"))
+          .filter(line -> line.contains("libc"))
+          .anyMatch(line -> line.contains("musl"));
+    } catch (final IOException e) {
+      return false;
+    }
   }
 }
diff --git a/src/test/java/org/lmdbjava/TargetNameTest.java b/src/test/java/org/lmdbjava/TargetNameTest.java
index 04caea83..775b56d8 100644
--- a/src/test/java/org/lmdbjava/TargetNameTest.java
+++ b/src/test/java/org/lmdbjava/TargetNameTest.java
@@ -41,9 +41,13 @@ void customEmbedded() {
 
   @Test
   void embeddedNameResolution() {
-    embed("aarch64-linux-gnu.so", "aarch64", "Linux");
+    // Note: Linux resolution now detects musl vs glibc at runtime
+    // These tests verify the resolution logic but actual toolchain depends on system
+    final String linuxToolchain = TargetName.resolveFilename(NONE, NONE, "x86_64", "Linux")
+        .contains("-musl.") ? "musl" : "gnu";
+    embed("aarch64-linux-" + linuxToolchain + ".so", "aarch64", "Linux");
     embed("aarch64-macos-none.so", "aarch64", "Mac OS");
-    embed("x86_64-linux-gnu.so", "x86_64", "Linux");
+    embed("x86_64-linux-" + linuxToolchain + ".so", "x86_64", "Linux");
     embed("x86_64-macos-none.so", "x86_64", "Mac OS");
     embed("x86_64-windows-gnu.dll", "x86_64", "Windows");
   }

From 3136919e7d221477b03518d35f3085582d50b10f Mon Sep 17 00:00:00 2001
From: Ben Alex <ben.alex@acegi.com.au>
Date: Thu, 20 Nov 2025 12:29:11 +1100
Subject: [PATCH 313/322] Improve musl detection (#280)

---
 src/main/java/org/lmdbjava/TargetName.java | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/src/main/java/org/lmdbjava/TargetName.java b/src/main/java/org/lmdbjava/TargetName.java
index ef22bd20..fde95e6f 100644
--- a/src/main/java/org/lmdbjava/TargetName.java
+++ b/src/main/java/org/lmdbjava/TargetName.java
@@ -21,6 +21,7 @@
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Paths;
+import java.util.stream.Stream;
 
 /**
  * Determines the name of the target LMDB native library.
@@ -171,10 +172,8 @@ private static String resolveToolchain(final String os) {
   }
 
   private static boolean isMuslLibc() {
-    try {
-      return Files.lines(Paths.get("/proc/self/maps"))
-          .filter(line -> line.contains("libc"))
-          .anyMatch(line -> line.contains("musl"));
+    try (Stream<String> lines = Files.lines(Paths.get("/proc/self/maps"))) {
+      return lines.anyMatch(line -> line.contains("/ld-musl"));
     } catch (final IOException e) {
       return false;
     }

From 1800dd6670740fabceee25fd6490f9ad9b88b47b Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Thu, 20 Nov 2025 17:12:48 +0000
Subject: [PATCH 314/322] Improve javadoc, format code

---
 src/main/java/org/lmdbjava/DbiBuilder.java     | 3 ++-
 src/test/java/org/lmdbjava/TargetNameTest.java | 6 ++++--
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/main/java/org/lmdbjava/DbiBuilder.java b/src/main/java/org/lmdbjava/DbiBuilder.java
index f322cb6d..29bbb8f5 100644
--- a/src/main/java/org/lmdbjava/DbiBuilder.java
+++ b/src/main/java/org/lmdbjava/DbiBuilder.java
@@ -302,7 +302,8 @@ public Stage3<T> addDbiFlags(final DbiFlagSet dbiFlagSet) {
      * Use the supplied transaction to open the {@link Dbi}.
      *
      * <p>The caller MUST commit the transaction after calling {@link Stage3#open()}, in order to
-     * retain the <code>Dbi</code> in the <code>Env</code>.
+     * retain the <code>Dbi</code> in the <code>Env</code>. The caller is also responsible for
+     * closing the transaction.
      *
      * <p>If you don't call this method to supply a {@link Txn}, a {@link Txn} will be opened for
      * the purpose of creating and opening the {@link Dbi}, then closed. Therefore, if you already
diff --git a/src/test/java/org/lmdbjava/TargetNameTest.java b/src/test/java/org/lmdbjava/TargetNameTest.java
index 775b56d8..6c0a8f44 100644
--- a/src/test/java/org/lmdbjava/TargetNameTest.java
+++ b/src/test/java/org/lmdbjava/TargetNameTest.java
@@ -43,8 +43,10 @@ void customEmbedded() {
   void embeddedNameResolution() {
     // Note: Linux resolution now detects musl vs glibc at runtime
     // These tests verify the resolution logic but actual toolchain depends on system
-    final String linuxToolchain = TargetName.resolveFilename(NONE, NONE, "x86_64", "Linux")
-        .contains("-musl.") ? "musl" : "gnu";
+    final String linuxToolchain =
+        TargetName.resolveFilename(NONE, NONE, "x86_64", "Linux").contains("-musl.")
+            ? "musl"
+            : "gnu";
     embed("aarch64-linux-" + linuxToolchain + ".so", "aarch64", "Linux");
     embed("aarch64-macos-none.so", "aarch64", "Mac OS");
     embed("x86_64-linux-" + linuxToolchain + ".so", "x86_64", "Linux");

From 83c3a62afe2868b2c93fd7d61b39fc3d57b92a97 Mon Sep 17 00:00:00 2001
From: at055612 <22818309+at055612@users.noreply.github.com>
Date: Thu, 20 Nov 2025 17:34:39 +0000
Subject: [PATCH 315/322] Add missing @Override, remove commented code

---
 .../java/org/lmdbjava/ComparatorTest.java     | 25 +------------------
 1 file changed, 1 insertion(+), 24 deletions(-)

diff --git a/src/test/java/org/lmdbjava/ComparatorTest.java b/src/test/java/org/lmdbjava/ComparatorTest.java
index fbde37c3..5a1ddb62 100644
--- a/src/test/java/org/lmdbjava/ComparatorTest.java
+++ b/src/test/java/org/lmdbjava/ComparatorTest.java
@@ -256,30 +256,6 @@ public int compare(final byte[] o1, final byte[] o2) {
     }
   }
 
-  //  /** Converts an integer result code into its contractual meaning. */
-  //  enum ComparatorResult {
-  //    LESS_THAN,
-  //    EQUAL_TO,
-  //    GREATER_THAN;
-  //
-  //    static ComparatorResult get(final int comparatorResult) {
-  //      if (comparatorResult == 0) {
-  //        return EQUAL_TO;
-  //      }
-  //      return comparatorResult < 0 ? LESS_THAN : GREATER_THAN;
-  //    }
-  //
-  //    ComparatorResult opposite() {
-  //      if (this == LESS_THAN) {
-  //        return GREATER_THAN;
-  //      } else if (this == GREATER_THAN) {
-  //        return LESS_THAN;
-  //      } else {
-  //        return EQUAL_TO;
-  //      }
-  //    }
-  //  }
-
   /** Interface that can test a {@link BufferProxy} <code>compare</code> method. */
   private interface ComparatorRunner extends Comparator<byte[]> {
 
@@ -291,6 +267,7 @@ private interface ComparatorRunner extends Comparator<byte[]> {
      * @param o2 rhs buffer content
      * @return as per {@link Comparable}
      */
+    @Override
     int compare(byte[] o1, byte[] o2);
   }
 }

From d047260ce48a5b935fa81f8e3836a905352eafb8 Mon Sep 17 00:00:00 2001
From: BP Alex <718596+bp-alex@users.noreply.github.com>
Date: Tue, 13 Jan 2026 16:30:50 +1100
Subject: [PATCH 316/322] Add missing copyright header

---
 .../java/org/lmdbjava/DirectBufferProxyTest.java  | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/src/test/java/org/lmdbjava/DirectBufferProxyTest.java b/src/test/java/org/lmdbjava/DirectBufferProxyTest.java
index 73389c0d..fc01e801 100644
--- a/src/test/java/org/lmdbjava/DirectBufferProxyTest.java
+++ b/src/test/java/org/lmdbjava/DirectBufferProxyTest.java
@@ -1,3 +1,18 @@
+/*
+ * Copyright © 2016-2026 The LmdbJava Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package org.lmdbjava;
 
 import java.nio.ByteOrder;

From f2962f4a15bf9d9a3073d97e9eb0f309dc123fdc Mon Sep 17 00:00:00 2001
From: BP Alex <718596+bp-alex@users.noreply.github.com>
Date: Tue, 13 Jan 2026 16:44:20 +1100
Subject: [PATCH 317/322] POM auto-formatting

---
 pom.xml | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/pom.xml b/pom.xml
index 2e2ed69d..ccc7e9f0 100644
--- a/pom.xml
+++ b/pom.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
 
-    Copyright © 2016-2025 The LmdbJava Open Source Project
+    Copyright © 2016-2026 The LmdbJava Open Source Project
 
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -218,19 +218,19 @@
             </goals>
             <configuration>
               <rules>
-                <dependencyConvergence />
+                <dependencyConvergence/>
                 <requireMavenVersion>
                   <version>[${maven.enforcer.mvn},)</version>
                 </requireMavenVersion>
                 <requireJavaVersion>
                   <version>[${maven.enforcer.java},)</version>
                 </requireJavaVersion>
-                <requireNoRepositories />
-                <requirePluginVersions />
+                <requireNoRepositories/>
+                <requirePluginVersions/>
                 <requireReleaseDeps>
                   <onlyWhenRelease>true</onlyWhenRelease>
                 </requireReleaseDeps>
-                <requireUpperBoundDeps />
+                <requireUpperBoundDeps/>
               </rules>
             </configuration>
           </execution>

From 50612662a85fd0e7a450aa8e7c57dcbf3cc924d1 Mon Sep 17 00:00:00 2001
From: BP Alex <718596+bp-alex@users.noreply.github.com>
Date: Tue, 13 Jan 2026 17:32:17 +1100
Subject: [PATCH 318/322] Update native to 0.9.33-4 (#280)

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index ccc7e9f0..20a47038 100644
--- a/pom.xml
+++ b/pom.xml
@@ -38,7 +38,7 @@
     <jnr-ffi.version>2.2.18</jnr-ffi.version>
     <junit.version>5.14.1</junit.version>
     <license-maven-plugin.version>4.6</license-maven-plugin.version>
-    <lmdbjava-native.version>0.9.33-3</lmdbjava-native.version>
+    <lmdbjava-native.version>0.9.33-4</lmdbjava-native.version>
     <maven-clean-plugin.version>3.5.0</maven-clean-plugin.version>
     <maven-compiler-plugin.version>3.14.1</maven-compiler-plugin.version>
     <maven-dependency-plugin.version>3.9.0</maven-dependency-plugin.version>

From 8abdbecebdc0a7f550bac17aaed3df2e41088ccd Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 26 Jan 2026 21:56:22 +0000
Subject: [PATCH 319/322] Bump org.assertj:assertj-core from 3.27.6 to 3.27.7

Bumps [org.assertj:assertj-core](https://github.com/assertj/assertj) from 3.27.6 to 3.27.7.
- [Release notes](https://github.com/assertj/assertj/releases)
- [Commits](https://github.com/assertj/assertj/compare/assertj-build-3.27.6...assertj-build-3.27.7)

---
updated-dependencies:
- dependency-name: org.assertj:assertj-core
  dependency-version: 3.27.7
  dependency-type: direct:development
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 20a47038..b0724fbc 100644
--- a/pom.xml
+++ b/pom.xml
@@ -27,7 +27,7 @@
   <properties>
     <!-- Agrona 1.23+ requires Java 17+ -->
     <agrona.version>1.22.0</agrona.version>
-    <assertj.version>3.27.6</assertj.version>
+    <assertj.version>3.27.7</assertj.version>
     <buildnumber-maven-plugin.version>3.2.1</buildnumber-maven-plugin.version>
     <central-publishing-maven-plugin.version>0.9.0</central-publishing-maven-plugin.version>
     <fmt-maven-plugin.version>2.29</fmt-maven-plugin.version>

From 0de591af0657fdf7fa8f0f9927b1c03002927708 Mon Sep 17 00:00:00 2001
From: BP Alex <718596+bp-alex@users.noreply.github.com>
Date: Fri, 30 Jan 2026 09:23:53 +1100
Subject: [PATCH 320/322] Update native to 0.9.33-5 (#280)

---
 pom.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pom.xml b/pom.xml
index 20a47038..4af065d9 100644
--- a/pom.xml
+++ b/pom.xml
@@ -38,7 +38,7 @@
     <jnr-ffi.version>2.2.18</jnr-ffi.version>
     <junit.version>5.14.1</junit.version>
     <license-maven-plugin.version>4.6</license-maven-plugin.version>
-    <lmdbjava-native.version>0.9.33-4</lmdbjava-native.version>
+    <lmdbjava-native.version>0.9.33-5</lmdbjava-native.version>
     <maven-clean-plugin.version>3.5.0</maven-clean-plugin.version>
     <maven-compiler-plugin.version>3.14.1</maven-compiler-plugin.version>
     <maven-dependency-plugin.version>3.9.0</maven-dependency-plugin.version>

From fc1bcbd9b4ee8806fd309033dcbf31838f3faf38 Mon Sep 17 00:00:00 2001
From: BP Alex <718596+bp-alex@users.noreply.github.com>
Date: Fri, 6 Feb 2026 09:17:06 +1100
Subject: [PATCH 321/322] Improve error message for unsupported OS (#283)

---
 src/main/java/org/lmdbjava/TargetName.java | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/main/java/org/lmdbjava/TargetName.java b/src/main/java/org/lmdbjava/TargetName.java
index fde95e6f..49a65dea 100644
--- a/src/main/java/org/lmdbjava/TargetName.java
+++ b/src/main/java/org/lmdbjava/TargetName.java
@@ -134,10 +134,12 @@ private static String err(final String reason) {
     return reason
         + " (please set system property "
         + LMDB_NATIVE_LIB_PROP
-        + " to the path of an external LMDB native library or property "
+        + " to the path of an external LMDB native library,"
+        + " or simply 'lmdb' if LMDB is installed in standard system paths;"
+        + " alternatively set property "
         + LMDB_EMBEDDED_LIB_PROP
-        + " to the name of an LmdbJava embedded"
-        + " library; os.arch='"
+        + " to the name of an LmdbJava embedded library;"
+        + " os.arch='"
         + ARCH
         + "' os.name='"
         + OS

From cc2f24a405478c76da10540a803d295aa7fefdbe Mon Sep 17 00:00:00 2001
From: BP Alex <718596+bp-alex@users.noreply.github.com>
Date: Fri, 6 Feb 2026 09:45:32 +1100
Subject: [PATCH 322/322] Deploy releases on tag push, snapshots on branch push

Prevents double deployment during release:prepare by checking
POM version before deploying. Branch pushes only deploy if
version contains -SNAPSHOT; tag pushes only deploy if it does not.
---
 .github/workflows/maven.yml | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml
index 38f6472b..0df7cef5 100644
--- a/.github/workflows/maven.yml
+++ b/.github/workflows/maven.yml
@@ -3,6 +3,7 @@ name: Maven Build and Deployment
 on:
   push:
     branches: [ master ]
+    tags: [ 'lmdbjava-*' ]
   pull_request:
     branches: [ master ]
 
@@ -84,7 +85,14 @@ jobs:
         gpg-private-key: ${{ secrets.gpg_private_key }}
         gpg-passphrase: MAVEN_GPG_PASSPHRASE
 
+    - name: Get project version
+      id: version
+      run: echo "version=$(mvn help:evaluate -Dexpression=project.version -q -DforceStdout)" >> $GITHUB_OUTPUT
+
     - name: Publish Maven package
+      if: |
+        (github.ref_type == 'branch' && contains(steps.version.outputs.version, '-SNAPSHOT')) ||
+        (github.ref_type == 'tag' && !contains(steps.version.outputs.version, '-SNAPSHOT'))
       run: mvn -B -Pcentral-deploy deploy -DskipTests
       env:
         MAVEN_GPG_PASSPHRASE: ${{ secrets.gpg_passphrase }}