diff --git a/R/sortuse64.R b/R/sortuse64.R
index 09756b26..a08faed9 100644
--- a/R/sortuse64.R
+++ b/R/sortuse64.R
@@ -1,7 +1,8 @@
 # /*
 # R-Code for searching and merging
 # S3 atomic 64bit integers for R
-# (c) 2011 Jens Oehlschägel
+# (c) 2011-2024 Jens Oehlschägel
+# (c) 2024-2026 Michael Chirico
 # Licence: GPL2
 # Provided 'as is', use at your own risk
 # Created: 2011-12-11
@@ -72,13 +73,13 @@
 #'  message("check the code of 'optimizer64' for examples:")
 #'  print(optimizer64)
 #' @export
-sortnut <- function(sorted, ...) UseMethod("sortnut")
+sortnut = function(sorted, ...) UseMethod("sortnut")
 
 #' @rdname sortnut
 #' @export
-sortnut.integer64 <- function(sorted, ...) {
-  ret <- .Call(C_r_ram_integer64_sortnut, x = sorted)
-  names(ret) <- c("nunique", "nties")
+sortnut.integer64 = function(sorted, ...) {
+  ret = .Call(C_r_ram_integer64_sortnut, x = sorted)
+  names(ret) = c("nunique", "nties")
   ret
 }
 
@@ -86,35 +87,35 @@ sortnut.integer64 <- function(sorted, ...) {
 #' @param table the original data with original order under the sorted vector
 #' @param order an [`integer`] order vector that turns 'table' into 'sorted'
 #' @export
-ordernut <- function(table, order, ...) UseMethod("ordernut")
+ordernut = function(table, order, ...) UseMethod("ordernut")
 
 #' @rdname sortnut
 #' @export
-ordernut.integer64 <- function(table, order, ...) {
-  ret <- .Call(C_r_ram_integer64_ordernut, table = as.integer64(table), order = as.integer(order))
-  names(ret) <- c("nunique", "nties")
+ordernut.integer64 = function(table, order, ...) {
+  ret = .Call(C_r_ram_integer64_ordernut, table = as.integer64(table), order = as.integer(order))
+  names(ret) = c("nunique", "nties")
   ret
 }
 
 #' @rdname sortnut
 #' @param x an [`integer64`] vector
 #' @export
-sortfin <- function(sorted, x, ...) UseMethod("sortfin")
+sortfin = function(sorted, x, ...) UseMethod("sortfin")
 
 #' @rdname sortnut
 #' @export
-sortfin.integer64 <- function(sorted, x, method=NULL, ...) {
-  n <- length(x)
+sortfin.integer64 = function(sorted, x, method=NULL, ...) {
+  n = length(x)
   if (is.null(method)) {
     if (n<2048L) {
-      method <- 1L
+      method = 1L
     } else if (n<length(sorted)/128L) {
-      method <- 2L
+      method = 2L
     } else {
-      method <- 3L
+      method = 3L
     }
   } else {
-    method <- as.integer(method)
+    method = as.integer(method)
   }
   if (method==1L) {
       .Call(C_r_ram_integer64_sortfin_asc
@@ -124,9 +125,9 @@ sortfin.integer64 <- function(sorted, x, method=NULL, ...) {
       , ret = logical(n)
       )
   } else {
-    sx <- clone(as.integer64(x)); o <- seq_along(x); ramsortorder(sx, o, na.last=FALSE, ...)
-    ret <- logical(n)
-    ret[o] <- .Call(C_r_ram_integer64_sortfin_asc
+    sx = clone(as.integer64(x)); o = seq_along(x); ramsortorder(sx, o, na.last=FALSE, ...)
+    ret = logical(n)
+    ret[o] = .Call(C_r_ram_integer64_sortfin_asc
       , x = sx
       , sorted = as.integer64(sorted)
       , method= method
@@ -138,22 +139,22 @@ sortfin.integer64 <- function(sorted, x, method=NULL, ...) {
 
 #' @rdname sortnut
 #' @export
-orderfin <- function(table, order, x, ...) UseMethod("orderfin")
+orderfin = function(table, order, x, ...) UseMethod("orderfin")
 
 #' @rdname sortnut
 #' @export
-orderfin.integer64 <- function(table, order, x, method=NULL, ...) {
-  n <- length(x)
+orderfin.integer64 = function(table, order, x, method=NULL, ...) {
+  n = length(x)
   if (is.null(method)) {
     if (n<4096L) {
-      method <- 1L
+      method = 1L
     } else if (n<length(table)/8L) {
-      method <- 2L
+      method = 2L
     } else {
-      method <- 3L
+      method = 3L
     }
   } else {
-    method <- as.integer(method)
+    method = as.integer(method)
   }
   if (method==1L) {
       .Call(C_r_ram_integer64_orderfin_asc
@@ -164,10 +165,10 @@ orderfin.integer64 <- function(table, order, x, method=NULL, ...) {
       , ret = logical(n)
       )
   } else {
-    x <- as.integer64(x)
-    o <- seq_along(x); ramorder(x, o, na.last=FALSE, ...)
-    ret <- logical(n)
-    ret[o] <- .Call(C_r_ram_integer64_orderfin_asc
+    x = as.integer64(x)
+    o = seq_along(x); ramorder(x, o, na.last=FALSE, ...)
+    ret = logical(n)
+    ret[o] = .Call(C_r_ram_integer64_orderfin_asc
       , x = x[o]
       , table = as.integer64(table)
       , order = as.integer(order)
@@ -180,23 +181,23 @@ orderfin.integer64 <- function(table, order, x, method=NULL, ...) {
 
 #' @rdname sortnut
 #' @export
-orderpos <- function(table, order, x, ...) UseMethod("orderpos")
+orderpos = function(table, order, x, ...) UseMethod("orderpos")
 
 #' @rdname sortnut
 #' @param nomatch the value to be returned if an element is not found in the hashmap
 #' @export
-orderpos.integer64 <- function(table, order, x, nomatch=NA, method=NULL, ...) {
-  n <- length(x)
+orderpos.integer64 = function(table, order, x, nomatch=NA, method=NULL, ...) {
+  n = length(x)
   if (is.null(method)) {
     if (n<4096L) {
-      method <- 1L
+      method = 1L
     } else if (n<length(table)/8L) {
-      method <- 2L
+      method = 2L
     } else {
-      method <- 3L
+      method = 3L
     }
   } else {
-    method <- as.integer(method)
+    method = as.integer(method)
   }
   if (method==1L) {
       .Call(C_r_ram_integer64_orderpos_asc
@@ -208,10 +209,10 @@ orderpos.integer64 <- function(table, order, x, nomatch=NA, method=NULL, ...) {
       , ret = integer(n)
       )
   } else {
-    x <- as.integer64(x)
-    o <- seq_along(x); ramorder(x, o, na.last=FALSE, ...)
-    ret <- integer(n)
-    ret[o] <- .Call(C_r_ram_integer64_orderpos_asc
+    x = as.integer64(x)
+    o = seq_along(x); ramorder(x, o, na.last=FALSE, ...)
+    ret = integer(n)
+    ret[o] = .Call(C_r_ram_integer64_orderpos_asc
       , x = x[o]
       , table = as.integer64(table)
       , order = as.integer(order)
@@ -225,22 +226,22 @@ orderpos.integer64 <- function(table, order, x, nomatch=NA, method=NULL, ...) {
 
 #' @rdname sortnut
 #' @export
-sortorderpos <- function(sorted, order, x, ...) UseMethod("sortorderpos")
+sortorderpos = function(sorted, order, x, ...) UseMethod("sortorderpos")
 
 #' @rdname sortnut
 #' @export
-sortorderpos.integer64 <- function(sorted, order, x, nomatch=NA, method=NULL, ...) {
-  n <- length(x)
+sortorderpos.integer64 = function(sorted, order, x, nomatch=NA, method=NULL, ...) {
+  n = length(x)
   if (is.null(method)) {
     if (n<2048L) {
-      method <- 1L
+      method = 1L
     } else if (n<length(sorted)/128L) {
-      method <- 2L
+      method = 2L
     } else {
-      method <- 3L
+      method = 3L
     }
   } else {
-    method <- as.integer(method)
+    method = as.integer(method)
   }
   if (method==1L) {
       .Call(C_r_ram_integer64_sortorderpos_asc
@@ -252,9 +253,9 @@ sortorderpos.integer64 <- function(sorted, order, x, nomatch=NA, method=NULL, ..
       , ret = integer(n)
       )
   } else {
-    sx <- clone(as.integer64(x)); o <- seq_along(x); ramsortorder(sx, o, na.last=FALSE, ...)
-    ret <- integer(n)
-    ret[o] <- .Call(C_r_ram_integer64_sortorderpos_asc
+    sx = clone(as.integer64(x)); o = seq_along(x); ramsortorder(sx, o, na.last=FALSE, ...)
+    ret = integer(n)
+    ret[o] = .Call(C_r_ram_integer64_sortorderpos_asc
       , x = sx
       , sorted = as.integer64(sorted)
       , order = as.integer(order)
@@ -268,18 +269,18 @@ sortorderpos.integer64 <- function(sorted, order, x, nomatch=NA, method=NULL, ..
 
 #' @rdname sortnut
 #' @export
-orderdup <- function(table, order, ...) UseMethod("orderdup")
+orderdup = function(table, order, ...) UseMethod("orderdup")
 
 #' @rdname sortnut
 #' @export
-orderdup.integer64 <- function(table, order, method=NULL, ...) {
+orderdup.integer64 = function(table, order, method=NULL, ...) {
   if (is.null(method)) {
     if (length(table)<4194304L)
-        method <- 1L
+        method = 1L
       else
-        method <- 2L
+        method = 2L
   } else {
-    method <- as.integer(method)
+    method = as.integer(method)
   }
   .Call(C_r_ram_integer64_orderdup_asc
   , table = as.integer64(table)
@@ -291,18 +292,18 @@ orderdup.integer64 <- function(table, order, method=NULL, ...) {
 
 #' @rdname sortnut
 #' @export
-sortorderdup <- function(sorted, order, ...) UseMethod("sortorderdup")
+sortorderdup = function(sorted, order, ...) UseMethod("sortorderdup")
 
 #' @rdname sortnut
 #' @export
-sortorderdup.integer64 <- function(sorted, order, method=NULL, ...) {
+sortorderdup.integer64 = function(sorted, order, method=NULL, ...) {
   if (is.null(method)) {
     if (length(sorted)<4194304L)
-        method <- 1L
+        method = 1L
       else
-        method <- 2L
+        method = 2L
   } else {
-    method <- as.integer(method)
+    method = as.integer(method)
   }
   .Call(C_r_ram_integer64_sortorderdup_asc
   , sorted = as.integer64(sorted)
@@ -316,11 +317,11 @@ sortorderdup.integer64 <- function(sorted, order, method=NULL, ...) {
 #' @param nunique number of unique elements, usually we get this from cache
 #'   or call `sortnut` or `ordernut`
 #' @export
-sortuni <- function(sorted, nunique, ...) UseMethod("sortuni")
+sortuni = function(sorted, nunique, ...) UseMethod("sortuni")
 
 #' @rdname sortnut
 #' @export
-sortuni.integer64 <- function(sorted, nunique, ...) {
+sortuni.integer64 = function(sorted, nunique, ...) {
   .Call(C_r_ram_integer64_sortuni_asc
   , sorted = as.integer64(sorted)
   , ret = integer64(nunique)
@@ -329,14 +330,14 @@ sortuni.integer64 <- function(sorted, nunique, ...) {
 
 #' @rdname sortnut
 #' @export
-orderuni <- function(table, order, nunique, ...) UseMethod("orderuni")
+orderuni = function(table, order, nunique, ...) UseMethod("orderuni")
 
 #' @rdname sortnut
 #' @param keep.order determines order of results and speed: `FALSE` (the default)
 #'   is faster and returns in sorted order, `TRUE` returns in the order of first
 #'   appearance in the original data, but this requires extra work
 #' @export
-orderuni.integer64 <- function(table, order, nunique, keep.order=FALSE, ...) {
+orderuni.integer64 = function(table, order, nunique, keep.order=FALSE, ...) {
   .Call(C_r_ram_integer64_orderuni_asc
   , table = as.integer64(table)
   , order = as.integer(order)
@@ -347,11 +348,11 @@ orderuni.integer64 <- function(table, order, nunique, keep.order=FALSE, ...) {
 
 #' @rdname sortnut
 #' @export
-sortorderuni <- function(table, sorted, order, nunique, ...) UseMethod("sortorderuni")
+sortorderuni = function(table, sorted, order, nunique, ...) UseMethod("sortorderuni")
 
 #' @rdname sortnut
 #' @export
-sortorderuni.integer64 <- function(table, sorted, order, nunique, ...) {
+sortorderuni.integer64 = function(table, sorted, order, nunique, ...) {
   .Call(C_r_ram_integer64_sortorderuni_asc
   , table = as.integer64(table)
   , sorted = as.integer64(sorted)
@@ -362,26 +363,26 @@ sortorderuni.integer64 <- function(table, sorted, order, nunique, ...) {
 
 #' @rdname sortnut
 #' @export
-orderupo <- function(table, order, nunique, ...) UseMethod("orderupo")
+orderupo = function(table, order, nunique, ...) UseMethod("orderupo")
 
 #' @rdname sortnut
 #' @export
-orderupo.integer64 <- function(table, order, nunique, keep.order=FALSE, ...) {
-    .Call(C_r_ram_integer64_orderupo_asc
-    , table = as.integer64(table)
-    , order = as.integer(order)
-    , keep.order = as.logical(keep.order)
-    , ret = integer(nunique)
-    )
+orderupo.integer64 = function(table, order, nunique, keep.order=FALSE, ...) {
+  .Call(C_r_ram_integer64_orderupo_asc
+  , table = as.integer64(table)
+  , order = as.integer(order)
+  , keep.order = as.logical(keep.order)
+  , ret = integer(nunique)
+  )
 }
 
 #' @rdname sortnut
 #' @export
-sortorderupo <- function(sorted, order, nunique, keep.order=FALSE, ...) UseMethod("sortorderupo")
+sortorderupo = function(sorted, order, nunique, keep.order=FALSE, ...) UseMethod("sortorderupo")
 
 #' @rdname sortnut
 #' @export
-sortorderupo.integer64 <- function(sorted, order, nunique, keep.order=FALSE, ...) {
+sortorderupo.integer64 = function(sorted, order, nunique, keep.order=FALSE, ...) {
   .Call(C_r_ram_integer64_sortorderupo_asc
     , sorted = as.integer64(sorted)
     , order = as.integer(order)
@@ -394,11 +395,11 @@ sortorderupo.integer64 <- function(sorted, order, nunique, keep.order=FALSE, ...
 #' @param nties number of tied values, usually we get this from cache or
 #'   call `sortnut` or `ordernut`
 #' @export
-ordertie <- function(table, order, nties, ...) UseMethod("ordertie")
+ordertie = function(table, order, nties, ...) UseMethod("ordertie")
 
 #' @rdname sortnut
 #' @export
-ordertie.integer64 <- function(table, order, nties, ...) {
+ordertie.integer64 = function(table, order, nties, ...) {
   .Call(C_r_ram_integer64_ordertie_asc
   , table = as.integer64(table)
   , order = as.integer(order)
@@ -408,11 +409,11 @@ ordertie.integer64 <- function(table, order, nties, ...) {
 
 #' @rdname sortnut
 #' @export
-sortordertie <- function(sorted, order, nties, ...) UseMethod("sortordertie")
+sortordertie = function(sorted, order, nties, ...) UseMethod("sortordertie")
 
 #' @rdname sortnut
 #' @export
-sortordertie.integer64 <- function(sorted, order, nties, ...) {
+sortordertie.integer64 = function(sorted, order, nties, ...) {
   .Call(C_r_ram_integer64_sortordertie_asc
   , sorted = as.integer64(sorted)
   , order = as.integer(order)
@@ -422,11 +423,11 @@ sortordertie.integer64 <- function(sorted, order, nties, ...) {
 
 #' @rdname sortnut
 #' @export
-sorttab <- function(sorted, nunique, ...) UseMethod("sorttab")
+sorttab = function(sorted, nunique, ...) UseMethod("sorttab")
 
 #' @rdname sortnut
 #' @export
-sorttab.integer64 <- function(sorted, nunique, ...) {
+sorttab.integer64 = function(sorted, nunique, ...) {
   .Call(C_r_ram_integer64_sorttab_asc
   , sorted = as.integer64(sorted)
   , ret = integer(nunique)
@@ -435,15 +436,15 @@ sorttab.integer64 <- function(sorted, nunique, ...) {
 
 #' @rdname sortnut
 #' @export
-ordertab <- function(table, order, nunique, ...) UseMethod("ordertab")
+ordertab = function(table, order, nunique, ...) UseMethod("ordertab")
 
 #' @rdname sortnut
 #' @param denormalize FALSE returns counts of unique values, TRUE returns each
 #'   value with its counts
 #' @export
-ordertab.integer64 <- function(table, order, nunique, denormalize=FALSE, keep.order=FALSE, ...) {
-  denormalize <- as.logical(denormalize)
-  keep.order <- as.logical(keep.order)
+ordertab.integer64 = function(table, order, nunique, denormalize=FALSE, keep.order=FALSE, ...) {
+  denormalize = as.logical(denormalize)
+  keep.order = as.logical(keep.order)
   .Call(C_r_ram_integer64_ordertab_asc
   , table = as.integer64(table)
   , order = as.integer(order)
@@ -455,11 +456,11 @@ ordertab.integer64 <- function(table, order, nunique, denormalize=FALSE, keep.or
 
 #' @rdname sortnut
 #' @export
-sortordertab <- function(sorted, order, ...) UseMethod("sortordertab")
+sortordertab = function(sorted, order, ...) UseMethod("sortordertab")
 
 #' @rdname sortnut
 #' @export
-sortordertab.integer64 <- function(sorted, order, denormalize=FALSE, ...) {
+sortordertab.integer64 = function(sorted, order, denormalize=FALSE, ...) {
   .Call(C_r_ram_integer64_sortordertab_asc
   , sorted = as.integer64(sorted)
   , order = as.integer(order)
@@ -472,26 +473,26 @@ sortordertab.integer64 <- function(sorted, order, denormalize=FALSE, ...) {
 #' @param na.skip.num 0 or the number of `NA`s. With 0, `NA`s are coded with 1L,
 #'   with the number of `NA`s, these are coded with `NA`
 #' @export
-orderkey <- function(table, order, na.skip.num=0L, ...) UseMethod("orderkey")
+orderkey = function(table, order, na.skip.num=0L, ...) UseMethod("orderkey")
 
 #' @rdname sortnut
 #' @export
-orderkey.integer64 <- function(table, order, na.skip.num=0L, ...) {
-    .Call(C_r_ram_integer64_orderkey_asc
-    , table = as.integer64(table)
-    , order = as.integer(order)
-    , na.skip.num=na.skip.num
-    , ret = integer(length(table))
-    )
+orderkey.integer64 = function(table, order, na.skip.num=0L, ...) {
+  .Call(C_r_ram_integer64_orderkey_asc
+  , table = as.integer64(table)
+  , order = as.integer(order)
+  , na.skip.num=na.skip.num
+  , ret = integer(length(table))
+  )
 }
 
 #' @rdname sortnut
 #' @export
-sortorderkey <- function(sorted, order, na.skip.num=0L, ...) UseMethod("sortorderkey")
+sortorderkey = function(sorted, order, na.skip.num=0L, ...) UseMethod("sortorderkey")
 
 #' @rdname sortnut
 #' @export
-sortorderkey.integer64 <- function(sorted, order, na.skip.num=0L, ...) {
+sortorderkey.integer64 = function(sorted, order, na.skip.num=0L, ...) {
     .Call(C_r_ram_integer64_sortorderkey_asc
     , sorted = as.integer64(sorted)
     , order = as.integer(order)
@@ -503,11 +504,11 @@ sortorderkey.integer64 <- function(sorted, order, na.skip.num=0L, ...) {
 #' @rdname sortnut
 #' @param na.count the number of `NA`s, needed for this low-level function algorithm
 #' @export
-orderrnk <- function(table, order, na.count, ...) UseMethod("orderrnk")
+orderrnk = function(table, order, na.count, ...) UseMethod("orderrnk")
 
 #' @rdname sortnut
 #' @export
-orderrnk.integer64 <- function(table, order, na.count, ...) {
+orderrnk.integer64 = function(table, order, na.count, ...) {
   .Call(C_r_ram_integer64_orderrnk_asc
   , table = as.integer64(table)
   , order = as.integer(order)
@@ -518,10 +519,10 @@ orderrnk.integer64 <- function(table, order, na.count, ...) {
 
 #' @rdname sortnut
 #' @export
-sortorderrnk <- function(sorted, order, na.count, ...) UseMethod("sortorderrnk")
+sortorderrnk = function(sorted, order, na.count, ...) UseMethod("sortorderrnk")
 #' @rdname sortnut
 #' @export
-sortorderrnk.integer64 <- function(sorted, order, na.count, ...) {
+sortorderrnk.integer64 = function(sorted, order, na.count, ...) {
   .Call(C_r_ram_integer64_sortorderrnk_asc
   , sorted = as.integer64(sorted)
   , order = as.integer(order)
@@ -533,29 +534,29 @@ sortorderrnk.integer64 <- function(sorted, order, na.count, ...) {
 #' @rdname sortnut
 #' @param probs vector of probabilities in `[0..1]` for which we seek quantiles
 #' @export
-sortqtl <- function(sorted, na.count, probs, ...) UseMethod("sortqtl")
+sortqtl = function(sorted, na.count, probs, ...) UseMethod("sortqtl")
 
 #' @rdname sortnut
 #' @export
-sortqtl.integer64 <- function(sorted, na.count, probs, ...) {
-    n <- length(sorted) - na.count  # nvalid
-    ret <- sorted[na.count + round(1L + probs * (n-1L))]
-    # TODO(#31): Remove this once `[` can return NA for integer64 directly
-    ret[is.na(probs)] <- NA
-    ret
+sortqtl.integer64 = function(sorted, na.count, probs, ...) {
+  n = length(sorted) - na.count  # nvalid
+  ret = sorted[na.count + round(1L + probs * (n-1L))]
+  # TODO(#31): Remove this once `[` can return NA for integer64 directly
+  ret[is.na(probs)] = NA
+  ret
 }
 
 #' @rdname sortnut
 #' @export
-orderqtl <- function(table, order, na.count, probs, ...) UseMethod("orderqtl")
+orderqtl = function(table, order, na.count, probs, ...) UseMethod("orderqtl")
 
 #' @rdname sortnut
 #' @export
-orderqtl.integer64 <- function(table, order, na.count, probs, ...) {
+orderqtl.integer64 = function(table, order, na.count, probs, ...) {
   n = length(table) - na.count  # nvalid
   idx = na.count + round(1L + probs * (n-1L))
   ret = table[order[idx]]
   # TODO(#31): Remove this once `[` can return NA for integer64 directly
-  ret[is.na(probs)] <- NA
+  ret[is.na(probs)] = NA
   ret
 }