diff --git a/R/cache.R b/R/cache.R
index bfa059f..2815244 100644
--- a/R/cache.R
+++ b/R/cache.R
@@ -29,7 +29,7 @@
 #! setcache(x, which, value)
 #! getcache(x, which)
 #! remcache(x)
-#! \method{print}{cache}(x, all.names = FALSE, pattern, \dots)
+#! \method{print}{cache}(x, all.names = FALSE, pattern, ...)
 #! }
 #! \arguments{
 #!   \item{x}{
@@ -47,7 +47,7 @@
 #!   \item{pattern}{
 #!   passed to \code{\link{ls}} when listing the cache content
 #! }
-#!   \item{\dots}{
+#!   \item{...}{
 #!     ignored
 #! }
 #! }
@@ -181,7 +181,7 @@ print.cache<- function(x, all.names=FALSE, pattern, ...){
 #!     Functions to create cache that accelerates many operations
 #! }
 #! \usage{
-#! hashcache(x, nunique=NULL, \dots)
+#! hashcache(x, nunique=NULL, ...)
 #! sortcache(x, has.na = NULL)
 #! sortordercache(x, has.na = NULL, stable = NULL)
 #! ordercache(x, has.na = NULL, stable = NULL, optimize = "time")
@@ -202,7 +202,7 @@ print.cache<- function(x, all.names=FALSE, pattern, ...){
 #! by default ramsort optimizes for 'time' which requires more RAM,
 #! set to 'memory' to minimize RAM requirements and sacrifice speed
 #! }
-#!   \item{\dots}{
+#!   \item{...}{
 #!         passed to \code{\link{hashmap}}
 #! }
 #! }
@@ -327,17 +327,17 @@ ordercache <- function(x, has.na = NULL, stable = NULL, optimize = "time"){
 #!     These methods are packaged here for methods in packages \code{bit64} and \code{ff}.
 #! }
 #! \usage{
-#!     \method{is.sorted}{integer64}(x, \dots)
-#!     \method{na.count}{integer64}(x, \dots)
-#!     \method{nvalid}{integer64}(x, \dots)
-#!     \method{nunique}{integer64}(x, \dots)
-#!     \method{nties}{integer64}(x, \dots)
+#!     \method{is.sorted}{integer64}(x, ...)
+#!     \method{na.count}{integer64}(x, ...)
+#!     \method{nvalid}{integer64}(x, ...)
+#!     \method{nunique}{integer64}(x, ...)
+#!     \method{nties}{integer64}(x, ...)
 #! }
 #! \arguments{
 #!   \item{x}{
 #!     some object
 #!     }
-#!   \item{\dots}{
+#!   \item{...}{
 #!     ignored
 #!     }
 #! }
diff --git a/R/hash64.R b/R/hash64.R
index 65942e8..51a2de9 100644
--- a/R/hash64.R
+++ b/R/hash64.R
@@ -46,32 +46,32 @@
 #! re-use hashmaps, which avoid re-building hashmaps again and again.
 #! }
 #! \usage{
-#! hashfun(x, \dots)
-#! \method{hashfun}{integer64}(x, minfac=1.41, hashbits=NULL, \dots)
-#! hashmap(x, \dots)
-#! \method{hashmap}{integer64}(x, nunique=NULL, minfac=1.41, hashbits=NULL, cache=NULL, \dots)
-#! hashpos(cache, \dots)
-#! \method{hashpos}{cache_integer64}(cache, x, nomatch = NA_integer_, \dots)
-#! hashrev(cache, \dots)
-#! \method{hashrev}{cache_integer64}(cache, x, nomatch = NA_integer_, \dots)
-#! hashfin(cache, \dots)
-#! \method{hashfin}{cache_integer64}(cache, x, \dots)
-#! hashrin(cache, \dots)
-#! \method{hashrin}{cache_integer64}(cache, x, \dots)
-#! hashdup(cache, \dots)
-#! \method{hashdup}{cache_integer64}(cache, \dots)
-#! hashuni(cache, \dots)
-#! \method{hashuni}{cache_integer64}(cache, keep.order=FALSE, \dots)
-#! hashmapuni(x, \dots)
-#! \method{hashmapuni}{integer64}(x, nunique=NULL, minfac=1.5, hashbits=NULL, \dots)
-#! hashupo(cache, \dots)
-#! \method{hashupo}{cache_integer64}(cache, keep.order=FALSE, \dots)
-#! hashmapupo(x, \dots)
-#! \method{hashmapupo}{integer64}(x, nunique=NULL, minfac=1.5, hashbits=NULL, \dots)
-#! hashtab(cache, \dots)
-#! \method{hashtab}{cache_integer64}(cache, \dots)
-#! hashmaptab(x, \dots)
-#! \method{hashmaptab}{integer64}(x, nunique=NULL, minfac=1.5, hashbits=NULL, \dots)
+#! hashfun(x, ...)
+#! \method{hashfun}{integer64}(x, minfac=1.41, hashbits=NULL, ...)
+#! hashmap(x, ...)
+#! \method{hashmap}{integer64}(x, nunique=NULL, minfac=1.41, hashbits=NULL, cache=NULL, ...)
+#! hashpos(cache, ...)
+#! \method{hashpos}{cache_integer64}(cache, x, nomatch = NA_integer_, ...)
+#! hashrev(cache, ...)
+#! \method{hashrev}{cache_integer64}(cache, x, nomatch = NA_integer_, ...)
+#! hashfin(cache, ...)
+#! \method{hashfin}{cache_integer64}(cache, x, ...)
+#! hashrin(cache, ...)
+#! \method{hashrin}{cache_integer64}(cache, x, ...)
+#! hashdup(cache, ...)
+#! \method{hashdup}{cache_integer64}(cache, ...)
+#! hashuni(cache, ...)
+#! \method{hashuni}{cache_integer64}(cache, keep.order=FALSE, ...)
+#! hashmapuni(x, ...)
+#! \method{hashmapuni}{integer64}(x, nunique=NULL, minfac=1.5, hashbits=NULL, ...)
+#! hashupo(cache, ...)
+#! \method{hashupo}{cache_integer64}(cache, keep.order=FALSE, ...)
+#! hashmapupo(x, ...)
+#! \method{hashmapupo}{integer64}(x, nunique=NULL, minfac=1.5, hashbits=NULL, ...)
+#! hashtab(cache, ...)
+#! \method{hashtab}{cache_integer64}(cache, ...)
+#! hashmaptab(x, ...)
+#! \method{hashmaptab}{integer64}(x, nunique=NULL, minfac=1.5, hashbits=NULL, ...)
 #! }
 #! \arguments{
 #!   \item{x}{ an integer64 vector }
@@ -82,7 +82,7 @@
 #!   \item{nunique}{ giving \emph{correct} number of unique elements can help reducing the size of the hashmap }
 #!   \item{nomatch}{ the value to be returned if an element is not found in the hashmap }
 #!   \item{keep.order}{ determines order of results and speed: \code{FALSE} (the default) is faster and returns in the (pseudo)random order of the hash function, \code{TRUE} returns in the order of first appearance in the original data, but this requires extra work }
-#!   \item{\dots}{ further arguments, passed from generics, ignored in methods }
+#!   \item{...}{ further arguments, passed from generics, ignored in methods }
 #! }
 #! \details{
 #! \tabular{rrl}{
diff --git a/R/highlevel64.R b/R/highlevel64.R
index b08ee32..a239aff 100644
--- a/R/highlevel64.R
+++ b/R/highlevel64.R
@@ -1417,7 +1417,7 @@ optimizer64 <- function(nsmall=2L^16L, nbig=2L^25L, timefun=repeat.time
 #!   \item{method}{
 #!     NULL for automatic method selection or a suitable low-level method, see details
 #! }
-#!   \item{\dots}{
+#!   \item{...}{
 #! ignored
 #! }
 #! }
@@ -1706,7 +1706,7 @@ match.integer64 <- function(x, table, nomatch = NA_integer_, nunique=NULL, metho
 #!   indicating which elements (rows) are duplicates.
 #! }
 #! \usage{
-#! \method{duplicated}{integer64}(x, incomparables = FALSE, nunique = NULL, method = NULL, \dots)
+#! \method{duplicated}{integer64}(x, incomparables = FALSE, nunique = NULL, method = NULL, ...)
 #! }
 #! \arguments{
 #!   \item{x}{a vector or a data frame or an array or \code{NULL}.}
@@ -1717,7 +1717,7 @@ match.integer64 <- function(x, table, nomatch = NA_integer_, nunique=NULL, metho
 #!   \item{method}{
 #!     NULL for automatic method selection or a suitable low-level method, see details
 #! }
-#!   \item{\dots}{ignored}
+#!   \item{...}{ignored}
 #! }
 #! \details{
 #!   This function automatically chooses from several low-level functions considering the size of \code{x} and the availability of a cache.
@@ -1810,7 +1810,7 @@ duplicated.integer64 <- function(x
 #! }
 #! \usage{
 #! \method{unique}{integer64}(x, incomparables = FALSE, order = c("original","values","any")
-#! , nunique = NULL, method = NULL, \dots)
+#! , nunique = NULL, method = NULL, ...)
 #! }
 #! \arguments{
 #!   \item{x}{a vector or a data frame or an array or \code{NULL}.}
@@ -1822,7 +1822,7 @@ duplicated.integer64 <- function(x
 #!   \item{method}{
 #!     NULL for automatic method selection or a suitable low-level method, see details
 #! }
-#!   \item{\dots}{ignored}
+#!   \item{...}{ignored}
 #! }
 #! \details{
 #!   This function automatically chooses from several low-level functions considering the size of \code{x} and the availability of a cache.
@@ -1979,9 +1979,9 @@ unique.integer64 <- function(x
 #!   \code{unipos} returns the positions of those elements returned by \code{\link{unique}}.
 #! }
 #! \usage{
-#! unipos(x, incomparables = FALSE, order = c("original","values","any"), \dots)
+#! unipos(x, incomparables = FALSE, order = c("original","values","any"), ...)
 #! \method{unipos}{integer64}(x, incomparables = FALSE, order = c("original","values","any")
-#! , nunique = NULL, method = NULL, \dots)
+#! , nunique = NULL, method = NULL, ...)
 #! }
 #! \arguments{
 #!   \item{x}{a vector or a data frame or an array or \code{NULL}.}
@@ -1993,7 +1993,7 @@ unique.integer64 <- function(x
 #!   \item{method}{
 #!     NULL for automatic method selection or a suitable low-level method, see details
 #! }
-#!   \item{\dots}{ignored}
+#!   \item{...}{ignored}
 #! }
 #! \details{
 #!   This function automatically chooses from several low-level functions considering the size of \code{x} and the availability of a cache.
@@ -2147,7 +2147,7 @@ unipos.integer64 <- function(x
 #!   table of the counts at each combination of vector values.
 #! }
 #! \usage{
-#! table.integer64(\dots
+#! table.integer64(...
 #! , return = c("table","data.frame","list")
 #! , order = c("values","counts")
 #! , nunique = NULL
@@ -2156,7 +2156,7 @@ unipos.integer64 <- function(x
 #! )
 #! }
 #! \arguments{
-#!   \item{\dots}{one or more objects which can be interpreted as factors
+#!   \item{...}{one or more objects which can be interpreted as factors
 #!     (including character strings), or a list (or data frame) whose
 #!     components can be so interpreted.  (For \code{as.table} and
 #!     \code{as.data.frame}, arguments passed to specific methods.)}
@@ -2186,7 +2186,7 @@ unipos.integer64 <- function(x
 #! \cr
 #!   If the argument \code{dnn} is not supplied, the internal function
 #!   \code{list.names} is called to compute the \sQuote{dimname names}.  If the
-#!   arguments in \code{\dots} are named, those names are used.  For the
+#!   arguments in \code{...} are named, those names are used.  For the
 #!   remaining arguments, \code{deparse.level = 0} gives an empty name,
 #!   \code{deparse.level = 1} uses the supplied argument if it is a symbol,
 #!   and \code{deparse.level = 2} will deparse the argument.
@@ -2481,15 +2481,15 @@ as.integer64.factor <- function(x, ...)as.integer64(unclass(x))
 #!   \code{keypos} returns the positions of the (fact table) elements that participate in their sorted unique subset (dimension table)
 #! }
 #! \usage{
-#! keypos(x, \dots)
-#! \method{keypos}{integer64}(x, method = NULL, \dots)
+#! keypos(x, ...)
+#! \method{keypos}{integer64}(x, method = NULL, ...)
 #! }
 #! \arguments{
 #!   \item{x}{a vector or a data frame or an array or \code{NULL}.}
 #!   \item{method}{
 #!     NULL for automatic method selection or a suitable low-level method, see details
 #! }
-#!   \item{\dots}{ignored}
+#!   \item{...}{ignored}
 #! }
 #! \details{
 #!   NAs are sorted first in the dimension table, see \code{\link{ramorder.integer64}}.
@@ -2569,8 +2569,8 @@ keypos.integer64 <- function(x
 #!   \code{tiepos} returns the positions of those elements that participate in ties.
 #! }
 #! \usage{
-#! tiepos(x, \dots)
-#! \method{tiepos}{integer64}(x, nties = NULL, method = NULL, \dots)
+#! tiepos(x, ...)
+#! \method{tiepos}{integer64}(x, nties = NULL, method = NULL, ...)
 #! }
 #! \arguments{
 #!   \item{x}{a vector or a data frame or an array or \code{NULL}.}
@@ -2580,7 +2580,7 @@ keypos.integer64 <- function(x
 #!   \item{method}{
 #!     NULL for automatic method selection or a suitable low-level method, see details
 #! }
-#!   \item{\dots}{ignored}
+#!   \item{...}{ignored}
 #! }
 #! \details{
 #!   This function automatically chooses from several low-level functions considering the size of \code{x} and the availability of a cache.
@@ -2665,14 +2665,14 @@ tiepos.integer64 <- function(x
 #!   values) are averaged and missing values propagated.
 #! }
 #! \usage{
-#!     \method{rank}{integer64}(x, method = NULL, \dots)
+#!     \method{rank}{integer64}(x, method = NULL, ...)
 #! }
 #! \arguments{
 #!   \item{x}{a integer64 vector}
 #!   \item{method}{
 #!     NULL for automatic method selection or a suitable low-level method, see details
 #! }
-#!   \item{\dots}{ignored}
+#!   \item{...}{ignored}
 #! }
 #! \details{
 #!   This function automatically chooses from several low-level functions considering the size of \code{x} and the availability of a cache.
@@ -2750,15 +2750,15 @@ rank.integer64 <- function(x
 #!     \code{\link{qtile.integer64}} is the inverse function of 'prank.integer64' and projects [0..1] to [min..max].
 #! }
 #! \usage{
-#!     prank(x, \dots)
-#!     \method{prank}{integer64}(x, method = NULL, \dots)
+#!     prank(x, ...)
+#!     \method{prank}{integer64}(x, method = NULL, ...)
 #! }
 #! \arguments{
 #!   \item{x}{a integer64 vector}
 #!   \item{method}{
 #!     NULL for automatic method selection or a suitable low-level method, see details
 #! }
-#!   \item{\dots}{ignored}
+#!   \item{...}{ignored}
 #! }
 #! \details{
 #!     Function \code{prank.integer64} is based on \code{\link{rank.integer64}}.
@@ -2806,12 +2806,12 @@ prank.integer64 <- function(x
 #!     \code{qtile.ineger64} is the inverse function of 'prank.integer64' and projects [0..1] to [min..max].
 #! }
 #! \usage{
-#!     qtile(x, probs=seq(0, 1, 0.25), \dots)
-#!     \method{qtile}{integer64}(x, probs = seq(0, 1, 0.25), names = TRUE, method = NULL, \dots)
-#!     \method{quantile}{integer64}(x, probs = seq(0, 1, 0.25), na.rm = FALSE, names = TRUE, type=0L, \dots)
-#!     \method{median}{integer64}(x, na.rm = FALSE, \dots)
-#!  \method{mean}{integer64}(x, na.rm = FALSE, \dots)
-#!     \method{summary}{integer64}(object, \dots)
+#!     qtile(x, probs=seq(0, 1, 0.25), ...)
+#!     \method{qtile}{integer64}(x, probs = seq(0, 1, 0.25), names = TRUE, method = NULL, ...)
+#!     \method{quantile}{integer64}(x, probs = seq(0, 1, 0.25), na.rm = FALSE, names = TRUE, type=0L, ...)
+#!     \method{median}{integer64}(x, na.rm = FALSE, ...)
+#!  \method{mean}{integer64}(x, na.rm = FALSE, ...)
+#!     \method{summary}{integer64}(object, ...)
 #!  ## mean(x, na.rm = FALSE, ...)
 #!  ## or
 #!  ## mean(x, na.rm = FALSE)
@@ -2834,7 +2834,7 @@ prank.integer64 <- function(x
 #!   \item{na.rm}{
 #!     logical; if \code{TRUE}, any \code{NA} and \code{NaN}'s are removed from \code{x} before the quantiles are computed.
 #! }
-#!   \item{\dots}{ignored}
+#!   \item{...}{ignored}
 #! }
 #! \details{
 #!  Functions \code{quantile.integer64} with \code{type=0} and \code{median.integer64} are convenience wrappers to \code{qtile}.
diff --git a/R/integer64.R b/R/integer64.R
index ff24496..f28dccb 100644
--- a/R/integer64.R
+++ b/R/integer64.R
@@ -64,8 +64,8 @@
 #!  integer64(length)
 #!  \method{is}{integer64}(x)
 #!  \method{length}{integer64}(x) <- value
-#!  \method{print}{integer64}(x, quote=FALSE, \dots)
-#!  \method{str}{integer64}(object, vec.len  = strO$vec.len, give.head = TRUE, give.length = give.head, \dots)
+#!  \method{print}{integer64}(x, quote=FALSE, ...)
+#!  \method{str}{integer64}(object, vec.len  = strO$vec.len, give.head = TRUE, give.length = give.head, ...)
 #! }
 #! \arguments{
 #!   \item{length}{ length of vector using \code{\link{integer}} }
@@ -76,7 +76,7 @@
 #!   \item{vec.len}{ see \code{\link[utils]{str}} }
 #!   \item{give.head}{ see \code{\link[utils]{str}} }
 #!   \item{give.length}{ see \code{\link[utils]{str}} }
-#!   \item{\dots}{ further arguments to the \code{\link{NextMethod}} }
+#!   \item{...}{ further arguments to the \code{\link{NextMethod}} }
 #! }
 #! \details{
 #! \tabular{ll}{
@@ -963,21 +963,21 @@
 #!   \code{\link{as.logical}}, \code{\link{as.integer}} do what you would expect.
 #! }
 #! \usage{
-#!  as.bitstring(x, \dots)
-#!  \method{as.bitstring}{integer64}(x, \dots)
-#!  \method{print}{bitstring}(x, \dots)
-#!  \method{as.character}{integer64}(x, \dots)
-#!  \method{as.double}{integer64}(x, keep.names = FALSE, \dots)
-#!  \method{as.integer}{integer64}(x, \dots)
-#!  \method{as.logical}{integer64}(x, \dots)
+#!  as.bitstring(x, ...)
+#!  \method{as.bitstring}{integer64}(x, ...)
+#!  \method{print}{bitstring}(x, ...)
+#!  \method{as.character}{integer64}(x, ...)
+#!  \method{as.double}{integer64}(x, keep.names = FALSE, ...)
+#!  \method{as.integer}{integer64}(x, ...)
+#!  \method{as.logical}{integer64}(x, ...)
 #!  \method{as.factor}{integer64}(x)
 #!  \method{as.ordered}{integer64}(x)
-#!  \method{as.list}{integer64}(x, \dots)
+#!  \method{as.list}{integer64}(x, ...)
 #! }
 #! \arguments{
 #!   \item{x}{ an integer64 vector }
 #!   \item{keep.names}{ FALSE, set to TRUE to keep a names vector }
-#!   \item{\dots}{ further arguments to the \code{\link{NextMethod}} }
+#!   \item{...}{ further arguments to the \code{\link{NextMethod}} }
 #! }
 #! \value{
 #!   \code{as.bitstring} returns a string of class 'bitstring'. \cr
@@ -1016,20 +1016,20 @@
 #! }
 #! \usage{
 #!  NA_integer64_
-#!  as.integer64(x, \dots)
-#!  \method{as.integer64}{integer64}(x, \dots)
-#!  \method{as.integer64}{NULL}(x, \dots)
-#!  \method{as.integer64}{character}(x, \dots)
-#!  \method{as.integer64}{bitstring}(x, \dots)
-#!  \method{as.integer64}{double}(x, keep.names = FALSE, \dots)
-#!  \method{as.integer64}{integer}(x, \dots)
-#!  \method{as.integer64}{logical}(x, \dots)
-#!  \method{as.integer64}{factor}(x, \dots)
+#!  as.integer64(x, ...)
+#!  \method{as.integer64}{integer64}(x, ...)
+#!  \method{as.integer64}{NULL}(x, ...)
+#!  \method{as.integer64}{character}(x, ...)
+#!  \method{as.integer64}{bitstring}(x, ...)
+#!  \method{as.integer64}{double}(x, keep.names = FALSE, ...)
+#!  \method{as.integer64}{integer}(x, ...)
+#!  \method{as.integer64}{logical}(x, ...)
+#!  \method{as.integer64}{factor}(x, ...)
 #! }
 #! \arguments{
 #!   \item{x}{ an atomic vector }
 #!   \item{keep.names}{ FALSE, set to TRUE to keep a names vector }
-#!   \item{\dots}{ further arguments to the \code{\link{NextMethod}} }
+#!   \item{...}{ further arguments to the \code{\link{NextMethod}} }
 #! }
 #! \details{
 #!   \code{as.integer64.character} is realized using C function \code{strtoll} which does not support scientific notation.
@@ -1084,16 +1084,16 @@
 #!   Methods to extract and replace parts of an integer64 vector.
 #! }
 #! \usage{
-#!  \method{[}{integer64}(x, i, \dots)
-#!  \method{[}{integer64}(x, \dots) <- value
-#!  \method{[[}{integer64}(x, \dots)
-#!  \method{[[}{integer64}(x, \dots) <- value
+#!  \method{[}{integer64}(x, i, ...)
+#!  \method{[}{integer64}(x, ...) <- value
+#!  \method{[[}{integer64}(x, ...)
+#!  \method{[[}{integer64}(x, ...) <- value
 #! }
 #! \arguments{
 #!   \item{x}{ an atomic vector }
 #!   \item{i}{ indices specifying elements to extract }
 #!   \item{value}{ an atomic vector with values to be assigned }
-#!   \item{\dots}{ further arguments to the \code{\link{NextMethod}} }
+#!   \item{...}{ further arguments to the \code{\link{NextMethod}} }
 #! }
 #! \note{
 #!   You should not subscript non-existing elements and not use \code{NA}s as subscripts.
@@ -1147,7 +1147,7 @@
 #!   Unary operators and functions for integer64 vectors.
 #! }
 #! \usage{
-#! \method{format}{integer64}(x, justify="right", \dots)
+#! \method{format}{integer64}(x, justify="right", ...)
 #! \method{is.na}{integer64}(x)
 #! \method{is.nan}{integer64}(x)
 #! \method{is.finite}{integer64}(x)
@@ -1161,7 +1161,7 @@
 #! \method{log10}{integer64}(x)
 #! \method{floor}{integer64}(x)
 #! \method{ceiling}{integer64}(x)
-#! \method{trunc}{integer64}(x, \dots)
+#! \method{trunc}{integer64}(x, ...)
 #! \method{round}{integer64}(x, digits=0)
 #! \method{signif}{integer64}(x, digits=6)
 #! \method{scale}{integer64}(x, center = TRUE, scale = TRUE)
@@ -1174,7 +1174,7 @@
 #!   \item{justify}{ should it be right-justified (the default), left-justified, centred or left alone. }
 #!   \item{center}{ see \code{\link{scale}} }
 #!   \item{scale}{  see \code{\link{scale}} }
-#!   \item{\dots}{ further arguments to the \code{\link{NextMethod}} }
+#!   \item{...}{ further arguments to the \code{\link{NextMethod}} }
 #! }
 #! \value{
 #!   \code{\link{format}} returns a character vector \cr
@@ -1296,17 +1296,17 @@
 #!   Function 'range' without arguments returns the smallest and largest value of the 'integer64' class.
 #! }
 #! \usage{
-#! \method{all}{integer64}(\dots, na.rm = FALSE)
-#! \method{any}{integer64}(\dots, na.rm = FALSE)
-#! \method{min}{integer64}(\dots, na.rm = FALSE)
-#! \method{max}{integer64}(\dots, na.rm = FALSE)
-#! \method{range}{integer64}(\dots, na.rm = FALSE, finite = FALSE)
+#! \method{all}{integer64}(..., na.rm = FALSE)
+#! \method{any}{integer64}(..., na.rm = FALSE)
+#! \method{min}{integer64}(..., na.rm = FALSE)
+#! \method{max}{integer64}(..., na.rm = FALSE)
+#! \method{range}{integer64}(..., na.rm = FALSE, finite = FALSE)
 #! lim.integer64()
-#! \method{sum}{integer64}(\dots, na.rm = FALSE)
-#! \method{prod}{integer64}(\dots, na.rm = FALSE)
+#! \method{sum}{integer64}(..., na.rm = FALSE)
+#! \method{prod}{integer64}(..., na.rm = FALSE)
 #! }
 #! \arguments{
-#!   \item{\dots}{ atomic vectors of class 'integer64'}
+#!   \item{...}{ atomic vectors of class 'integer64'}
 #!   \item{na.rm}{ logical scalar indicating whether to ignore NAs }
 #!   \item{finite}{ logical scalar indicating whether to ignore NAs (just for compatibility with \code{\link{range.default}}) }
 #! }
@@ -1352,13 +1352,13 @@
 #! \method{cummax}{integer64}(x)
 #! \method{cumsum}{integer64}(x)
 #! \method{cumprod}{integer64}(x)
-#! \method{diff}{integer64}(x, lag = 1L, differences = 1L, \dots)
+#! \method{diff}{integer64}(x, lag = 1L, differences = 1L, ...)
 #! }
 #! \arguments{
 #!   \item{x}{ an atomic vector of class 'integer64'}
 #!   \item{lag}{ see \code{\link{diff}} }
 #!   \item{differences}{ see \code{\link{diff}} }
-#!   \item{\dots}{ ignored }
+#!   \item{...}{ ignored }
 #! }
 #! \value{
 #!   \code{\link{cummin}}, \code{\link{cummax}} , \code{\link{cumsum}} and \code{\link{cumprod}}
@@ -1390,12 +1390,12 @@
 #!   The ususal functions 'c', 'cbind' and 'rbind'
 #! }
 #! \usage{
-#! \method{c}{integer64}(\dots, recursive = FALSE)
-#! \method{cbind}{integer64}(\dots)
-#! \method{rbind}{integer64}(\dots)
+#! \method{c}{integer64}(..., recursive = FALSE)
+#! \method{cbind}{integer64}(...)
+#! \method{rbind}{integer64}(...)
 #! }
 #! \arguments{
-#!   \item{\dots}{ two or more arguments coerced to 'integer64' and passed to \code{\link{NextMethod}} }
+#!   \item{...}{ two or more arguments coerced to 'integer64' and passed to \code{\link{NextMethod}} }
 #!   \item{recursive}{ logical. If \code{recursive = TRUE}, the function recursively descends through lists (and pairlists) combining all their elements into a vector. }
 #! }
 #! \value{
@@ -1429,11 +1429,11 @@
 #!   Replicate elements of integer64 vectors
 #! }
 #! \usage{
-#! \method{rep}{integer64}(x, \dots)
+#! \method{rep}{integer64}(x, ...)
 #! }
 #! \arguments{
 #!   \item{x}{ a vector of 'integer64' to be replicated }
-#!   \item{\dots}{ further arguments passed to \code{\link{NextMethod}} }
+#!   \item{...}{ further arguments passed to \code{\link{NextMethod}} }
 #! }
 #! \value{
 #!   \code{\link{rep}} returns a integer64 vector
@@ -1462,7 +1462,7 @@
 #!   Generating sequence of integer64 values
 #! }
 #! \usage{
-#! \method{seq}{integer64}(from = NULL, to = NULL, by = NULL, length.out = NULL, along.with = NULL, \dots)
+#! \method{seq}{integer64}(from = NULL, to = NULL, by = NULL, length.out = NULL, along.with = NULL, ...)
 #! }
 #! \arguments{
 #!   \item{from}{ integer64 scalar (in order to dispatch the integer64 method of \code{\link{seq}} }
@@ -1470,7 +1470,7 @@
 #!   \item{by}{ scalar }
 #!   \item{length.out}{ scalar }
 #!   \item{along.with}{ scalar }
-#!   \item{\dots}{ ignored }
+#!   \item{...}{ ignored }
 #! }
 #! \details{
 #!   \code{seq.integer64} does coerce its arguments 'from', 'to' and 'by' to \code{integer64}.
@@ -1507,11 +1507,11 @@
 #!   Coercing integer64 vector to data.frame.
 #! }
 #! \usage{
-#!   \method{as.data.frame}{integer64}(x, \dots)
+#!   \method{as.data.frame}{integer64}(x, ...)
 #! }
 #! \arguments{
 #!   \item{x}{ an integer64 vector }
-#!   \item{\dots}{ passed to NextMethod \code{\link{as.data.frame}} after removing the 'integer64' class attribute }
+#!   \item{...}{ passed to NextMethod \code{\link{as.data.frame}} after removing the 'integer64' class attribute }
 #! }
 #! \value{
 #!   a one-column data.frame containing an integer64 vector
@@ -1610,7 +1610,7 @@
 #!     \code{err}, the relative, absolute or scaled error, and
 #!     \code{what}, a character string indicating the \emph{kind} of error;
 #!     maybe used, e.g., to format relative and absolute errors differently.}
-#!   \item{\dots}{further arguments are ignored}
+#!   \item{...}{further arguments are ignored}
 #!   \item{check.attributes}{logical indicating if the
 #!     \code{\link{attributes}} of \code{target} and \code{current}
 #!     (other than the names) should be compared.}
diff --git a/R/patch64.R b/R/patch64.R
index 679bf34..a11972a 100644
--- a/R/patch64.R
+++ b/R/patch64.R
@@ -59,7 +59,7 @@
 #! }
 #!   \item{from}{ scalar denoting first element of sequence }
 #!   \item{to}{ scalar denoting last element of sequence }
-#!   \item{\dots}{ ignored }
+#!   \item{...}{ ignored }
 #! }
 #! \details{
 #!    The following functions are turned into S3 gernerics in order to dispatch methods for \code{\link{integer64}}:
diff --git a/R/sort64.R b/R/sort64.R
index a78fabf..01fd7dd 100644
--- a/R/sort64.R
+++ b/R/sort64.R
@@ -36,27 +36,27 @@
 #!  The \code{sort}-methods change \code{x}, the \code{order}-methods change \code{i}, and the \code{sortoder}-methods change both \code{x} and \code{i}
 #! }
 #! \usage{
-#! \method{shellsort}{integer64}(x, has.na=TRUE, na.last=FALSE, decreasing=FALSE, \dots)
-#! \method{shellsortorder}{integer64}(x, i, has.na=TRUE, na.last=FALSE, decreasing=FALSE, \dots)
-#! \method{shellorder}{integer64}(x, i, has.na=TRUE, na.last=FALSE, decreasing=FALSE, \dots)
-#! \method{mergesort}{integer64}(x, has.na=TRUE, na.last=FALSE, decreasing=FALSE, \dots)
-#! \method{mergeorder}{integer64}(x, i, has.na=TRUE, na.last=FALSE, decreasing=FALSE, \dots)
-#! \method{mergesortorder}{integer64}(x, i, has.na=TRUE, na.last=FALSE, decreasing=FALSE, \dots)
+#! \method{shellsort}{integer64}(x, has.na=TRUE, na.last=FALSE, decreasing=FALSE, ...)
+#! \method{shellsortorder}{integer64}(x, i, has.na=TRUE, na.last=FALSE, decreasing=FALSE, ...)
+#! \method{shellorder}{integer64}(x, i, has.na=TRUE, na.last=FALSE, decreasing=FALSE, ...)
+#! \method{mergesort}{integer64}(x, has.na=TRUE, na.last=FALSE, decreasing=FALSE, ...)
+#! \method{mergeorder}{integer64}(x, i, has.na=TRUE, na.last=FALSE, decreasing=FALSE, ...)
+#! \method{mergesortorder}{integer64}(x, i, has.na=TRUE, na.last=FALSE, decreasing=FALSE, ...)
 #! \method{quicksort}{integer64}(x, has.na=TRUE, na.last=FALSE, decreasing=FALSE
-#! , restlevel=floor(1.5*log2(length(x))), \dots)
+#! , restlevel=floor(1.5*log2(length(x))), ...)
 #! \method{quicksortorder}{integer64}(x, i, has.na=TRUE, na.last=FALSE, decreasing=FALSE
-#! , restlevel=floor(1.5*log2(length(x))), \dots)
+#! , restlevel=floor(1.5*log2(length(x))), ...)
 #! \method{quickorder}{integer64}(x, i, has.na=TRUE, na.last=FALSE, decreasing=FALSE
-#! , restlevel=floor(1.5*log2(length(x))), \dots)
-#! \method{radixsort}{integer64}(x, has.na=TRUE, na.last=FALSE, decreasing=FALSE, radixbits=8L, \dots)
-#! \method{radixsortorder}{integer64}(x, i, has.na=TRUE, na.last=FALSE, decreasing=FALSE, radixbits=8L, \dots)
-#! \method{radixorder}{integer64}(x, i, has.na=TRUE, na.last=FALSE, decreasing=FALSE, radixbits=8L, \dots)
+#! , restlevel=floor(1.5*log2(length(x))), ...)
+#! \method{radixsort}{integer64}(x, has.na=TRUE, na.last=FALSE, decreasing=FALSE, radixbits=8L, ...)
+#! \method{radixsortorder}{integer64}(x, i, has.na=TRUE, na.last=FALSE, decreasing=FALSE, radixbits=8L, ...)
+#! \method{radixorder}{integer64}(x, i, has.na=TRUE, na.last=FALSE, decreasing=FALSE, radixbits=8L, ...)
 #! \method{ramsort}{integer64}(x, has.na = TRUE, na.last=FALSE, decreasing = FALSE, stable = TRUE
-#! , optimize = c("time", "memory"), VERBOSE = FALSE, \dots)
+#! , optimize = c("time", "memory"), VERBOSE = FALSE, ...)
 #! \method{ramsortorder}{integer64}(x, i, has.na = TRUE, na.last=FALSE, decreasing = FALSE, stable = TRUE
-#! , optimize = c("time", "memory"), VERBOSE = FALSE, \dots)
+#! , optimize = c("time", "memory"), VERBOSE = FALSE, ...)
 #! \method{ramorder}{integer64}(x, i, has.na = TRUE, na.last=FALSE, decreasing = FALSE, stable = TRUE
-#! , optimize = c("time", "memory"), VERBOSE = FALSE, \dots)
+#! , optimize = c("time", "memory"), VERBOSE = FALSE, ...)
 #! }
 #! \arguments{
 #!   \item{x}{ a vector to be sorted by \code{\link{ramsort.integer64}} and \code{\link{ramsortorder.integer64}}, i.e. the output of  \code{\link{sort.integer64}} }
@@ -88,7 +88,7 @@
 #!   \item{VERBOSE}{
 #!   cat some info about chosen method
 #! }
-#!   \item{\dots}{ further arguments, passed from generics, ignored in methods }
+#!   \item{...}{ further arguments, passed from generics, ignored in methods }
 #! }
 #! \details{
 #!  see \code{\link[bit:Sorting]{ramsort}}
@@ -471,8 +471,8 @@ ramorder.integer64 <- function (x
 #! }
 #! \usage{
 #! \method{sort}{integer64}(x, decreasing = FALSE, has.na = TRUE, na.last = TRUE, stable = TRUE
-#! , optimize = c("time", "memory"), VERBOSE = FALSE, \dots)
-#! \method{order}{integer64}(\dots, na.last = TRUE, decreasing = FALSE, has.na = TRUE, stable = TRUE
+#! , optimize = c("time", "memory"), VERBOSE = FALSE, ...)
+#! \method{order}{integer64}(..., na.last = TRUE, decreasing = FALSE, has.na = TRUE, stable = TRUE
 #! , optimize = c("time", "memory"), VERBOSE = FALSE)
 #! }
 #! \arguments{
@@ -498,7 +498,7 @@ ramorder.integer64 <- function (x
 #!   \item{VERBOSE}{
 #!   cat some info about chosen method
 #! }
-#!   \item{\dots}{ further arguments, passed from generics, ignored in methods }
+#!   \item{...}{ further arguments, passed from generics, ignored in methods }
 #! }
 #! \details{
 #!  see \code{\link{sort}} and \code{\link{order}}
diff --git a/R/sortuse64.R b/R/sortuse64.R
index 16ad2bb..e1ffc81 100644
--- a/R/sortuse64.R
+++ b/R/sortuse64.R
@@ -65,52 +65,52 @@
 #!   Since sorting is more informative than hashingwe can do some more interesting things.
 #! }
 #! \usage{
-#! sortnut(sorted, \dots)
-#! ordernut(table, order, \dots)
-#! sortfin(sorted, x, \dots)
-#! orderfin(table, order, x, \dots)
-#! orderpos(table, order, x, \dots)
-#! sortorderpos(sorted, order, x, \dots)
-#! orderdup(table, order, \dots)
-#! sortorderdup(sorted, order, \dots)
-#! sortuni(sorted, nunique, \dots)
-#! orderuni(table, order, nunique, \dots)
-#! sortorderuni(table, sorted, order, nunique, \dots)
-#! orderupo(table, order, nunique, \dots)
-#! sortorderupo(sorted, order, nunique, keep.order = FALSE, \dots)
-#! ordertie(table, order, nties, \dots)
-#! sortordertie(sorted, order, nties, \dots)
-#! sorttab(sorted, nunique, \dots)
-#! ordertab(table, order, nunique, \dots)
-#! sortordertab(sorted, order, \dots)
-#! orderkey(table, order, na.skip.num = 0L, \dots)
-#! sortorderkey(sorted, order, na.skip.num = 0L, \dots)
-#! orderrnk(table, order, na.count, \dots)
-#! sortorderrnk(sorted, order, na.count, \dots)
-#! \method{sortnut}{integer64}(sorted, \dots)
-#! \method{ordernut}{integer64}(table, order, \dots)
-#! \method{sortfin}{integer64}(sorted, x, method=NULL, \dots)
-#! \method{orderfin}{integer64}(table, order, x, method=NULL, \dots)
-#! \method{orderpos}{integer64}(table, order, x, nomatch=NA, method=NULL, \dots)
-#! \method{sortorderpos}{integer64}(sorted, order, x, nomatch=NA, method=NULL, \dots)
-#! \method{orderdup}{integer64}(table, order, method=NULL, \dots)
-#! \method{sortorderdup}{integer64}(sorted, order, method=NULL, \dots)
-#! \method{sortuni}{integer64}(sorted, nunique, \dots)
-#! \method{orderuni}{integer64}(table, order, nunique, keep.order=FALSE, \dots)
-#! \method{sortorderuni}{integer64}(table, sorted, order, nunique, \dots)
-#! \method{orderupo}{integer64}(table, order, nunique, keep.order=FALSE, \dots)
-#! \method{sortorderupo}{integer64}(sorted, order, nunique, keep.order = FALSE, \dots)
-#! \method{ordertie}{integer64}(table, order, nties, \dots)
-#! \method{sortordertie}{integer64}(sorted, order, nties, \dots)
-#! \method{sorttab}{integer64}(sorted, nunique, \dots)
-#! \method{ordertab}{integer64}(table, order, nunique, denormalize=FALSE, keep.order=FALSE, \dots)
-#! \method{sortordertab}{integer64}(sorted, order, denormalize=FALSE, \dots)
-#! \method{orderkey}{integer64}(table, order, na.skip.num = 0L, \dots)
-#! \method{sortorderkey}{integer64}(sorted, order, na.skip.num = 0L, \dots)
-#! \method{orderrnk}{integer64}(table, order, na.count, \dots)
-#! \method{sortorderrnk}{integer64}(sorted, order, na.count, \dots)
-#! \method{sortqtl}{integer64}(sorted, na.count, probs, \dots)
-#! \method{orderqtl}{integer64}(table, order, na.count, probs, \dots)
+#! sortnut(sorted, ...)
+#! ordernut(table, order, ...)
+#! sortfin(sorted, x, ...)
+#! orderfin(table, order, x, ...)
+#! orderpos(table, order, x, ...)
+#! sortorderpos(sorted, order, x, ...)
+#! orderdup(table, order, ...)
+#! sortorderdup(sorted, order, ...)
+#! sortuni(sorted, nunique, ...)
+#! orderuni(table, order, nunique, ...)
+#! sortorderuni(table, sorted, order, nunique, ...)
+#! orderupo(table, order, nunique, ...)
+#! sortorderupo(sorted, order, nunique, keep.order = FALSE, ...)
+#! ordertie(table, order, nties, ...)
+#! sortordertie(sorted, order, nties, ...)
+#! sorttab(sorted, nunique, ...)
+#! ordertab(table, order, nunique, ...)
+#! sortordertab(sorted, order, ...)
+#! orderkey(table, order, na.skip.num = 0L, ...)
+#! sortorderkey(sorted, order, na.skip.num = 0L, ...)
+#! orderrnk(table, order, na.count, ...)
+#! sortorderrnk(sorted, order, na.count, ...)
+#! \method{sortnut}{integer64}(sorted, ...)
+#! \method{ordernut}{integer64}(table, order, ...)
+#! \method{sortfin}{integer64}(sorted, x, method=NULL, ...)
+#! \method{orderfin}{integer64}(table, order, x, method=NULL, ...)
+#! \method{orderpos}{integer64}(table, order, x, nomatch=NA, method=NULL, ...)
+#! \method{sortorderpos}{integer64}(sorted, order, x, nomatch=NA, method=NULL, ...)
+#! \method{orderdup}{integer64}(table, order, method=NULL, ...)
+#! \method{sortorderdup}{integer64}(sorted, order, method=NULL, ...)
+#! \method{sortuni}{integer64}(sorted, nunique, ...)
+#! \method{orderuni}{integer64}(table, order, nunique, keep.order=FALSE, ...)
+#! \method{sortorderuni}{integer64}(table, sorted, order, nunique, ...)
+#! \method{orderupo}{integer64}(table, order, nunique, keep.order=FALSE, ...)
+#! \method{sortorderupo}{integer64}(sorted, order, nunique, keep.order = FALSE, ...)
+#! \method{ordertie}{integer64}(table, order, nties, ...)
+#! \method{sortordertie}{integer64}(sorted, order, nties, ...)
+#! \method{sorttab}{integer64}(sorted, nunique, ...)
+#! \method{ordertab}{integer64}(table, order, nunique, denormalize=FALSE, keep.order=FALSE, ...)
+#! \method{sortordertab}{integer64}(sorted, order, denormalize=FALSE, ...)
+#! \method{orderkey}{integer64}(table, order, na.skip.num = 0L, ...)
+#! \method{sortorderkey}{integer64}(sorted, order, na.skip.num = 0L, ...)
+#! \method{orderrnk}{integer64}(table, order, na.count, ...)
+#! \method{sortorderrnk}{integer64}(sorted, order, na.count, ...)
+#! \method{sortqtl}{integer64}(sorted, na.count, probs, ...)
+#! \method{orderqtl}{integer64}(table, order, na.count, probs, ...)
 #! }
 #! \arguments{
 #!   \item{x}{ an \code{\link{integer64}} vector }
@@ -126,7 +126,7 @@
 #!   \item{na.skip.num}{ 0 or the number of \code{NA}s. With 0, \code{NA}s are coded with 1L, with the number of \code{NA}s, these are coded with \code{NA} }
 #!   \item{na.count}{ the number of \code{NA}s, needed for this low-level function algorithm }
 #!   \item{method}{ see details }
-#!   \item{\dots}{ further arguments, passed from generics, ignored in methods }
+#!   \item{...}{ further arguments, passed from generics, ignored in methods }
 #! }
 #! \details{
 #! \tabular{rrrrl}{
diff --git a/man/all.equal.integer64.Rd b/man/all.equal.integer64.Rd
index d387808..2401669 100644
--- a/man/all.equal.integer64.Rd
+++ b/man/all.equal.integer64.Rd
@@ -35,7 +35,7 @@
     \code{err}, the relative, absolute or scaled error, and
     \code{what}, a character string indicating the \emph{kind} of error;
     maybe used, e.g., to format relative and absolute errors differently.}
-  \item{\dots}{further arguments are ignored}
+  \item{...}{further arguments are ignored}
   \item{check.attributes}{logical indicating if the
     \code{\link{attributes}} of \code{target} and \code{current}
     (other than the names) should be compared.}
diff --git a/man/as.character.integer64.Rd b/man/as.character.integer64.Rd
index 20911e6..edb0a8e 100644
--- a/man/as.character.integer64.Rd
+++ b/man/as.character.integer64.Rd
@@ -17,19 +17,19 @@
   \code{\link{as.logical}}, \code{\link{as.integer}} do what you would expect.
 }
 \usage{
- as.bitstring(x, \dots)
- \method{as.bitstring}{integer64}(x, \dots)
- \method{print}{bitstring}(x, \dots)
- \method{as.character}{integer64}(x, \dots)
- \method{as.double}{integer64}(x, keep.names = FALSE, \dots)
- \method{as.integer}{integer64}(x, \dots)
- \method{as.logical}{integer64}(x, \dots)
- \method{as.list}{integer64}(x, \dots)
+ as.bitstring(x, ...)
+ \method{as.bitstring}{integer64}(x, ...)
+ \method{print}{bitstring}(x, ...)
+ \method{as.character}{integer64}(x, ...)
+ \method{as.double}{integer64}(x, keep.names = FALSE, ...)
+ \method{as.integer}{integer64}(x, ...)
+ \method{as.logical}{integer64}(x, ...)
+ \method{as.list}{integer64}(x, ...)
 }
 \arguments{
   \item{x}{ an integer64 vector }
   \item{keep.names}{ FALSE, set to TRUE to keep a names vector }
-  \item{\dots}{ further arguments to the \code{\link{NextMethod}} }
+  \item{...}{ further arguments to the \code{\link{NextMethod}} }
 }
 \value{
   \code{as.bitstring} returns a string of class 'bitstring'. \cr
diff --git a/man/as.data.frame.integer64.Rd b/man/as.data.frame.integer64.Rd
index 74ccc97..c152574 100644
--- a/man/as.data.frame.integer64.Rd
+++ b/man/as.data.frame.integer64.Rd
@@ -7,11 +7,11 @@
   Coercing integer64 vector to data.frame.
 }
 \usage{
-  \method{as.data.frame}{integer64}(x, \dots)
+  \method{as.data.frame}{integer64}(x, ...)
 }
 \arguments{
   \item{x}{ an integer64 vector }
-  \item{\dots}{ passed to NextMethod \code{\link{as.data.frame}} after removing the 'integer64' class attribute }
+  \item{...}{ passed to NextMethod \code{\link{as.data.frame}} after removing the 'integer64' class attribute }
 }
 \value{
   a one-column data.frame containing an integer64 vector
diff --git a/man/as.integer64.character.Rd b/man/as.integer64.character.Rd
index f82e0dd..e1faf0d 100644
--- a/man/as.integer64.character.Rd
+++ b/man/as.integer64.character.Rd
@@ -17,20 +17,20 @@
 }
 \usage{
  NA_integer64_
- as.integer64(x, \dots)
- \method{as.integer64}{integer64}(x, \dots)
- \method{as.integer64}{NULL}(x, \dots)
- \method{as.integer64}{character}(x, \dots)
- \method{as.integer64}{bitstring}(x, \dots)
- \method{as.integer64}{double}(x, keep.names = FALSE, \dots)
- \method{as.integer64}{integer}(x, \dots)
- \method{as.integer64}{logical}(x, \dots)
- \method{as.integer64}{factor}(x, \dots)
+ as.integer64(x, ...)
+ \method{as.integer64}{integer64}(x, ...)
+ \method{as.integer64}{NULL}(x, ...)
+ \method{as.integer64}{character}(x, ...)
+ \method{as.integer64}{bitstring}(x, ...)
+ \method{as.integer64}{double}(x, keep.names = FALSE, ...)
+ \method{as.integer64}{integer}(x, ...)
+ \method{as.integer64}{logical}(x, ...)
+ \method{as.integer64}{factor}(x, ...)
 }
 \arguments{
   \item{x}{ an atomic vector }
   \item{keep.names}{ FALSE, set to TRUE to keep a names vector }
-  \item{\dots}{ further arguments to the \code{\link{NextMethod}} }
+  \item{...}{ further arguments to the \code{\link{NextMethod}} }
 }
 \details{
   \code{as.integer64.character} is realized using C function \code{strtoll} which does not support scientific notation.
diff --git a/man/bit64-package.Rd b/man/bit64-package.Rd
index d661786..59d83b9 100644
--- a/man/bit64-package.Rd
+++ b/man/bit64-package.Rd
@@ -54,8 +54,8 @@ is not worth it with 32x at duplicated RAM consumption).
  integer64(length)
  \method{is}{integer64}(x)
  \method{length}{integer64}(x) <- value
- \method{print}{integer64}(x, quote=FALSE, \dots)
- \method{str}{integer64}(object, vec.len  = strO$vec.len, give.head = TRUE, give.length = give.head, \dots)
+ \method{print}{integer64}(x, quote=FALSE, ...)
+ \method{str}{integer64}(object, vec.len  = strO$vec.len, give.head = TRUE, give.length = give.head, ...)
 }
 \arguments{
   \item{length}{ length of vector using \code{\link{integer}} }
@@ -66,7 +66,7 @@ is not worth it with 32x at duplicated RAM consumption).
   \item{vec.len}{ see \code{\link[utils]{str}} }
   \item{give.head}{ see \code{\link[utils]{str}} }
   \item{give.length}{ see \code{\link[utils]{str}} }
-  \item{\dots}{ further arguments to the \code{\link{NextMethod}} }
+  \item{...}{ further arguments to the \code{\link{NextMethod}} }
 }
 \details{
 \tabular{ll}{
diff --git a/man/bit64S3.Rd b/man/bit64S3.Rd
index 3b3f9ce..757dc45 100644
--- a/man/bit64S3.Rd
+++ b/man/bit64S3.Rd
@@ -49,7 +49,7 @@
 }
   \item{from}{ scalar denoting first element of sequence }
   \item{to}{ scalar denoting last element of sequence }
-  \item{\dots}{ ignored }
+  \item{...}{ ignored }
 }
 \details{
    The following functions are turned into S3 gernerics in order to dispatch methods for \code{\link{integer64}}:
diff --git a/man/c.integer64.Rd b/man/c.integer64.Rd
index 90f6828..cb5a61b 100644
--- a/man/c.integer64.Rd
+++ b/man/c.integer64.Rd
@@ -9,12 +9,12 @@
   The ususal functions 'c', 'cbind' and 'rbind'
 }
 \usage{
-\method{c}{integer64}(\dots, recursive = FALSE)
-\method{cbind}{integer64}(\dots)
-\method{rbind}{integer64}(\dots)
+\method{c}{integer64}(..., recursive = FALSE)
+\method{cbind}{integer64}(...)
+\method{rbind}{integer64}(...)
 }
 \arguments{
-  \item{\dots}{ two or more arguments coerced to 'integer64' and passed to \code{\link{NextMethod}} }
+  \item{...}{ two or more arguments coerced to 'integer64' and passed to \code{\link{NextMethod}} }
   \item{recursive}{ logical. If \code{recursive = TRUE}, the function recursively descends through lists (and pairlists) combining all their elements into a vector. }
 }
 \value{
diff --git a/man/cache.Rd b/man/cache.Rd
index 97a8638..60ac216 100644
--- a/man/cache.Rd
+++ b/man/cache.Rd
@@ -19,7 +19,7 @@ cache(x)
 setcache(x, which, value)
 getcache(x, which)
 remcache(x)
-\method{print}{cache}(x, all.names = FALSE, pattern, \dots)
+\method{print}{cache}(x, all.names = FALSE, pattern, ...)
 }
 \arguments{
   \item{x}{
@@ -37,7 +37,7 @@ remcache(x)
   \item{pattern}{
   passed to \code{\link{ls}} when listing the cache content
 }
-  \item{\dots}{
+  \item{...}{
     ignored
 }
 }
diff --git a/man/cumsum.integer64.Rd b/man/cumsum.integer64.Rd
index 9b82245..4c08f90 100644
--- a/man/cumsum.integer64.Rd
+++ b/man/cumsum.integer64.Rd
@@ -15,13 +15,13 @@
 \method{cummax}{integer64}(x)
 \method{cumsum}{integer64}(x)
 \method{cumprod}{integer64}(x)
-\method{diff}{integer64}(x, lag = 1L, differences = 1L, \dots)
+\method{diff}{integer64}(x, lag = 1L, differences = 1L, ...)
 }
 \arguments{
   \item{x}{ an atomic vector of class 'integer64'}
   \item{lag}{ see \code{\link{diff}} }
   \item{differences}{ see \code{\link{diff}} }
-  \item{\dots}{ ignored }
+  \item{...}{ ignored }
 }
 \value{
   \code{\link{cummin}}, \code{\link{cummax}} , \code{\link{cumsum}} and \code{\link{cumprod}}
diff --git a/man/duplicated.integer64.Rd b/man/duplicated.integer64.Rd
index b8dd71b..c0f3ce3 100644
--- a/man/duplicated.integer64.Rd
+++ b/man/duplicated.integer64.Rd
@@ -7,7 +7,7 @@
   indicating which elements (rows) are duplicates.
 }
 \usage{
-\method{duplicated}{integer64}(x, incomparables = FALSE, nunique = NULL, method = NULL, \dots)
+\method{duplicated}{integer64}(x, incomparables = FALSE, nunique = NULL, method = NULL, ...)
 }
 \arguments{
   \item{x}{a vector or a data frame or an array or \code{NULL}.}
@@ -18,7 +18,7 @@
   \item{method}{
     NULL for automatic method selection or a suitable low-level method, see details
 }
-  \item{\dots}{ignored}
+  \item{...}{ignored}
 }
 \details{
   This function automatically chooses from several low-level functions considering the size of \code{x} and the availability of a cache.
diff --git a/man/extract.replace.integer64.Rd b/man/extract.replace.integer64.Rd
index df59e5d..caf85b3 100644
--- a/man/extract.replace.integer64.Rd
+++ b/man/extract.replace.integer64.Rd
@@ -10,16 +10,16 @@
   Methods to extract and replace parts of an integer64 vector.
 }
 \usage{
- \method{[}{integer64}(x, i, \dots)
- \method{[}{integer64}(x, \dots) <- value
- \method{[[}{integer64}(x, \dots)
- \method{[[}{integer64}(x, \dots) <- value
+ \method{[}{integer64}(x, i, ...)
+ \method{[}{integer64}(x, ...) <- value
+ \method{[[}{integer64}(x, ...)
+ \method{[[}{integer64}(x, ...) <- value
 }
 \arguments{
   \item{x}{ an atomic vector }
   \item{i}{ indices specifying elements to extract }
   \item{value}{ an atomic vector with values to be assigned }
-  \item{\dots}{ further arguments to the \code{\link{NextMethod}} }
+  \item{...}{ further arguments to the \code{\link{NextMethod}} }
 }
 \note{
   You should not subscript non-existing elements and not use \code{NA}s as subscripts.
diff --git a/man/format.integer64.Rd b/man/format.integer64.Rd
index 1e85c2a..8ac0cba 100644
--- a/man/format.integer64.Rd
+++ b/man/format.integer64.Rd
@@ -24,7 +24,7 @@
   Unary operators and functions for integer64 vectors.
 }
 \usage{
-\method{format}{integer64}(x, justify="right", \dots)
+\method{format}{integer64}(x, justify="right", ...)
 \method{is.na}{integer64}(x)
 \method{is.nan}{integer64}(x)
 \method{is.finite}{integer64}(x)
@@ -38,7 +38,7 @@
 \method{log10}{integer64}(x)
 \method{floor}{integer64}(x)
 \method{ceiling}{integer64}(x)
-\method{trunc}{integer64}(x, \dots)
+\method{trunc}{integer64}(x, ...)
 \method{round}{integer64}(x, digits=0)
 \method{signif}{integer64}(x, digits=6)
 \method{scale}{integer64}(x, center = TRUE, scale = TRUE)
@@ -51,7 +51,7 @@
   \item{justify}{ should it be right-justified (the default), left-justified, centred or left alone. }
   \item{center}{ see \code{\link{scale}} }
   \item{scale}{  see \code{\link{scale}} }
-  \item{\dots}{ further arguments to the \code{\link{NextMethod}} }
+  \item{...}{ further arguments to the \code{\link{NextMethod}} }
 }
 \value{
   \code{\link{format}} returns a character vector \cr
diff --git a/man/hashcache.Rd b/man/hashcache.Rd
index 2d5a3de..21d5501 100644
--- a/man/hashcache.Rd
+++ b/man/hashcache.Rd
@@ -10,7 +10,7 @@
     Functions to create cache that accelerates many operations
 }
 \usage{
-hashcache(x, nunique=NULL, \dots)
+hashcache(x, nunique=NULL, ...)
 sortcache(x, has.na = NULL)
 sortordercache(x, has.na = NULL, stable = NULL)
 ordercache(x, has.na = NULL, stable = NULL, optimize = "time")
@@ -31,7 +31,7 @@ boolean scalar defining whether stable sorting is needed. Allowing non-stable ma
 by default ramsort optimizes for 'time' which requires more RAM,
 set to 'memory' to minimize RAM requirements and sacrifice speed
 }
-  \item{\dots}{
+  \item{...}{
         passed to \code{\link{hashmap}}
 }
 }
diff --git a/man/hashmap.Rd b/man/hashmap.Rd
index f4ac68b..ecc8a02 100644
--- a/man/hashmap.Rd
+++ b/man/hashmap.Rd
@@ -35,32 +35,32 @@ store and use hash functionality directly. One advantage is that you can
 re-use hashmaps, which avoid re-building hashmaps again and again.
 }
 \usage{
-hashfun(x, \dots)
-\method{hashfun}{integer64}(x, minfac=1.41, hashbits=NULL, \dots)
-hashmap(x, \dots)
-\method{hashmap}{integer64}(x, nunique=NULL, minfac=1.41, hashbits=NULL, cache=NULL, \dots)
-hashpos(cache, \dots)
-\method{hashpos}{cache_integer64}(cache, x, nomatch = NA_integer_, \dots)
-hashrev(cache, \dots)
-\method{hashrev}{cache_integer64}(cache, x, nomatch = NA_integer_, \dots)
-hashfin(cache, \dots)
-\method{hashfin}{cache_integer64}(cache, x, \dots)
-hashrin(cache, \dots)
-\method{hashrin}{cache_integer64}(cache, x, \dots)
-hashdup(cache, \dots)
-\method{hashdup}{cache_integer64}(cache, \dots)
-hashuni(cache, \dots)
-\method{hashuni}{cache_integer64}(cache, keep.order=FALSE, \dots)
-hashmapuni(x, \dots)
-\method{hashmapuni}{integer64}(x, nunique=NULL, minfac=1.5, hashbits=NULL, \dots)
-hashupo(cache, \dots)
-\method{hashupo}{cache_integer64}(cache, keep.order=FALSE, \dots)
-hashmapupo(x, \dots)
-\method{hashmapupo}{integer64}(x, nunique=NULL, minfac=1.5, hashbits=NULL, \dots)
-hashtab(cache, \dots)
-\method{hashtab}{cache_integer64}(cache, \dots)
-hashmaptab(x, \dots)
-\method{hashmaptab}{integer64}(x, nunique=NULL, minfac=1.5, hashbits=NULL, \dots)
+hashfun(x, ...)
+\method{hashfun}{integer64}(x, minfac=1.41, hashbits=NULL, ...)
+hashmap(x, ...)
+\method{hashmap}{integer64}(x, nunique=NULL, minfac=1.41, hashbits=NULL, cache=NULL, ...)
+hashpos(cache, ...)
+\method{hashpos}{cache_integer64}(cache, x, nomatch = NA_integer_, ...)
+hashrev(cache, ...)
+\method{hashrev}{cache_integer64}(cache, x, nomatch = NA_integer_, ...)
+hashfin(cache, ...)
+\method{hashfin}{cache_integer64}(cache, x, ...)
+hashrin(cache, ...)
+\method{hashrin}{cache_integer64}(cache, x, ...)
+hashdup(cache, ...)
+\method{hashdup}{cache_integer64}(cache, ...)
+hashuni(cache, ...)
+\method{hashuni}{cache_integer64}(cache, keep.order=FALSE, ...)
+hashmapuni(x, ...)
+\method{hashmapuni}{integer64}(x, nunique=NULL, minfac=1.5, hashbits=NULL, ...)
+hashupo(cache, ...)
+\method{hashupo}{cache_integer64}(cache, keep.order=FALSE, ...)
+hashmapupo(x, ...)
+\method{hashmapupo}{integer64}(x, nunique=NULL, minfac=1.5, hashbits=NULL, ...)
+hashtab(cache, ...)
+\method{hashtab}{cache_integer64}(cache, ...)
+hashmaptab(x, ...)
+\method{hashmaptab}{integer64}(x, nunique=NULL, minfac=1.5, hashbits=NULL, ...)
 }
 \arguments{
   \item{x}{ an integer64 vector }
@@ -71,7 +71,7 @@ hashmaptab(x, \dots)
   \item{nunique}{ giving \emph{correct} number of unique elements can help reducing the size of the hashmap }
   \item{nomatch}{ the value to be returned if an element is not found in the hashmap }
   \item{keep.order}{ determines order of results and speed: \code{FALSE} (the default) is faster and returns in the (pseudo)random order of the hash function, \code{TRUE} returns in the order of first appearance in the original data, but this requires extra work }
-  \item{\dots}{ further arguments, passed from generics, ignored in methods }
+  \item{...}{ further arguments, passed from generics, ignored in methods }
 }
 \details{
 \tabular{rrl}{
diff --git a/man/is.sorted.integer64.Rd b/man/is.sorted.integer64.Rd
index fbd2c9a..ff82fc6 100644
--- a/man/is.sorted.integer64.Rd
+++ b/man/is.sorted.integer64.Rd
@@ -11,17 +11,17 @@
     These methods are packaged here for methods in packages \code{bit64} and \code{ff}.
 }
 \usage{
-    \method{is.sorted}{integer64}(x, \dots)
-    \method{na.count}{integer64}(x, \dots)
-    \method{nvalid}{integer64}(x, \dots)
-    \method{nunique}{integer64}(x, \dots)
-    \method{nties}{integer64}(x, \dots)
+    \method{is.sorted}{integer64}(x, ...)
+    \method{na.count}{integer64}(x, ...)
+    \method{nvalid}{integer64}(x, ...)
+    \method{nunique}{integer64}(x, ...)
+    \method{nties}{integer64}(x, ...)
 }
 \arguments{
   \item{x}{
     some object
     }
-  \item{\dots}{
+  \item{...}{
     ignored
     }
 }
diff --git a/man/keypos.Rd b/man/keypos.Rd
index fb6e74e..256f44c 100644
--- a/man/keypos.Rd
+++ b/man/keypos.Rd
@@ -6,15 +6,15 @@
   \code{keypos} returns the positions of the (fact table) elements that participate in their sorted unique subset (dimension table)
 }
 \usage{
-keypos(x, \dots)
-\method{keypos}{integer64}(x, method = NULL, \dots)
+keypos(x, ...)
+\method{keypos}{integer64}(x, method = NULL, ...)
 }
 \arguments{
   \item{x}{a vector or a data frame or an array or \code{NULL}.}
   \item{method}{
     NULL for automatic method selection or a suitable low-level method, see details
 }
-  \item{\dots}{ignored}
+  \item{...}{ignored}
 }
 \details{
   NAs are sorted first in the dimension table, see \code{\link{ramorder.integer64}}.
diff --git a/man/match.integer64.Rd b/man/match.integer64.Rd
index aa880a6..964f1ab 100644
--- a/man/match.integer64.Rd
+++ b/man/match.integer64.Rd
@@ -30,7 +30,7 @@
   \item{method}{
     NULL for automatic method selection or a suitable low-level method, see details
 }
-  \item{\dots}{
+  \item{...}{
 ignored
 }
 }
diff --git a/man/prank.Rd b/man/prank.Rd
index c4f9a71..4a7bd5d 100644
--- a/man/prank.Rd
+++ b/man/prank.Rd
@@ -7,15 +7,15 @@
     \code{\link{qtile.integer64}} is the inverse function of 'prank.integer64' and projects [0..1] to [min..max].
 }
 \usage{
-    prank(x, \dots)
-    \method{prank}{integer64}(x, method = NULL, \dots)
+    prank(x, ...)
+    \method{prank}{integer64}(x, method = NULL, ...)
 }
 \arguments{
   \item{x}{a integer64 vector}
   \item{method}{
     NULL for automatic method selection or a suitable low-level method, see details
 }
-  \item{\dots}{ignored}
+  \item{...}{ignored}
 }
 \details{
     Function \code{prank.integer64} is based on \code{\link{rank.integer64}}.
diff --git a/man/qtile.Rd b/man/qtile.Rd
index 36dd8f1..9f36c89 100644
--- a/man/qtile.Rd
+++ b/man/qtile.Rd
@@ -11,12 +11,12 @@
     \code{qtile.ineger64} is the inverse function of 'prank.integer64' and projects [0..1] to [min..max].
 }
 \usage{
-    qtile(x, probs=seq(0, 1, 0.25), \dots)
-    \method{qtile}{integer64}(x, probs = seq(0, 1, 0.25), names = TRUE, method = NULL, \dots)
-    \method{quantile}{integer64}(x, probs = seq(0, 1, 0.25), na.rm = FALSE, names = TRUE, type=0L, \dots)
-    \method{median}{integer64}(x, na.rm = FALSE, \dots)
- \method{mean}{integer64}(x, na.rm = FALSE, \dots)
-    \method{summary}{integer64}(object, \dots)
+    qtile(x, probs=seq(0, 1, 0.25), ...)
+    \method{qtile}{integer64}(x, probs = seq(0, 1, 0.25), names = TRUE, method = NULL, ...)
+    \method{quantile}{integer64}(x, probs = seq(0, 1, 0.25), na.rm = FALSE, names = TRUE, type=0L, ...)
+    \method{median}{integer64}(x, na.rm = FALSE, ...)
+ \method{mean}{integer64}(x, na.rm = FALSE, ...)
+    \method{summary}{integer64}(object, ...)
  ## mean(x, na.rm = FALSE, ...)
  ## or
  ## mean(x, na.rm = FALSE)
@@ -39,7 +39,7 @@
   \item{na.rm}{
     logical; if \code{TRUE}, any \code{NA} and \code{NaN}'s are removed from \code{x} before the quantiles are computed.
 }
-  \item{\dots}{ignored}
+  \item{...}{ignored}
 }
 \details{
  Functions \code{quantile.integer64} with \code{type=0} and \code{median.integer64} are convenience wrappers to \code{qtile}.
diff --git a/man/ramsort.integer64.Rd b/man/ramsort.integer64.Rd
index 54ed9c0..db6d139 100644
--- a/man/ramsort.integer64.Rd
+++ b/man/ramsort.integer64.Rd
@@ -26,27 +26,27 @@
  The \code{sort}-methods change \code{x}, the \code{order}-methods change \code{i}, and the \code{sortoder}-methods change both \code{x} and \code{i}
 }
 \usage{
-\method{shellsort}{integer64}(x, has.na=TRUE, na.last=FALSE, decreasing=FALSE, \dots)
-\method{shellsortorder}{integer64}(x, i, has.na=TRUE, na.last=FALSE, decreasing=FALSE, \dots)
-\method{shellorder}{integer64}(x, i, has.na=TRUE, na.last=FALSE, decreasing=FALSE, \dots)
-\method{mergesort}{integer64}(x, has.na=TRUE, na.last=FALSE, decreasing=FALSE, \dots)
-\method{mergeorder}{integer64}(x, i, has.na=TRUE, na.last=FALSE, decreasing=FALSE, \dots)
-\method{mergesortorder}{integer64}(x, i, has.na=TRUE, na.last=FALSE, decreasing=FALSE, \dots)
+\method{shellsort}{integer64}(x, has.na=TRUE, na.last=FALSE, decreasing=FALSE, ...)
+\method{shellsortorder}{integer64}(x, i, has.na=TRUE, na.last=FALSE, decreasing=FALSE, ...)
+\method{shellorder}{integer64}(x, i, has.na=TRUE, na.last=FALSE, decreasing=FALSE, ...)
+\method{mergesort}{integer64}(x, has.na=TRUE, na.last=FALSE, decreasing=FALSE, ...)
+\method{mergeorder}{integer64}(x, i, has.na=TRUE, na.last=FALSE, decreasing=FALSE, ...)
+\method{mergesortorder}{integer64}(x, i, has.na=TRUE, na.last=FALSE, decreasing=FALSE, ...)
 \method{quicksort}{integer64}(x, has.na=TRUE, na.last=FALSE, decreasing=FALSE
-, restlevel=floor(1.5*log2(length(x))), \dots)
+, restlevel=floor(1.5*log2(length(x))), ...)
 \method{quicksortorder}{integer64}(x, i, has.na=TRUE, na.last=FALSE, decreasing=FALSE
-, restlevel=floor(1.5*log2(length(x))), \dots)
+, restlevel=floor(1.5*log2(length(x))), ...)
 \method{quickorder}{integer64}(x, i, has.na=TRUE, na.last=FALSE, decreasing=FALSE
-, restlevel=floor(1.5*log2(length(x))), \dots)
-\method{radixsort}{integer64}(x, has.na=TRUE, na.last=FALSE, decreasing=FALSE, radixbits=8L, \dots)
-\method{radixsortorder}{integer64}(x, i, has.na=TRUE, na.last=FALSE, decreasing=FALSE, radixbits=8L, \dots)
-\method{radixorder}{integer64}(x, i, has.na=TRUE, na.last=FALSE, decreasing=FALSE, radixbits=8L, \dots)
+, restlevel=floor(1.5*log2(length(x))), ...)
+\method{radixsort}{integer64}(x, has.na=TRUE, na.last=FALSE, decreasing=FALSE, radixbits=8L, ...)
+\method{radixsortorder}{integer64}(x, i, has.na=TRUE, na.last=FALSE, decreasing=FALSE, radixbits=8L, ...)
+\method{radixorder}{integer64}(x, i, has.na=TRUE, na.last=FALSE, decreasing=FALSE, radixbits=8L, ...)
 \method{ramsort}{integer64}(x, has.na = TRUE, na.last=FALSE, decreasing = FALSE, stable = TRUE
-, optimize = c("time", "memory"), VERBOSE = FALSE, \dots)
+, optimize = c("time", "memory"), VERBOSE = FALSE, ...)
 \method{ramsortorder}{integer64}(x, i, has.na = TRUE, na.last=FALSE, decreasing = FALSE, stable = TRUE
-, optimize = c("time", "memory"), VERBOSE = FALSE, \dots)
+, optimize = c("time", "memory"), VERBOSE = FALSE, ...)
 \method{ramorder}{integer64}(x, i, has.na = TRUE, na.last=FALSE, decreasing = FALSE, stable = TRUE
-, optimize = c("time", "memory"), VERBOSE = FALSE, \dots)
+, optimize = c("time", "memory"), VERBOSE = FALSE, ...)
 }
 \arguments{
   \item{x}{ a vector to be sorted by \code{\link{ramsort.integer64}} and \code{\link{ramsortorder.integer64}}, i.e. the output of  \code{\link{sort.integer64}} }
@@ -78,7 +78,7 @@ number of remaining recursionlevels before \code{quicksort} switches from recurs
   \item{VERBOSE}{
   cat some info about chosen method
 }
-  \item{\dots}{ further arguments, passed from generics, ignored in methods }
+  \item{...}{ further arguments, passed from generics, ignored in methods }
 }
 \details{
  see \code{\link[bit:Sorting]{ramsort}}
diff --git a/man/rank.integer64.Rd b/man/rank.integer64.Rd
index e95f52e..dd9a47f 100644
--- a/man/rank.integer64.Rd
+++ b/man/rank.integer64.Rd
@@ -6,14 +6,14 @@
   values) are averaged and missing values propagated.
 }
 \usage{
-    \method{rank}{integer64}(x, method = NULL, \dots)
+    \method{rank}{integer64}(x, method = NULL, ...)
 }
 \arguments{
   \item{x}{a integer64 vector}
   \item{method}{
     NULL for automatic method selection or a suitable low-level method, see details
 }
-  \item{\dots}{ignored}
+  \item{...}{ignored}
 }
 \details{
   This function automatically chooses from several low-level functions considering the size of \code{x} and the availability of a cache.
diff --git a/man/rep.integer64.Rd b/man/rep.integer64.Rd
index 3200302..45a0aa6 100644
--- a/man/rep.integer64.Rd
+++ b/man/rep.integer64.Rd
@@ -7,11 +7,11 @@
   Replicate elements of integer64 vectors
 }
 \usage{
-\method{rep}{integer64}(x, \dots)
+\method{rep}{integer64}(x, ...)
 }
 \arguments{
   \item{x}{ a vector of 'integer64' to be replicated }
-  \item{\dots}{ further arguments passed to \code{\link{NextMethod}} }
+  \item{...}{ further arguments passed to \code{\link{NextMethod}} }
 }
 \value{
   \code{\link{rep}} returns a integer64 vector
diff --git a/man/seq.integer64.Rd b/man/seq.integer64.Rd
index ad6c1ef..32605ff 100644
--- a/man/seq.integer64.Rd
+++ b/man/seq.integer64.Rd
@@ -7,7 +7,7 @@
   Generating sequence of integer64 values
 }
 \usage{
-\method{seq}{integer64}(from = NULL, to = NULL, by = NULL, length.out = NULL, along.with = NULL, \dots)
+\method{seq}{integer64}(from = NULL, to = NULL, by = NULL, length.out = NULL, along.with = NULL, ...)
 }
 \arguments{
   \item{from}{ integer64 scalar (in order to dispatch the integer64 method of \code{\link{seq}} }
@@ -15,7 +15,7 @@
   \item{by}{ scalar }
   \item{length.out}{ scalar }
   \item{along.with}{ scalar }
-  \item{\dots}{ ignored }
+  \item{...}{ ignored }
 }
 \details{
   \code{seq.integer64} does coerce its arguments 'from', 'to' and 'by' to \code{integer64}.
diff --git a/man/sort.integer64.Rd b/man/sort.integer64.Rd
index 849ef07..4348eac 100644
--- a/man/sort.integer64.Rd
+++ b/man/sort.integer64.Rd
@@ -10,8 +10,8 @@
 }
 \usage{
 \method{sort}{integer64}(x, decreasing = FALSE, has.na = TRUE, na.last = TRUE, stable = TRUE
-, optimize = c("time", "memory"), VERBOSE = FALSE, \dots)
-\method{order}{integer64}(\dots, na.last = TRUE, decreasing = FALSE, has.na = TRUE, stable = TRUE
+, optimize = c("time", "memory"), VERBOSE = FALSE, ...)
+\method{order}{integer64}(..., na.last = TRUE, decreasing = FALSE, has.na = TRUE, stable = TRUE
 , optimize = c("time", "memory"), VERBOSE = FALSE)
 }
 \arguments{
@@ -37,7 +37,7 @@ set to 'memory' to minimize RAM requirements and sacrifice speed
   \item{VERBOSE}{
   cat some info about chosen method
 }
-  \item{\dots}{ further arguments, passed from generics, ignored in methods }
+  \item{...}{ further arguments, passed from generics, ignored in methods }
 }
 \details{
  see \code{\link{sort}} and \code{\link{order}}
diff --git a/man/sortnut.Rd b/man/sortnut.Rd
index 41b9b0e..144a01f 100644
--- a/man/sortnut.Rd
+++ b/man/sortnut.Rd
@@ -55,52 +55,52 @@
   Since sorting is more informative than hashingwe can do some more interesting things.
 }
 \usage{
-sortnut(sorted, \dots)
-ordernut(table, order, \dots)
-sortfin(sorted, x, \dots)
-orderfin(table, order, x, \dots)
-orderpos(table, order, x, \dots)
-sortorderpos(sorted, order, x, \dots)
-orderdup(table, order, \dots)
-sortorderdup(sorted, order, \dots)
-sortuni(sorted, nunique, \dots)
-orderuni(table, order, nunique, \dots)
-sortorderuni(table, sorted, order, nunique, \dots)
-orderupo(table, order, nunique, \dots)
-sortorderupo(sorted, order, nunique, keep.order = FALSE, \dots)
-ordertie(table, order, nties, \dots)
-sortordertie(sorted, order, nties, \dots)
-sorttab(sorted, nunique, \dots)
-ordertab(table, order, nunique, \dots)
-sortordertab(sorted, order, \dots)
-orderkey(table, order, na.skip.num = 0L, \dots)
-sortorderkey(sorted, order, na.skip.num = 0L, \dots)
-orderrnk(table, order, na.count, \dots)
-sortorderrnk(sorted, order, na.count, \dots)
-\method{sortnut}{integer64}(sorted, \dots)
-\method{ordernut}{integer64}(table, order, \dots)
-\method{sortfin}{integer64}(sorted, x, method=NULL, \dots)
-\method{orderfin}{integer64}(table, order, x, method=NULL, \dots)
-\method{orderpos}{integer64}(table, order, x, nomatch=NA, method=NULL, \dots)
-\method{sortorderpos}{integer64}(sorted, order, x, nomatch=NA, method=NULL, \dots)
-\method{orderdup}{integer64}(table, order, method=NULL, \dots)
-\method{sortorderdup}{integer64}(sorted, order, method=NULL, \dots)
-\method{sortuni}{integer64}(sorted, nunique, \dots)
-\method{orderuni}{integer64}(table, order, nunique, keep.order=FALSE, \dots)
-\method{sortorderuni}{integer64}(table, sorted, order, nunique, \dots)
-\method{orderupo}{integer64}(table, order, nunique, keep.order=FALSE, \dots)
-\method{sortorderupo}{integer64}(sorted, order, nunique, keep.order = FALSE, \dots)
-\method{ordertie}{integer64}(table, order, nties, \dots)
-\method{sortordertie}{integer64}(sorted, order, nties, \dots)
-\method{sorttab}{integer64}(sorted, nunique, \dots)
-\method{ordertab}{integer64}(table, order, nunique, denormalize=FALSE, keep.order=FALSE, \dots)
-\method{sortordertab}{integer64}(sorted, order, denormalize=FALSE, \dots)
-\method{orderkey}{integer64}(table, order, na.skip.num = 0L, \dots)
-\method{sortorderkey}{integer64}(sorted, order, na.skip.num = 0L, \dots)
-\method{orderrnk}{integer64}(table, order, na.count, \dots)
-\method{sortorderrnk}{integer64}(sorted, order, na.count, \dots)
-\method{sortqtl}{integer64}(sorted, na.count, probs, \dots)
-\method{orderqtl}{integer64}(table, order, na.count, probs, \dots)
+sortnut(sorted, ...)
+ordernut(table, order, ...)
+sortfin(sorted, x, ...)
+orderfin(table, order, x, ...)
+orderpos(table, order, x, ...)
+sortorderpos(sorted, order, x, ...)
+orderdup(table, order, ...)
+sortorderdup(sorted, order, ...)
+sortuni(sorted, nunique, ...)
+orderuni(table, order, nunique, ...)
+sortorderuni(table, sorted, order, nunique, ...)
+orderupo(table, order, nunique, ...)
+sortorderupo(sorted, order, nunique, keep.order = FALSE, ...)
+ordertie(table, order, nties, ...)
+sortordertie(sorted, order, nties, ...)
+sorttab(sorted, nunique, ...)
+ordertab(table, order, nunique, ...)
+sortordertab(sorted, order, ...)
+orderkey(table, order, na.skip.num = 0L, ...)
+sortorderkey(sorted, order, na.skip.num = 0L, ...)
+orderrnk(table, order, na.count, ...)
+sortorderrnk(sorted, order, na.count, ...)
+\method{sortnut}{integer64}(sorted, ...)
+\method{ordernut}{integer64}(table, order, ...)
+\method{sortfin}{integer64}(sorted, x, method=NULL, ...)
+\method{orderfin}{integer64}(table, order, x, method=NULL, ...)
+\method{orderpos}{integer64}(table, order, x, nomatch=NA, method=NULL, ...)
+\method{sortorderpos}{integer64}(sorted, order, x, nomatch=NA, method=NULL, ...)
+\method{orderdup}{integer64}(table, order, method=NULL, ...)
+\method{sortorderdup}{integer64}(sorted, order, method=NULL, ...)
+\method{sortuni}{integer64}(sorted, nunique, ...)
+\method{orderuni}{integer64}(table, order, nunique, keep.order=FALSE, ...)
+\method{sortorderuni}{integer64}(table, sorted, order, nunique, ...)
+\method{orderupo}{integer64}(table, order, nunique, keep.order=FALSE, ...)
+\method{sortorderupo}{integer64}(sorted, order, nunique, keep.order = FALSE, ...)
+\method{ordertie}{integer64}(table, order, nties, ...)
+\method{sortordertie}{integer64}(sorted, order, nties, ...)
+\method{sorttab}{integer64}(sorted, nunique, ...)
+\method{ordertab}{integer64}(table, order, nunique, denormalize=FALSE, keep.order=FALSE, ...)
+\method{sortordertab}{integer64}(sorted, order, denormalize=FALSE, ...)
+\method{orderkey}{integer64}(table, order, na.skip.num = 0L, ...)
+\method{sortorderkey}{integer64}(sorted, order, na.skip.num = 0L, ...)
+\method{orderrnk}{integer64}(table, order, na.count, ...)
+\method{sortorderrnk}{integer64}(sorted, order, na.count, ...)
+\method{sortqtl}{integer64}(sorted, na.count, probs, ...)
+\method{orderqtl}{integer64}(table, order, na.count, probs, ...)
 }
 \arguments{
   \item{x}{ an \code{\link{integer64}} vector }
@@ -116,7 +116,7 @@ sortorderrnk(sorted, order, na.count, \dots)
   \item{na.skip.num}{ 0 or the number of \code{NA}s. With 0, \code{NA}s are coded with 1L, with the number of \code{NA}s, these are coded with \code{NA} }
   \item{na.count}{ the number of \code{NA}s, needed for this low-level function algorithm }
   \item{method}{ see details }
-  \item{\dots}{ further arguments, passed from generics, ignored in methods }
+  \item{...}{ further arguments, passed from generics, ignored in methods }
 }
 \details{
 \tabular{rrrrl}{
diff --git a/man/sum.integer64.Rd b/man/sum.integer64.Rd
index fc5d43a..00ff7a8 100644
--- a/man/sum.integer64.Rd
+++ b/man/sum.integer64.Rd
@@ -15,17 +15,17 @@
   Function 'range' without arguments returns the smallest and largest value of the 'integer64' class.
 }
 \usage{
-\method{all}{integer64}(\dots, na.rm = FALSE)
-\method{any}{integer64}(\dots, na.rm = FALSE)
-\method{min}{integer64}(\dots, na.rm = FALSE)
-\method{max}{integer64}(\dots, na.rm = FALSE)
-\method{range}{integer64}(\dots, na.rm = FALSE, finite = FALSE)
+\method{all}{integer64}(..., na.rm = FALSE)
+\method{any}{integer64}(..., na.rm = FALSE)
+\method{min}{integer64}(..., na.rm = FALSE)
+\method{max}{integer64}(..., na.rm = FALSE)
+\method{range}{integer64}(..., na.rm = FALSE, finite = FALSE)
 lim.integer64()
-\method{sum}{integer64}(\dots, na.rm = FALSE)
-\method{prod}{integer64}(\dots, na.rm = FALSE)
+\method{sum}{integer64}(..., na.rm = FALSE)
+\method{prod}{integer64}(..., na.rm = FALSE)
 }
 \arguments{
-  \item{\dots}{ atomic vectors of class 'integer64'}
+  \item{...}{ atomic vectors of class 'integer64'}
   \item{na.rm}{ logical scalar indicating whether to ignore NAs }
   \item{finite}{ logical scalar indicating whether to ignore NAs (just for compatibility with \code{\link{range.default}}) }
 }
diff --git a/man/table.integer64.Rd b/man/table.integer64.Rd
index e68b149..bc6356f 100644
--- a/man/table.integer64.Rd
+++ b/man/table.integer64.Rd
@@ -12,7 +12,7 @@
   table of the counts at each combination of vector values.
 }
 \usage{
-table.integer64(\dots
+table.integer64(...
 , return = c("table","data.frame","list")
 , order = c("values","counts")
 , nunique = NULL
@@ -21,7 +21,7 @@ table.integer64(\dots
 )
 }
 \arguments{
-  \item{\dots}{one or more objects which can be interpreted as factors
+  \item{...}{one or more objects which can be interpreted as factors
     (including character strings), or a list (or data frame) whose
     components can be so interpreted.  (For \code{as.table} and
     \code{as.data.frame}, arguments passed to specific methods.)}
@@ -51,7 +51,7 @@ and \code{\link{ordertab}} (memory saving ordering).
 \cr
   If the argument \code{dnn} is not supplied, the internal function
   \code{list.names} is called to compute the \sQuote{dimname names}.  If the
-  arguments in \code{\dots} are named, those names are used.  For the
+  arguments in \code{...} are named, those names are used.  For the
   remaining arguments, \code{deparse.level = 0} gives an empty name,
   \code{deparse.level = 1} uses the supplied argument if it is a symbol,
   and \code{deparse.level = 2} will deparse the argument.
diff --git a/man/tiepos.Rd b/man/tiepos.Rd
index 6c9af20..6a4457c 100644
--- a/man/tiepos.Rd
+++ b/man/tiepos.Rd
@@ -6,8 +6,8 @@
   \code{tiepos} returns the positions of those elements that participate in ties.
 }
 \usage{
-tiepos(x, \dots)
-\method{tiepos}{integer64}(x, nties = NULL, method = NULL, \dots)
+tiepos(x, ...)
+\method{tiepos}{integer64}(x, nties = NULL, method = NULL, ...)
 }
 \arguments{
   \item{x}{a vector or a data frame or an array or \code{NULL}.}
@@ -17,7 +17,7 @@ tiepos(x, \dots)
   \item{method}{
     NULL for automatic method selection or a suitable low-level method, see details
 }
-  \item{\dots}{ignored}
+  \item{...}{ignored}
 }
 \details{
   This function automatically chooses from several low-level functions considering the size of \code{x} and the availability of a cache.
diff --git a/man/unipos.Rd b/man/unipos.Rd
index 389e518..80c763d 100644
--- a/man/unipos.Rd
+++ b/man/unipos.Rd
@@ -6,9 +6,9 @@
   \code{unipos} returns the positions of those elements returned by \code{\link{unique}}.
 }
 \usage{
-unipos(x, incomparables = FALSE, order = c("original","values","any"), \dots)
+unipos(x, incomparables = FALSE, order = c("original","values","any"), ...)
 \method{unipos}{integer64}(x, incomparables = FALSE, order = c("original","values","any")
-, nunique = NULL, method = NULL, \dots)
+, nunique = NULL, method = NULL, ...)
 }
 \arguments{
   \item{x}{a vector or a data frame or an array or \code{NULL}.}
@@ -20,7 +20,7 @@ unipos(x, incomparables = FALSE, order = c("original","values","any"), \dots)
   \item{method}{
     NULL for automatic method selection or a suitable low-level method, see details
 }
-  \item{\dots}{ignored}
+  \item{...}{ignored}
 }
 \details{
   This function automatically chooses from several low-level functions considering the size of \code{x} and the availability of a cache.
diff --git a/man/unique.integer64.Rd b/man/unique.integer64.Rd
index 7b88f72..bbe7d9c 100644
--- a/man/unique.integer64.Rd
+++ b/man/unique.integer64.Rd
@@ -6,7 +6,7 @@
 }
 \usage{
 \method{unique}{integer64}(x, incomparables = FALSE, order = c("original","values","any")
-, nunique = NULL, method = NULL, \dots)
+, nunique = NULL, method = NULL, ...)
 }
 \arguments{
   \item{x}{a vector or a data frame or an array or \code{NULL}.}
@@ -18,7 +18,7 @@
   \item{method}{
     NULL for automatic method selection or a suitable low-level method, see details
 }
-  \item{\dots}{ignored}
+  \item{...}{ignored}
 }
 \details{
   This function automatically chooses from several low-level functions considering the size of \code{x} and the availability of a cache.