R version 4.4.0 alpha (2024-03-26 r86209 ucrt)
Copyright (C) 2024 The R Foundation for Statistical Computing
Platform: x86_64-w64-mingw32/x64

R is free software and comes with ABSOLUTELY NO WARRANTY.
You are welcome to redistribute it under certain conditions.
Type 'license()' or 'licence()' for distribution details.

R is a collaborative project with many contributors.
Type 'contributors()' for more information and
'citation()' on how to cite R or R packages in publications.

Type 'demo()' for some demos, 'help()' for on-line help, or
'help.start()' for an HTML browser interface to help.
Type 'q()' to quit R.

> source("incl/start.R")
Loading required package: future
[15:31:03.698] plan(): Setting new future strategy stack:
[15:31:03.700] List of future strategies:
[15:31:03.700] 1. sequential:
[15:31:03.700]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:03.700]    - tweaked: FALSE
[15:31:03.700]    - call: future::plan("sequential")
[15:31:03.727] plan(): nbrOfWorkers() = 1
> 
> message("*** future_apply() ...")
*** future_apply() ...
> 
> z0 <- NULL
> 
> for (strategy in supportedStrategies()) {
+   message(sprintf("*** strategy = %s ...", sQuote(strategy)))
+   plan(strategy)
+ 
+   message("- From example(apply) ...")
+   X <- matrix(c(1:4, 1, 6:8), nrow = 2L)
+   
+   Y0 <- apply(X, MARGIN = 1L, FUN = table)
+   Y1 <- future_apply(X, MARGIN = 1L, FUN = table)
+   print(Y1)
+   stopifnot(all.equal(Y1, Y0, check.attributes = FALSE)) ## FIXME
+ 
+   Y2 <- future_apply(X, MARGIN = 1L, FUN = "table")
+   print(Y2)
+   stopifnot(identical(Y2, Y1))
+ 
+   Y0 <- apply(X, MARGIN = 1L, FUN = stats::quantile)
+   Y1 <- future_apply(X, MARGIN = 1L, FUN = stats::quantile)
+   print(Y1)
+   stopifnot(all.equal(Y1, Y0))
+ 
+   x <- cbind(x1 = 3, x2 = c(4:1, 2:5))
+   names(dimnames(x)) <- c("row", "col")
+   x3 <- array(x, dim = c(dim(x), 3),
+               dimnames = c(dimnames(x), list(C = paste0("cop.", 1:3))))
+   
+   y0 <- apply(x, MARGIN = 2L, FUN = identity)
+   stopifnot(identical(y0, x))
+   y1 <- future_apply(x, MARGIN = 2L, FUN = identity)
+   print(y1)
+   stopifnot(identical(y1, y0))
+   
+   y0 <- apply(x3, MARGIN = 2:3, FUN = identity)
+   stopifnot(identical(y0, x3))
+   y1 <- future_apply(x3, MARGIN = 2:3, FUN = identity)
+   print(y1)
+   stopifnot(identical(y1, y0))
+ 
+   z <- array(1:24, dim = 2:4)
+   y0 <- apply(z, MARGIN = 1:2, FUN = function(x) seq_len(max(x)))
+   y1 <- future_apply(z, MARGIN = 1:2, FUN = function(x) seq_len(max(x)))
+   print(y1)
+   stopifnot(identical(y1, y0))
+ 
+   message("- apply(X, MARGIN = <character>, ...) ...")
+   X <- matrix(1:2, nrow = 2L, ncol = 1L, dimnames = list(rows = c("a", "b")))
+   y0 <- apply(X, MARGIN = "rows", FUN = identity)
+   y1 <- future_apply(X, MARGIN = "rows", FUN = identity)
+   print(y1)
+   stopifnot(identical(y1, y0))
+ 
+   message("- apply(X, ...) - dim(X) > 2 ...")
+   X <- array(1:12, dim = c(2, 2, 3))
+   y0 <- apply(X, MARGIN = 1L, FUN = identity)
+   y1 <- future_apply(X, MARGIN = 1L, FUN = identity)
+   print(y1)
+   stopifnot(identical(y1, y0))
+ 
+   message("- apply(X, ...) - not all same names ...")
+   FUN <- function(x) {
+     if (x[1] == 1L) names(x) <- letters[seq_along(x)]
+     x
+   }
+   X <- matrix(1:4, nrow = 2L, ncol = 2L)
+   y0 <- apply(X, MARGIN = 1L, FUN = FUN)
+   y1 <- future_apply(X, MARGIN = 1L, FUN = FUN)
+   print(y1)
+   stopifnot(identical(y1, y0))
+ 
+   message("- example(future_apply) - reproducible RNG ...")
+   z1 <- future_apply(X, MARGIN = 1L, FUN = sample,
+           future.seed = 0xBEEF,
+           ## Test also all other 'future.*' arguments
+           future.stdout     = TRUE,
+           future.conditions = NULL,
+           future.globals    = TRUE,
+           future.packages   = NULL,
+           future.scheduling = 1.0,
+           future.chunk.size = NULL,
+           future.label      = "future_apply-%d"
+         )
+   print(z1)
+   if (is.null(z0)) {
+     z0 <- z1
+   } else {
+     stopifnot(identical(z1, z0))
+   }
+ 
+   plan(sequential)
+   message(sprintf("*** strategy = %s ... done", sQuote(strategy)))
+ } ## for (strategy in ...) 
*** strategy = 'sequential' ...
[15:31:03.833] plan(): Setting new future strategy stack:
[15:31:03.834] List of future strategies:
[15:31:03.834] 1. sequential:
[15:31:03.834]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:03.834]    - tweaked: FALSE
[15:31:03.834]    - call: plan(strategy)
[15:31:03.851] plan(): nbrOfWorkers() = 1
- From example(apply) ...
[15:31:03.852] getGlobalsAndPackagesXApply() ...
[15:31:03.852]  - future.globals: TRUE
[15:31:03.853] getGlobalsAndPackages() ...
[15:31:03.853] Searching for globals...
[15:31:03.925] - globals found: [59] 'FUN', 'if', '==', 'c', 'list.names', '{', '<-', '[', 'as.list', 'substitute', '-', '&&', 'length', 'is.list', '!', 'is.null', 'names', 'return', 'seq_along', 'vapply', 'switch', '+', 'is.symbol', 'as.character', 'deparse', '[<-', 'missing', 'match', 'match.arg', '!=', 'warning', 'list', '[[', 'paste', 'stop', 'integer', 'for', 'is.factor', 'anyNA', 'options', 'on.exit', 'factor', '(', '||', 'levels', 'as.integer', 'which', 'is.na', 'is.na<-', '>', 'prod', '$', '.Machine', '*', 'names<-', 'array', 'tabulate', 'class', 'class<-'
[15:31:03.925] Searching for globals ... DONE
[15:31:03.926] Resolving globals: FALSE
[15:31:03.930] The total size of the 1 globals is 345.92 KiB (354224 bytes)
[15:31:03.931] The total size of the 1 globals exported for future expression ('FUN(X = structure(c(1, 2, 3, 4, 1, 6, 7, 8), dim = c(2L, 4L)))') is 345.92 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (345.92 KiB of class 'function')
[15:31:03.931] - globals: [1] 'FUN'
[15:31:03.932] 
[15:31:03.932] getGlobalsAndPackages() ... DONE
[15:31:03.932]  - globals found/used: [n=1] 'FUN'
[15:31:03.932]  - needed namespaces: [n=0] 
[15:31:03.933] Finding globals ... DONE
[15:31:03.933]  - use_args: TRUE
[15:31:03.933]  - Getting '...' globals ...
[15:31:03.934] resolve() on list ...
[15:31:03.935]  recursive: 0
[15:31:03.935]  length: 1
[15:31:03.935]  elements: '...'
[15:31:03.936]  length: 0 (resolved future 1)
[15:31:03.936] resolve() on list ... DONE
[15:31:03.936]    - '...' content: [n=0] 
[15:31:03.937] List of 1
[15:31:03.937]  $ ...: list()
[15:31:03.937]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:03.937]  - attr(*, "where")=List of 1
[15:31:03.937]   ..$ ...:<environment: 0x000001bcb7c13420> 
[15:31:03.937]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:03.937]  - attr(*, "resolved")= logi TRUE
[15:31:03.937]  - attr(*, "total_size")= num NA
[15:31:03.944]  - Getting '...' globals ... DONE
[15:31:03.945] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:03.945] List of 2
[15:31:03.945]  $ ...future.FUN:function (..., exclude = if (useNA == "no") c(NA, NaN), useNA = c("no", 
[15:31:03.945]     "ifany", "always"), dnn = list.names(...), deparse.level = 1)  
[15:31:03.945]  $ ...          : list()
[15:31:03.945]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:03.945]  - attr(*, "where")=List of 2
[15:31:03.945]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:03.945]   ..$ ...          :<environment: 0x000001bcb7c13420> 
[15:31:03.945]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:03.945]  - attr(*, "resolved")= logi FALSE
[15:31:03.945]  - attr(*, "total_size")= num 354224
[15:31:03.950] Packages to be attached in all futures: [n=0] 
[15:31:03.950] getGlobalsAndPackagesXApply() ... DONE
[15:31:03.951] future_lapply() ...
[15:31:04.028] Number of chunks: 1
[15:31:04.028] getGlobalsAndPackagesXApply() ...
[15:31:04.028]  - future.globals: <name-value list> with names 'list()'
[15:31:04.029]  - use_args: TRUE
[15:31:04.029] Globals to be used in all futures (chunks): [n=2] '...', '...future.FUN'
[15:31:04.029] List of 2
[15:31:04.029]  $ ...          : list()
[15:31:04.029]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:04.029]  $ ...future.FUN:function (..., exclude = if (useNA == "no") c(NA, NaN), useNA = c("no", 
[15:31:04.029]     "ifany", "always"), dnn = list.names(...), deparse.level = 1)  
[15:31:04.029]  - attr(*, "where")=List of 2
[15:31:04.029]   ..$ ...          :<environment: 0x000001bcb7c13420> 
[15:31:04.029]   ..$ ...future.FUN:<environment: namespace:base> 
[15:31:04.029]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:04.029]  - attr(*, "resolved")= logi FALSE
[15:31:04.029]  - attr(*, "total_size")= num NA
[15:31:04.035] Packages to be attached in all futures: [n=0] 
[15:31:04.036] getGlobalsAndPackagesXApply() ... DONE
[15:31:04.036] Number of futures (= number of chunks): 1
[15:31:04.037] Launching 1 futures (chunks) ...
[15:31:04.037] Chunk #1 of 1 ...
[15:31:04.037]  - seeds: <none>
[15:31:04.040]  - All globals exported: [n=5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:04.040] getGlobalsAndPackages() ...
[15:31:04.041] - globals passed as-is: [5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:04.041] Resolving globals: FALSE
[15:31:04.041] Tweak future expression to call with '...' arguments ...
[15:31:04.042] {
[15:31:04.042]     do.call(function(...) {
[15:31:04.042]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:04.042]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:04.042]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:04.042]             on.exit(options(oopts), add = TRUE)
[15:31:04.042]         }
[15:31:04.042]         {
[15:31:04.042]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:04.042]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:04.042]                 ...future.FUN(...future.X_jj, ...)
[15:31:04.042]             })
[15:31:04.042]         }
[15:31:04.042]     }, args = future.call.arguments)
[15:31:04.042] }
[15:31:04.043] Tweak future expression to call with '...' arguments ... DONE
[15:31:04.043] - globals: [5] 'future.call.arguments', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:04.044] 
[15:31:04.044] getGlobalsAndPackages() ... DONE
[15:31:04.045] run() for 'Future' ...
[15:31:04.046] - state: 'created'
[15:31:04.046] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:31:04.047] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:04.048] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:31:04.048]   - Field: 'label'
[15:31:04.048]   - Field: 'local'
[15:31:04.049]   - Field: 'owner'
[15:31:04.049]   - Field: 'envir'
[15:31:04.049]   - Field: 'packages'
[15:31:04.050]   - Field: 'gc'
[15:31:04.050]   - Field: 'conditions'
[15:31:04.050]   - Field: 'expr'
[15:31:04.051]   - Field: 'uuid'
[15:31:04.051]   - Field: 'seed'
[15:31:04.051]   - Field: 'version'
[15:31:04.052]   - Field: 'result'
[15:31:04.052]   - Field: 'asynchronous'
[15:31:04.052]   - Field: 'calls'
[15:31:04.053]   - Field: 'globals'
[15:31:04.053]   - Field: 'stdout'
[15:31:04.053]   - Field: 'earlySignal'
[15:31:04.054]   - Field: 'lazy'
[15:31:04.054]   - Field: 'state'
[15:31:04.054] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:31:04.054] - Launch lazy future ...
[15:31:04.056] Packages needed by the future expression (n = 0): <none>
[15:31:04.056] Packages needed by future strategies (n = 0): <none>
[15:31:04.057] {
[15:31:04.057]     {
[15:31:04.057]         {
[15:31:04.057]             ...future.startTime <- base::Sys.time()
[15:31:04.057]             {
[15:31:04.057]                 {
[15:31:04.057]                   {
[15:31:04.057]                     base::local({
[15:31:04.057]                       has_future <- base::requireNamespace("future", 
[15:31:04.057]                         quietly = TRUE)
[15:31:04.057]                       if (has_future) {
[15:31:04.057]                         ns <- base::getNamespace("future")
[15:31:04.057]                         version <- ns[[".package"]][["version"]]
[15:31:04.057]                         if (is.null(version)) 
[15:31:04.057]                           version <- utils::packageVersion("future")
[15:31:04.057]                       }
[15:31:04.057]                       else {
[15:31:04.057]                         version <- NULL
[15:31:04.057]                       }
[15:31:04.057]                       if (!has_future || version < "1.8.0") {
[15:31:04.057]                         info <- base::c(r_version = base::gsub("R version ", 
[15:31:04.057]                           "", base::R.version$version.string), 
[15:31:04.057]                           platform = base::sprintf("%s (%s-bit)", 
[15:31:04.057]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:04.057]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:04.057]                             "release", "version")], collapse = " "), 
[15:31:04.057]                           hostname = base::Sys.info()[["nodename"]])
[15:31:04.057]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:31:04.057]                           info)
[15:31:04.057]                         info <- base::paste(info, collapse = "; ")
[15:31:04.057]                         if (!has_future) {
[15:31:04.057]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:04.057]                             info)
[15:31:04.057]                         }
[15:31:04.057]                         else {
[15:31:04.057]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:04.057]                             info, version)
[15:31:04.057]                         }
[15:31:04.057]                         base::stop(msg)
[15:31:04.057]                       }
[15:31:04.057]                     })
[15:31:04.057]                   }
[15:31:04.057]                   ...future.strategy.old <- future::plan("list")
[15:31:04.057]                   options(future.plan = NULL)
[15:31:04.057]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:04.057]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:04.057]                 }
[15:31:04.057]                 ...future.workdir <- getwd()
[15:31:04.057]             }
[15:31:04.057]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:04.057]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:04.057]         }
[15:31:04.057]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:04.057]             future.globals.maxSize = Inf, future.globals.method = NULL, 
[15:31:04.057]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:04.057]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:04.057]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:04.057]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:04.057]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:04.057]             base::names(...future.oldOptions))
[15:31:04.057]     }
[15:31:04.057]     if (FALSE) {
[15:31:04.057]     }
[15:31:04.057]     else {
[15:31:04.057]         if (TRUE) {
[15:31:04.057]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:04.057]                 open = "w")
[15:31:04.057]         }
[15:31:04.057]         else {
[15:31:04.057]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:04.057]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:04.057]         }
[15:31:04.057]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:04.057]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:04.057]             base::sink(type = "output", split = FALSE)
[15:31:04.057]             base::close(...future.stdout)
[15:31:04.057]         }, add = TRUE)
[15:31:04.057]     }
[15:31:04.057]     ...future.frame <- base::sys.nframe()
[15:31:04.057]     ...future.conditions <- base::list()
[15:31:04.057]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:04.057]     if (FALSE) {
[15:31:04.057]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:04.057]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:04.057]     }
[15:31:04.057]     ...future.result <- base::tryCatch({
[15:31:04.057]         base::withCallingHandlers({
[15:31:04.057]             ...future.value <- base::withVisible(base::local({
[15:31:04.057]                 do.call(function(...) {
[15:31:04.057]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:04.057]                   if (!identical(...future.globals.maxSize.org, 
[15:31:04.057]                     ...future.globals.maxSize)) {
[15:31:04.057]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:04.057]                     on.exit(options(oopts), add = TRUE)
[15:31:04.057]                   }
[15:31:04.057]                   {
[15:31:04.057]                     lapply(seq_along(...future.elements_ii), 
[15:31:04.057]                       FUN = function(jj) {
[15:31:04.057]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:04.057]                         ...future.FUN(...future.X_jj, ...)
[15:31:04.057]                       })
[15:31:04.057]                   }
[15:31:04.057]                 }, args = future.call.arguments)
[15:31:04.057]             }))
[15:31:04.057]             future::FutureResult(value = ...future.value$value, 
[15:31:04.057]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:04.057]                   ...future.rng), globalenv = if (FALSE) 
[15:31:04.057]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:04.057]                     ...future.globalenv.names))
[15:31:04.057]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:04.057]         }, condition = base::local({
[15:31:04.057]             c <- base::c
[15:31:04.057]             inherits <- base::inherits
[15:31:04.057]             invokeRestart <- base::invokeRestart
[15:31:04.057]             length <- base::length
[15:31:04.057]             list <- base::list
[15:31:04.057]             seq.int <- base::seq.int
[15:31:04.057]             signalCondition <- base::signalCondition
[15:31:04.057]             sys.calls <- base::sys.calls
[15:31:04.057]             `[[` <- base::`[[`
[15:31:04.057]             `+` <- base::`+`
[15:31:04.057]             `<<-` <- base::`<<-`
[15:31:04.057]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:04.057]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:04.057]                   3L)]
[15:31:04.057]             }
[15:31:04.057]             function(cond) {
[15:31:04.057]                 is_error <- inherits(cond, "error")
[15:31:04.057]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:04.057]                   NULL)
[15:31:04.057]                 if (is_error) {
[15:31:04.057]                   sessionInformation <- function() {
[15:31:04.057]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:04.057]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:04.057]                       search = base::search(), system = base::Sys.info())
[15:31:04.057]                   }
[15:31:04.057]                   ...future.conditions[[length(...future.conditions) + 
[15:31:04.057]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:04.057]                     cond$call), session = sessionInformation(), 
[15:31:04.057]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:04.057]                   signalCondition(cond)
[15:31:04.057]                 }
[15:31:04.057]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:04.057]                 "immediateCondition"))) {
[15:31:04.057]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:04.057]                   ...future.conditions[[length(...future.conditions) + 
[15:31:04.057]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:04.057]                   if (TRUE && !signal) {
[15:31:04.057]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:04.057]                     {
[15:31:04.057]                       inherits <- base::inherits
[15:31:04.057]                       invokeRestart <- base::invokeRestart
[15:31:04.057]                       is.null <- base::is.null
[15:31:04.057]                       muffled <- FALSE
[15:31:04.057]                       if (inherits(cond, "message")) {
[15:31:04.057]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:04.057]                         if (muffled) 
[15:31:04.057]                           invokeRestart("muffleMessage")
[15:31:04.057]                       }
[15:31:04.057]                       else if (inherits(cond, "warning")) {
[15:31:04.057]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:04.057]                         if (muffled) 
[15:31:04.057]                           invokeRestart("muffleWarning")
[15:31:04.057]                       }
[15:31:04.057]                       else if (inherits(cond, "condition")) {
[15:31:04.057]                         if (!is.null(pattern)) {
[15:31:04.057]                           computeRestarts <- base::computeRestarts
[15:31:04.057]                           grepl <- base::grepl
[15:31:04.057]                           restarts <- computeRestarts(cond)
[15:31:04.057]                           for (restart in restarts) {
[15:31:04.057]                             name <- restart$name
[15:31:04.057]                             if (is.null(name)) 
[15:31:04.057]                               next
[15:31:04.057]                             if (!grepl(pattern, name)) 
[15:31:04.057]                               next
[15:31:04.057]                             invokeRestart(restart)
[15:31:04.057]                             muffled <- TRUE
[15:31:04.057]                             break
[15:31:04.057]                           }
[15:31:04.057]                         }
[15:31:04.057]                       }
[15:31:04.057]                       invisible(muffled)
[15:31:04.057]                     }
[15:31:04.057]                     muffleCondition(cond, pattern = "^muffle")
[15:31:04.057]                   }
[15:31:04.057]                 }
[15:31:04.057]                 else {
[15:31:04.057]                   if (TRUE) {
[15:31:04.057]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:04.057]                     {
[15:31:04.057]                       inherits <- base::inherits
[15:31:04.057]                       invokeRestart <- base::invokeRestart
[15:31:04.057]                       is.null <- base::is.null
[15:31:04.057]                       muffled <- FALSE
[15:31:04.057]                       if (inherits(cond, "message")) {
[15:31:04.057]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:04.057]                         if (muffled) 
[15:31:04.057]                           invokeRestart("muffleMessage")
[15:31:04.057]                       }
[15:31:04.057]                       else if (inherits(cond, "warning")) {
[15:31:04.057]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:04.057]                         if (muffled) 
[15:31:04.057]                           invokeRestart("muffleWarning")
[15:31:04.057]                       }
[15:31:04.057]                       else if (inherits(cond, "condition")) {
[15:31:04.057]                         if (!is.null(pattern)) {
[15:31:04.057]                           computeRestarts <- base::computeRestarts
[15:31:04.057]                           grepl <- base::grepl
[15:31:04.057]                           restarts <- computeRestarts(cond)
[15:31:04.057]                           for (restart in restarts) {
[15:31:04.057]                             name <- restart$name
[15:31:04.057]                             if (is.null(name)) 
[15:31:04.057]                               next
[15:31:04.057]                             if (!grepl(pattern, name)) 
[15:31:04.057]                               next
[15:31:04.057]                             invokeRestart(restart)
[15:31:04.057]                             muffled <- TRUE
[15:31:04.057]                             break
[15:31:04.057]                           }
[15:31:04.057]                         }
[15:31:04.057]                       }
[15:31:04.057]                       invisible(muffled)
[15:31:04.057]                     }
[15:31:04.057]                     muffleCondition(cond, pattern = "^muffle")
[15:31:04.057]                   }
[15:31:04.057]                 }
[15:31:04.057]             }
[15:31:04.057]         }))
[15:31:04.057]     }, error = function(ex) {
[15:31:04.057]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:04.057]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:04.057]                 ...future.rng), started = ...future.startTime, 
[15:31:04.057]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:04.057]             version = "1.8"), class = "FutureResult")
[15:31:04.057]     }, finally = {
[15:31:04.057]         if (!identical(...future.workdir, getwd())) 
[15:31:04.057]             setwd(...future.workdir)
[15:31:04.057]         {
[15:31:04.057]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:04.057]                 ...future.oldOptions$nwarnings <- NULL
[15:31:04.057]             }
[15:31:04.057]             base::options(...future.oldOptions)
[15:31:04.057]             if (.Platform$OS.type == "windows") {
[15:31:04.057]                 old_names <- names(...future.oldEnvVars)
[15:31:04.057]                 envs <- base::Sys.getenv()
[15:31:04.057]                 names <- names(envs)
[15:31:04.057]                 common <- intersect(names, old_names)
[15:31:04.057]                 added <- setdiff(names, old_names)
[15:31:04.057]                 removed <- setdiff(old_names, names)
[15:31:04.057]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:04.057]                   envs[common]]
[15:31:04.057]                 NAMES <- toupper(changed)
[15:31:04.057]                 args <- list()
[15:31:04.057]                 for (kk in seq_along(NAMES)) {
[15:31:04.057]                   name <- changed[[kk]]
[15:31:04.057]                   NAME <- NAMES[[kk]]
[15:31:04.057]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:04.057]                     next
[15:31:04.057]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:04.057]                 }
[15:31:04.057]                 NAMES <- toupper(added)
[15:31:04.057]                 for (kk in seq_along(NAMES)) {
[15:31:04.057]                   name <- added[[kk]]
[15:31:04.057]                   NAME <- NAMES[[kk]]
[15:31:04.057]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:04.057]                     next
[15:31:04.057]                   args[[name]] <- ""
[15:31:04.057]                 }
[15:31:04.057]                 NAMES <- toupper(removed)
[15:31:04.057]                 for (kk in seq_along(NAMES)) {
[15:31:04.057]                   name <- removed[[kk]]
[15:31:04.057]                   NAME <- NAMES[[kk]]
[15:31:04.057]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:04.057]                     next
[15:31:04.057]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:04.057]                 }
[15:31:04.057]                 if (length(args) > 0) 
[15:31:04.057]                   base::do.call(base::Sys.setenv, args = args)
[15:31:04.057]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:04.057]             }
[15:31:04.057]             else {
[15:31:04.057]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:04.057]             }
[15:31:04.057]             {
[15:31:04.057]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:04.057]                   0L) {
[15:31:04.057]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:04.057]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:04.057]                   base::options(opts)
[15:31:04.057]                 }
[15:31:04.057]                 {
[15:31:04.057]                   {
[15:31:04.057]                     NULL
[15:31:04.057]                     RNGkind("Mersenne-Twister")
[15:31:04.057]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:31:04.057]                       inherits = FALSE)
[15:31:04.057]                   }
[15:31:04.057]                   options(future.plan = NULL)
[15:31:04.057]                   if (is.na(NA_character_)) 
[15:31:04.057]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:04.057]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:04.057]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:04.057]                     .init = FALSE)
[15:31:04.057]                 }
[15:31:04.057]             }
[15:31:04.057]         }
[15:31:04.057]     })
[15:31:04.057]     if (TRUE) {
[15:31:04.057]         base::sink(type = "output", split = FALSE)
[15:31:04.057]         if (TRUE) {
[15:31:04.057]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:04.057]         }
[15:31:04.057]         else {
[15:31:04.057]             ...future.result["stdout"] <- base::list(NULL)
[15:31:04.057]         }
[15:31:04.057]         base::close(...future.stdout)
[15:31:04.057]         ...future.stdout <- NULL
[15:31:04.057]     }
[15:31:04.057]     ...future.result$conditions <- ...future.conditions
[15:31:04.057]     ...future.result$finished <- base::Sys.time()
[15:31:04.057]     ...future.result
[15:31:04.057] }
[15:31:04.064] assign_globals() ...
[15:31:04.065] List of 5
[15:31:04.065]  $ future.call.arguments    : list()
[15:31:04.065]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:04.065]  $ ...future.FUN            :function (..., exclude = if (useNA == "no") c(NA, NaN), useNA = c("no", 
[15:31:04.065]     "ifany", "always"), dnn = list.names(...), deparse.level = 1)  
[15:31:04.065]  $ ...future.elements_ii    :List of 2
[15:31:04.065]   ..$ : num [1:4] 1 3 1 7
[15:31:04.065]   ..$ : num [1:4] 2 4 6 8
[15:31:04.065]  $ ...future.seeds_ii       : NULL
[15:31:04.065]  $ ...future.globals.maxSize: num Inf
[15:31:04.065]  - attr(*, "resolved")= logi FALSE
[15:31:04.065]  - attr(*, "total_size")= num NA
[15:31:04.065]  - attr(*, "where")=List of 5
[15:31:04.065]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:31:04.065]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:31:04.065]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:31:04.065]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:31:04.065]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:31:04.065]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:04.065]  - attr(*, "already-done")= logi TRUE
[15:31:04.076] - copied 'future.call.arguments' to environment
[15:31:04.076] - copied '...future.FUN' to environment
[15:31:04.076] - copied '...future.elements_ii' to environment
[15:31:04.077] - copied '...future.seeds_ii' to environment
[15:31:04.077] - copied '...future.globals.maxSize' to environment
[15:31:04.077] assign_globals() ... done
[15:31:04.078] plan(): Setting new future strategy stack:
[15:31:04.078] List of future strategies:
[15:31:04.078] 1. sequential:
[15:31:04.078]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:04.078]    - tweaked: FALSE
[15:31:04.078]    - call: NULL
[15:31:04.079] plan(): nbrOfWorkers() = 1
[15:31:04.083] plan(): Setting new future strategy stack:
[15:31:04.083] List of future strategies:
[15:31:04.083] 1. sequential:
[15:31:04.083]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:04.083]    - tweaked: FALSE
[15:31:04.083]    - call: plan(strategy)
[15:31:04.084] plan(): nbrOfWorkers() = 1
[15:31:04.084] SequentialFuture started (and completed)
[15:31:04.085] - Launch lazy future ... done
[15:31:04.085] run() for 'SequentialFuture' ... done
[15:31:04.086] Created future:
[15:31:04.086] SequentialFuture:
[15:31:04.086] Label: 'future_apply-1'
[15:31:04.086] Expression:
[15:31:04.086] {
[15:31:04.086]     do.call(function(...) {
[15:31:04.086]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:04.086]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:04.086]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:04.086]             on.exit(options(oopts), add = TRUE)
[15:31:04.086]         }
[15:31:04.086]         {
[15:31:04.086]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:04.086]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:04.086]                 ...future.FUN(...future.X_jj, ...)
[15:31:04.086]             })
[15:31:04.086]         }
[15:31:04.086]     }, args = future.call.arguments)
[15:31:04.086] }
[15:31:04.086] Lazy evaluation: FALSE
[15:31:04.086] Asynchronous evaluation: FALSE
[15:31:04.086] Local evaluation: TRUE
[15:31:04.086] Environment: R_GlobalEnv
[15:31:04.086] Capture standard output: TRUE
[15:31:04.086] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:04.086] Globals: 5 objects totaling 346.13 KiB (DotDotDotList 'future.call.arguments' of 0 bytes, function '...future.FUN' of 345.92 KiB, list '...future.elements_ii' of 160 bytes, NULL '...future.seeds_ii' of 0 bytes, numeric '...future.globals.maxSize' of 56 bytes)
[15:31:04.086] Packages: <none>
[15:31:04.086] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:04.086] Resolved: TRUE
[15:31:04.086] Value: 2.21 KiB of class 'list'
[15:31:04.086] Early signaling: FALSE
[15:31:04.086] Owner process: 6672a580-6d3c-e82f-380e-108c475ace70
[15:31:04.086] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:04.089] Chunk #1 of 1 ... DONE
[15:31:04.089] Launching 1 futures (chunks) ... DONE
[15:31:04.089] Resolving 1 futures (chunks) ...
[15:31:04.090] resolve() on list ...
[15:31:04.090]  recursive: 0
[15:31:04.090]  length: 1
[15:31:04.091] 
[15:31:04.091] resolved() for 'SequentialFuture' ...
[15:31:04.091] - state: 'finished'
[15:31:04.092] - run: TRUE
[15:31:04.092] - result: 'FutureResult'
[15:31:04.092] resolved() for 'SequentialFuture' ... done
[15:31:04.092] Future #1
[15:31:04.093] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:31:04.094] - nx: 1
[15:31:04.094] - relay: TRUE
[15:31:04.094] - stdout: TRUE
[15:31:04.094] - signal: TRUE
[15:31:04.095] - resignal: FALSE
[15:31:04.095] - force: TRUE
[15:31:04.095] - relayed: [n=1] FALSE
[15:31:04.095] - queued futures: [n=1] FALSE
[15:31:04.096]  - until=1
[15:31:04.096]  - relaying element #1
[15:31:04.096] - relayed: [n=1] TRUE
[15:31:04.097] - queued futures: [n=1] TRUE
[15:31:04.097] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:31:04.101]  length: 0 (resolved future 1)
[15:31:04.101] Relaying remaining futures
[15:31:04.101] signalConditionsASAP(NULL, pos=0) ...
[15:31:04.102] - nx: 1
[15:31:04.102] - relay: TRUE
[15:31:04.102] - stdout: TRUE
[15:31:04.103] - signal: TRUE
[15:31:04.103] - resignal: FALSE
[15:31:04.103] - force: TRUE
[15:31:04.103] - relayed: [n=1] TRUE
[15:31:04.104] - queued futures: [n=1] TRUE
 - flush all
[15:31:04.104] - relayed: [n=1] TRUE
[15:31:04.104] - queued futures: [n=1] TRUE
[15:31:04.105] signalConditionsASAP(NULL, pos=0) ... done
[15:31:04.105] resolve() on list ... DONE
[15:31:04.105]  - Number of value chunks collected: 1
[15:31:04.106] Resolving 1 futures (chunks) ... DONE
[15:31:04.106] Reducing values from 1 chunks ...
[15:31:04.106]  - Number of values collected after concatenation: 2
[15:31:04.106]  - Number of values expected: 2
[15:31:04.107] Reducing values from 1 chunks ... DONE
[15:31:04.107] future_lapply() ... DONE
[[1]]
...future.X_jj
1 3 7 
2 1 1 

[[2]]
...future.X_jj
2 4 6 8 
1 1 1 1 

[15:31:04.109] getGlobalsAndPackagesXApply() ...
[15:31:04.109]  - future.globals: TRUE
[15:31:04.110] getGlobalsAndPackages() ...
[15:31:04.110] Searching for globals...
[15:31:04.197] - globals found: [59] 'FUN', 'if', '==', 'c', 'list.names', '{', '<-', '[', 'as.list', 'substitute', '-', '&&', 'length', 'is.list', '!', 'is.null', 'names', 'return', 'seq_along', 'vapply', 'switch', '+', 'is.symbol', 'as.character', 'deparse', '[<-', 'missing', 'match', 'match.arg', '!=', 'warning', 'list', '[[', 'paste', 'stop', 'integer', 'for', 'is.factor', 'anyNA', 'options', 'on.exit', 'factor', '(', '||', 'levels', 'as.integer', 'which', 'is.na', 'is.na<-', '>', 'prod', '$', '.Machine', '*', 'names<-', 'array', 'tabulate', 'class', 'class<-'
[15:31:04.197] Searching for globals ... DONE
[15:31:04.198] Resolving globals: FALSE
[15:31:04.201] The total size of the 1 globals is 345.92 KiB (354224 bytes)
[15:31:04.202] The total size of the 1 globals exported for future expression ('FUN(X = structure(c(1, 2, 3, 4, 1, 6, 7, 8), dim = c(2L, 4L)))') is 345.92 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (345.92 KiB of class 'function')
[15:31:04.203] - globals: [1] 'FUN'
[15:31:04.203] 
[15:31:04.203] getGlobalsAndPackages() ... DONE
[15:31:04.203]  - globals found/used: [n=1] 'FUN'
[15:31:04.204]  - needed namespaces: [n=0] 
[15:31:04.204] Finding globals ... DONE
[15:31:04.204]  - use_args: TRUE
[15:31:04.205]  - Getting '...' globals ...
[15:31:04.205] resolve() on list ...
[15:31:04.206]  recursive: 0
[15:31:04.206]  length: 1
[15:31:04.206]  elements: '...'
[15:31:04.206]  length: 0 (resolved future 1)
[15:31:04.207] resolve() on list ... DONE
[15:31:04.207]    - '...' content: [n=0] 
[15:31:04.207] List of 1
[15:31:04.207]  $ ...: list()
[15:31:04.207]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:04.207]  - attr(*, "where")=List of 1
[15:31:04.207]   ..$ ...:<environment: 0x000001bcb900e148> 
[15:31:04.207]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:04.207]  - attr(*, "resolved")= logi TRUE
[15:31:04.207]  - attr(*, "total_size")= num NA
[15:31:04.212]  - Getting '...' globals ... DONE
[15:31:04.212] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:04.213] List of 2
[15:31:04.213]  $ ...future.FUN:function (..., exclude = if (useNA == "no") c(NA, NaN), useNA = c("no", 
[15:31:04.213]     "ifany", "always"), dnn = list.names(...), deparse.level = 1)  
[15:31:04.213]  $ ...          : list()
[15:31:04.213]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:04.213]  - attr(*, "where")=List of 2
[15:31:04.213]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:04.213]   ..$ ...          :<environment: 0x000001bcb900e148> 
[15:31:04.213]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:04.213]  - attr(*, "resolved")= logi FALSE
[15:31:04.213]  - attr(*, "total_size")= num 354224
[15:31:04.220] Packages to be attached in all futures: [n=0] 
[15:31:04.221] getGlobalsAndPackagesXApply() ... DONE
[15:31:04.221] future_lapply() ...
[15:31:04.300] Number of chunks: 1
[15:31:04.300] getGlobalsAndPackagesXApply() ...
[15:31:04.300]  - future.globals: <name-value list> with names 'list()'
[15:31:04.301]  - use_args: TRUE
[15:31:04.301] Globals to be used in all futures (chunks): [n=2] '...', '...future.FUN'
[15:31:04.301] List of 2
[15:31:04.301]  $ ...          : list()
[15:31:04.301]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:04.301]  $ ...future.FUN:function (..., exclude = if (useNA == "no") c(NA, NaN), useNA = c("no", 
[15:31:04.301]     "ifany", "always"), dnn = list.names(...), deparse.level = 1)  
[15:31:04.301]  - attr(*, "where")=List of 2
[15:31:04.301]   ..$ ...          :<environment: 0x000001bcb900e148> 
[15:31:04.301]   ..$ ...future.FUN:<environment: namespace:base> 
[15:31:04.301]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:04.301]  - attr(*, "resolved")= logi FALSE
[15:31:04.301]  - attr(*, "total_size")= num NA
[15:31:04.308] Packages to be attached in all futures: [n=0] 
[15:31:04.308] getGlobalsAndPackagesXApply() ... DONE
[15:31:04.308] Number of futures (= number of chunks): 1
[15:31:04.309] Launching 1 futures (chunks) ...
[15:31:04.309] Chunk #1 of 1 ...
[15:31:04.309]  - seeds: <none>
[15:31:04.309]  - All globals exported: [n=5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:04.310] getGlobalsAndPackages() ...
[15:31:04.310] - globals passed as-is: [5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:04.310] Resolving globals: FALSE
[15:31:04.311] Tweak future expression to call with '...' arguments ...
[15:31:04.311] {
[15:31:04.311]     do.call(function(...) {
[15:31:04.311]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:04.311]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:04.311]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:04.311]             on.exit(options(oopts), add = TRUE)
[15:31:04.311]         }
[15:31:04.311]         {
[15:31:04.311]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:04.311]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:04.311]                 ...future.FUN(...future.X_jj, ...)
[15:31:04.311]             })
[15:31:04.311]         }
[15:31:04.311]     }, args = future.call.arguments)
[15:31:04.311] }
[15:31:04.312] Tweak future expression to call with '...' arguments ... DONE
[15:31:04.312] - globals: [5] 'future.call.arguments', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:04.313] 
[15:31:04.313] getGlobalsAndPackages() ... DONE
[15:31:04.314] run() for 'Future' ...
[15:31:04.314] - state: 'created'
[15:31:04.314] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:31:04.315] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:04.315] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:31:04.315]   - Field: 'label'
[15:31:04.316]   - Field: 'local'
[15:31:04.316]   - Field: 'owner'
[15:31:04.316]   - Field: 'envir'
[15:31:04.317]   - Field: 'packages'
[15:31:04.317]   - Field: 'gc'
[15:31:04.317]   - Field: 'conditions'
[15:31:04.318]   - Field: 'expr'
[15:31:04.318]   - Field: 'uuid'
[15:31:04.318]   - Field: 'seed'
[15:31:04.318]   - Field: 'version'
[15:31:04.319]   - Field: 'result'
[15:31:04.319]   - Field: 'asynchronous'
[15:31:04.319]   - Field: 'calls'
[15:31:04.320]   - Field: 'globals'
[15:31:04.320]   - Field: 'stdout'
[15:31:04.320]   - Field: 'earlySignal'
[15:31:04.320]   - Field: 'lazy'
[15:31:04.321]   - Field: 'state'
[15:31:04.321] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:31:04.321] - Launch lazy future ...
[15:31:04.322] Packages needed by the future expression (n = 0): <none>
[15:31:04.322] Packages needed by future strategies (n = 0): <none>
[15:31:04.323] {
[15:31:04.323]     {
[15:31:04.323]         {
[15:31:04.323]             ...future.startTime <- base::Sys.time()
[15:31:04.323]             {
[15:31:04.323]                 {
[15:31:04.323]                   {
[15:31:04.323]                     base::local({
[15:31:04.323]                       has_future <- base::requireNamespace("future", 
[15:31:04.323]                         quietly = TRUE)
[15:31:04.323]                       if (has_future) {
[15:31:04.323]                         ns <- base::getNamespace("future")
[15:31:04.323]                         version <- ns[[".package"]][["version"]]
[15:31:04.323]                         if (is.null(version)) 
[15:31:04.323]                           version <- utils::packageVersion("future")
[15:31:04.323]                       }
[15:31:04.323]                       else {
[15:31:04.323]                         version <- NULL
[15:31:04.323]                       }
[15:31:04.323]                       if (!has_future || version < "1.8.0") {
[15:31:04.323]                         info <- base::c(r_version = base::gsub("R version ", 
[15:31:04.323]                           "", base::R.version$version.string), 
[15:31:04.323]                           platform = base::sprintf("%s (%s-bit)", 
[15:31:04.323]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:04.323]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:04.323]                             "release", "version")], collapse = " "), 
[15:31:04.323]                           hostname = base::Sys.info()[["nodename"]])
[15:31:04.323]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:31:04.323]                           info)
[15:31:04.323]                         info <- base::paste(info, collapse = "; ")
[15:31:04.323]                         if (!has_future) {
[15:31:04.323]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:04.323]                             info)
[15:31:04.323]                         }
[15:31:04.323]                         else {
[15:31:04.323]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:04.323]                             info, version)
[15:31:04.323]                         }
[15:31:04.323]                         base::stop(msg)
[15:31:04.323]                       }
[15:31:04.323]                     })
[15:31:04.323]                   }
[15:31:04.323]                   ...future.strategy.old <- future::plan("list")
[15:31:04.323]                   options(future.plan = NULL)
[15:31:04.323]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:04.323]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:04.323]                 }
[15:31:04.323]                 ...future.workdir <- getwd()
[15:31:04.323]             }
[15:31:04.323]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:04.323]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:04.323]         }
[15:31:04.323]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:04.323]             future.globals.maxSize = Inf, future.globals.method = NULL, 
[15:31:04.323]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:04.323]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:04.323]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:04.323]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:04.323]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:04.323]             base::names(...future.oldOptions))
[15:31:04.323]     }
[15:31:04.323]     if (FALSE) {
[15:31:04.323]     }
[15:31:04.323]     else {
[15:31:04.323]         if (TRUE) {
[15:31:04.323]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:04.323]                 open = "w")
[15:31:04.323]         }
[15:31:04.323]         else {
[15:31:04.323]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:04.323]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:04.323]         }
[15:31:04.323]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:04.323]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:04.323]             base::sink(type = "output", split = FALSE)
[15:31:04.323]             base::close(...future.stdout)
[15:31:04.323]         }, add = TRUE)
[15:31:04.323]     }
[15:31:04.323]     ...future.frame <- base::sys.nframe()
[15:31:04.323]     ...future.conditions <- base::list()
[15:31:04.323]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:04.323]     if (FALSE) {
[15:31:04.323]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:04.323]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:04.323]     }
[15:31:04.323]     ...future.result <- base::tryCatch({
[15:31:04.323]         base::withCallingHandlers({
[15:31:04.323]             ...future.value <- base::withVisible(base::local({
[15:31:04.323]                 do.call(function(...) {
[15:31:04.323]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:04.323]                   if (!identical(...future.globals.maxSize.org, 
[15:31:04.323]                     ...future.globals.maxSize)) {
[15:31:04.323]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:04.323]                     on.exit(options(oopts), add = TRUE)
[15:31:04.323]                   }
[15:31:04.323]                   {
[15:31:04.323]                     lapply(seq_along(...future.elements_ii), 
[15:31:04.323]                       FUN = function(jj) {
[15:31:04.323]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:04.323]                         ...future.FUN(...future.X_jj, ...)
[15:31:04.323]                       })
[15:31:04.323]                   }
[15:31:04.323]                 }, args = future.call.arguments)
[15:31:04.323]             }))
[15:31:04.323]             future::FutureResult(value = ...future.value$value, 
[15:31:04.323]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:04.323]                   ...future.rng), globalenv = if (FALSE) 
[15:31:04.323]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:04.323]                     ...future.globalenv.names))
[15:31:04.323]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:04.323]         }, condition = base::local({
[15:31:04.323]             c <- base::c
[15:31:04.323]             inherits <- base::inherits
[15:31:04.323]             invokeRestart <- base::invokeRestart
[15:31:04.323]             length <- base::length
[15:31:04.323]             list <- base::list
[15:31:04.323]             seq.int <- base::seq.int
[15:31:04.323]             signalCondition <- base::signalCondition
[15:31:04.323]             sys.calls <- base::sys.calls
[15:31:04.323]             `[[` <- base::`[[`
[15:31:04.323]             `+` <- base::`+`
[15:31:04.323]             `<<-` <- base::`<<-`
[15:31:04.323]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:04.323]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:04.323]                   3L)]
[15:31:04.323]             }
[15:31:04.323]             function(cond) {
[15:31:04.323]                 is_error <- inherits(cond, "error")
[15:31:04.323]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:04.323]                   NULL)
[15:31:04.323]                 if (is_error) {
[15:31:04.323]                   sessionInformation <- function() {
[15:31:04.323]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:04.323]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:04.323]                       search = base::search(), system = base::Sys.info())
[15:31:04.323]                   }
[15:31:04.323]                   ...future.conditions[[length(...future.conditions) + 
[15:31:04.323]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:04.323]                     cond$call), session = sessionInformation(), 
[15:31:04.323]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:04.323]                   signalCondition(cond)
[15:31:04.323]                 }
[15:31:04.323]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:04.323]                 "immediateCondition"))) {
[15:31:04.323]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:04.323]                   ...future.conditions[[length(...future.conditions) + 
[15:31:04.323]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:04.323]                   if (TRUE && !signal) {
[15:31:04.323]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:04.323]                     {
[15:31:04.323]                       inherits <- base::inherits
[15:31:04.323]                       invokeRestart <- base::invokeRestart
[15:31:04.323]                       is.null <- base::is.null
[15:31:04.323]                       muffled <- FALSE
[15:31:04.323]                       if (inherits(cond, "message")) {
[15:31:04.323]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:04.323]                         if (muffled) 
[15:31:04.323]                           invokeRestart("muffleMessage")
[15:31:04.323]                       }
[15:31:04.323]                       else if (inherits(cond, "warning")) {
[15:31:04.323]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:04.323]                         if (muffled) 
[15:31:04.323]                           invokeRestart("muffleWarning")
[15:31:04.323]                       }
[15:31:04.323]                       else if (inherits(cond, "condition")) {
[15:31:04.323]                         if (!is.null(pattern)) {
[15:31:04.323]                           computeRestarts <- base::computeRestarts
[15:31:04.323]                           grepl <- base::grepl
[15:31:04.323]                           restarts <- computeRestarts(cond)
[15:31:04.323]                           for (restart in restarts) {
[15:31:04.323]                             name <- restart$name
[15:31:04.323]                             if (is.null(name)) 
[15:31:04.323]                               next
[15:31:04.323]                             if (!grepl(pattern, name)) 
[15:31:04.323]                               next
[15:31:04.323]                             invokeRestart(restart)
[15:31:04.323]                             muffled <- TRUE
[15:31:04.323]                             break
[15:31:04.323]                           }
[15:31:04.323]                         }
[15:31:04.323]                       }
[15:31:04.323]                       invisible(muffled)
[15:31:04.323]                     }
[15:31:04.323]                     muffleCondition(cond, pattern = "^muffle")
[15:31:04.323]                   }
[15:31:04.323]                 }
[15:31:04.323]                 else {
[15:31:04.323]                   if (TRUE) {
[15:31:04.323]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:04.323]                     {
[15:31:04.323]                       inherits <- base::inherits
[15:31:04.323]                       invokeRestart <- base::invokeRestart
[15:31:04.323]                       is.null <- base::is.null
[15:31:04.323]                       muffled <- FALSE
[15:31:04.323]                       if (inherits(cond, "message")) {
[15:31:04.323]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:04.323]                         if (muffled) 
[15:31:04.323]                           invokeRestart("muffleMessage")
[15:31:04.323]                       }
[15:31:04.323]                       else if (inherits(cond, "warning")) {
[15:31:04.323]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:04.323]                         if (muffled) 
[15:31:04.323]                           invokeRestart("muffleWarning")
[15:31:04.323]                       }
[15:31:04.323]                       else if (inherits(cond, "condition")) {
[15:31:04.323]                         if (!is.null(pattern)) {
[15:31:04.323]                           computeRestarts <- base::computeRestarts
[15:31:04.323]                           grepl <- base::grepl
[15:31:04.323]                           restarts <- computeRestarts(cond)
[15:31:04.323]                           for (restart in restarts) {
[15:31:04.323]                             name <- restart$name
[15:31:04.323]                             if (is.null(name)) 
[15:31:04.323]                               next
[15:31:04.323]                             if (!grepl(pattern, name)) 
[15:31:04.323]                               next
[15:31:04.323]                             invokeRestart(restart)
[15:31:04.323]                             muffled <- TRUE
[15:31:04.323]                             break
[15:31:04.323]                           }
[15:31:04.323]                         }
[15:31:04.323]                       }
[15:31:04.323]                       invisible(muffled)
[15:31:04.323]                     }
[15:31:04.323]                     muffleCondition(cond, pattern = "^muffle")
[15:31:04.323]                   }
[15:31:04.323]                 }
[15:31:04.323]             }
[15:31:04.323]         }))
[15:31:04.323]     }, error = function(ex) {
[15:31:04.323]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:04.323]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:04.323]                 ...future.rng), started = ...future.startTime, 
[15:31:04.323]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:04.323]             version = "1.8"), class = "FutureResult")
[15:31:04.323]     }, finally = {
[15:31:04.323]         if (!identical(...future.workdir, getwd())) 
[15:31:04.323]             setwd(...future.workdir)
[15:31:04.323]         {
[15:31:04.323]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:04.323]                 ...future.oldOptions$nwarnings <- NULL
[15:31:04.323]             }
[15:31:04.323]             base::options(...future.oldOptions)
[15:31:04.323]             if (.Platform$OS.type == "windows") {
[15:31:04.323]                 old_names <- names(...future.oldEnvVars)
[15:31:04.323]                 envs <- base::Sys.getenv()
[15:31:04.323]                 names <- names(envs)
[15:31:04.323]                 common <- intersect(names, old_names)
[15:31:04.323]                 added <- setdiff(names, old_names)
[15:31:04.323]                 removed <- setdiff(old_names, names)
[15:31:04.323]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:04.323]                   envs[common]]
[15:31:04.323]                 NAMES <- toupper(changed)
[15:31:04.323]                 args <- list()
[15:31:04.323]                 for (kk in seq_along(NAMES)) {
[15:31:04.323]                   name <- changed[[kk]]
[15:31:04.323]                   NAME <- NAMES[[kk]]
[15:31:04.323]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:04.323]                     next
[15:31:04.323]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:04.323]                 }
[15:31:04.323]                 NAMES <- toupper(added)
[15:31:04.323]                 for (kk in seq_along(NAMES)) {
[15:31:04.323]                   name <- added[[kk]]
[15:31:04.323]                   NAME <- NAMES[[kk]]
[15:31:04.323]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:04.323]                     next
[15:31:04.323]                   args[[name]] <- ""
[15:31:04.323]                 }
[15:31:04.323]                 NAMES <- toupper(removed)
[15:31:04.323]                 for (kk in seq_along(NAMES)) {
[15:31:04.323]                   name <- removed[[kk]]
[15:31:04.323]                   NAME <- NAMES[[kk]]
[15:31:04.323]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:04.323]                     next
[15:31:04.323]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:04.323]                 }
[15:31:04.323]                 if (length(args) > 0) 
[15:31:04.323]                   base::do.call(base::Sys.setenv, args = args)
[15:31:04.323]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:04.323]             }
[15:31:04.323]             else {
[15:31:04.323]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:04.323]             }
[15:31:04.323]             {
[15:31:04.323]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:04.323]                   0L) {
[15:31:04.323]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:04.323]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:04.323]                   base::options(opts)
[15:31:04.323]                 }
[15:31:04.323]                 {
[15:31:04.323]                   {
[15:31:04.323]                     NULL
[15:31:04.323]                     RNGkind("Mersenne-Twister")
[15:31:04.323]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:31:04.323]                       inherits = FALSE)
[15:31:04.323]                   }
[15:31:04.323]                   options(future.plan = NULL)
[15:31:04.323]                   if (is.na(NA_character_)) 
[15:31:04.323]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:04.323]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:04.323]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:04.323]                     .init = FALSE)
[15:31:04.323]                 }
[15:31:04.323]             }
[15:31:04.323]         }
[15:31:04.323]     })
[15:31:04.323]     if (TRUE) {
[15:31:04.323]         base::sink(type = "output", split = FALSE)
[15:31:04.323]         if (TRUE) {
[15:31:04.323]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:04.323]         }
[15:31:04.323]         else {
[15:31:04.323]             ...future.result["stdout"] <- base::list(NULL)
[15:31:04.323]         }
[15:31:04.323]         base::close(...future.stdout)
[15:31:04.323]         ...future.stdout <- NULL
[15:31:04.323]     }
[15:31:04.323]     ...future.result$conditions <- ...future.conditions
[15:31:04.323]     ...future.result$finished <- base::Sys.time()
[15:31:04.323]     ...future.result
[15:31:04.323] }
[15:31:04.329] assign_globals() ...
[15:31:04.330] List of 5
[15:31:04.330]  $ future.call.arguments    : list()
[15:31:04.330]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:04.330]  $ ...future.FUN            :function (..., exclude = if (useNA == "no") c(NA, NaN), useNA = c("no", 
[15:31:04.330]     "ifany", "always"), dnn = list.names(...), deparse.level = 1)  
[15:31:04.330]  $ ...future.elements_ii    :List of 2
[15:31:04.330]   ..$ : num [1:4] 1 3 1 7
[15:31:04.330]   ..$ : num [1:4] 2 4 6 8
[15:31:04.330]  $ ...future.seeds_ii       : NULL
[15:31:04.330]  $ ...future.globals.maxSize: num Inf
[15:31:04.330]  - attr(*, "resolved")= logi FALSE
[15:31:04.330]  - attr(*, "total_size")= num NA
[15:31:04.330]  - attr(*, "where")=List of 5
[15:31:04.330]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:31:04.330]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:31:04.330]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:31:04.330]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:31:04.330]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:31:04.330]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:04.330]  - attr(*, "already-done")= logi TRUE
[15:31:04.343] - copied 'future.call.arguments' to environment
[15:31:04.343] - copied '...future.FUN' to environment
[15:31:04.344] - copied '...future.elements_ii' to environment
[15:31:04.344] - copied '...future.seeds_ii' to environment
[15:31:04.344] - copied '...future.globals.maxSize' to environment
[15:31:04.344] assign_globals() ... done
[15:31:04.345] plan(): Setting new future strategy stack:
[15:31:04.345] List of future strategies:
[15:31:04.345] 1. sequential:
[15:31:04.345]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:04.345]    - tweaked: FALSE
[15:31:04.345]    - call: NULL
[15:31:04.346] plan(): nbrOfWorkers() = 1
[15:31:04.351] plan(): Setting new future strategy stack:
[15:31:04.352] List of future strategies:
[15:31:04.352] 1. sequential:
[15:31:04.352]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:04.352]    - tweaked: FALSE
[15:31:04.352]    - call: plan(strategy)
[15:31:04.353] plan(): nbrOfWorkers() = 1
[15:31:04.353] SequentialFuture started (and completed)
[15:31:04.354] - Launch lazy future ... done
[15:31:04.354] run() for 'SequentialFuture' ... done
[15:31:04.354] Created future:
[15:31:04.355] SequentialFuture:
[15:31:04.355] Label: 'future_apply-1'
[15:31:04.355] Expression:
[15:31:04.355] {
[15:31:04.355]     do.call(function(...) {
[15:31:04.355]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:04.355]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:04.355]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:04.355]             on.exit(options(oopts), add = TRUE)
[15:31:04.355]         }
[15:31:04.355]         {
[15:31:04.355]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:04.355]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:04.355]                 ...future.FUN(...future.X_jj, ...)
[15:31:04.355]             })
[15:31:04.355]         }
[15:31:04.355]     }, args = future.call.arguments)
[15:31:04.355] }
[15:31:04.355] Lazy evaluation: FALSE
[15:31:04.355] Asynchronous evaluation: FALSE
[15:31:04.355] Local evaluation: TRUE
[15:31:04.355] Environment: R_GlobalEnv
[15:31:04.355] Capture standard output: TRUE
[15:31:04.355] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:04.355] Globals: 5 objects totaling 346.13 KiB (DotDotDotList 'future.call.arguments' of 0 bytes, function '...future.FUN' of 345.92 KiB, list '...future.elements_ii' of 160 bytes, NULL '...future.seeds_ii' of 0 bytes, numeric '...future.globals.maxSize' of 56 bytes)
[15:31:04.355] Packages: <none>
[15:31:04.355] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:04.355] Resolved: TRUE
[15:31:04.355] Value: 2.21 KiB of class 'list'
[15:31:04.355] Early signaling: FALSE
[15:31:04.355] Owner process: 6672a580-6d3c-e82f-380e-108c475ace70
[15:31:04.355] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:04.357] Chunk #1 of 1 ... DONE
[15:31:04.357] Launching 1 futures (chunks) ... DONE
[15:31:04.358] Resolving 1 futures (chunks) ...
[15:31:04.358] resolve() on list ...
[15:31:04.358]  recursive: 0
[15:31:04.359]  length: 1
[15:31:04.359] 
[15:31:04.359] resolved() for 'SequentialFuture' ...
[15:31:04.359] - state: 'finished'
[15:31:04.359] - run: TRUE
[15:31:04.360] - result: 'FutureResult'
[15:31:04.360] resolved() for 'SequentialFuture' ... done
[15:31:04.360] Future #1
[15:31:04.360] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:31:04.361] - nx: 1
[15:31:04.361] - relay: TRUE
[15:31:04.361] - stdout: TRUE
[15:31:04.361] - signal: TRUE
[15:31:04.362] - resignal: FALSE
[15:31:04.362] - force: TRUE
[15:31:04.362] - relayed: [n=1] FALSE
[15:31:04.362] - queued futures: [n=1] FALSE
[15:31:04.363]  - until=1
[15:31:04.363]  - relaying element #1
[15:31:04.364] - relayed: [n=1] TRUE
[15:31:04.364] - queued futures: [n=1] TRUE
[15:31:04.364] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:31:04.364]  length: 0 (resolved future 1)
[15:31:04.364] Relaying remaining futures
[15:31:04.364] signalConditionsASAP(NULL, pos=0) ...
[15:31:04.365] - nx: 1
[15:31:04.365] - relay: TRUE
[15:31:04.365] - stdout: TRUE
[15:31:04.365] - signal: TRUE
[15:31:04.365] - resignal: FALSE
[15:31:04.365] - force: TRUE
[15:31:04.366] - relayed: [n=1] TRUE
[15:31:04.366] - queued futures: [n=1] TRUE
 - flush all
[15:31:04.366] - relayed: [n=1] TRUE
[15:31:04.366] - queued futures: [n=1] TRUE
[15:31:04.366] signalConditionsASAP(NULL, pos=0) ... done
[15:31:04.367] resolve() on list ... DONE
[15:31:04.367]  - Number of value chunks collected: 1
[15:31:04.367] Resolving 1 futures (chunks) ... DONE
[15:31:04.368] Reducing values from 1 chunks ...
[15:31:04.368]  - Number of values collected after concatenation: 2
[15:31:04.368]  - Number of values expected: 2
[15:31:04.368] Reducing values from 1 chunks ... DONE
[15:31:04.369] future_lapply() ... DONE
[[1]]
...future.X_jj
1 3 7 
2 1 1 

[[2]]
...future.X_jj
2 4 6 8 
1 1 1 1 

[15:31:04.372] getGlobalsAndPackagesXApply() ...
[15:31:04.373]  - future.globals: TRUE
[15:31:04.373] getGlobalsAndPackages() ...
[15:31:04.373] Searching for globals...
[15:31:04.379] - globals found: [2] 'FUN', 'UseMethod'
[15:31:04.379] Searching for globals ... DONE
[15:31:04.379] Resolving globals: FALSE
[15:31:04.380] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:31:04.381] The total size of the 1 globals exported for future expression ('FUN(X = structure(c(1, 2, 3, 4, 1, 6, 7, 8), dim = c(2L, 4L)))') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:31:04.381] - globals: [1] 'FUN'
[15:31:04.381] - packages: [1] 'stats'
[15:31:04.382] getGlobalsAndPackages() ... DONE
[15:31:04.382]  - globals found/used: [n=1] 'FUN'
[15:31:04.382]  - needed namespaces: [n=1] 'stats'
[15:31:04.382] Finding globals ... DONE
[15:31:04.383]  - use_args: TRUE
[15:31:04.383]  - Getting '...' globals ...
[15:31:04.384] resolve() on list ...
[15:31:04.384]  recursive: 0
[15:31:04.384]  length: 1
[15:31:04.384]  elements: '...'
[15:31:04.385]  length: 0 (resolved future 1)
[15:31:04.385] resolve() on list ... DONE
[15:31:04.385]    - '...' content: [n=0] 
[15:31:04.385] List of 1
[15:31:04.385]  $ ...: list()
[15:31:04.385]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:04.385]  - attr(*, "where")=List of 1
[15:31:04.385]   ..$ ...:<environment: 0x000001bcbb6a0998> 
[15:31:04.385]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:04.385]  - attr(*, "resolved")= logi TRUE
[15:31:04.385]  - attr(*, "total_size")= num NA
[15:31:04.389]  - Getting '...' globals ... DONE
[15:31:04.390] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:04.390] List of 2
[15:31:04.390]  $ ...future.FUN:function (x, ...)  
[15:31:04.390]  $ ...          : list()
[15:31:04.390]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:04.390]  - attr(*, "where")=List of 2
[15:31:04.390]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:04.390]   ..$ ...          :<environment: 0x000001bcbb6a0998> 
[15:31:04.390]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:04.390]  - attr(*, "resolved")= logi FALSE
[15:31:04.390]  - attr(*, "total_size")= num 1248
[15:31:04.395] Packages to be attached in all futures: [n=1] 'stats'
[15:31:04.395] getGlobalsAndPackagesXApply() ... DONE
[15:31:04.396] future_lapply() ...
[15:31:04.397] Number of chunks: 1
[15:31:04.397] getGlobalsAndPackagesXApply() ...
[15:31:04.398]  - future.globals: <name-value list> with names 'list()'
[15:31:04.398]  - use_args: TRUE
[15:31:04.398] Globals to be used in all futures (chunks): [n=2] '...', '...future.FUN'
[15:31:04.399] List of 2
[15:31:04.399]  $ ...          : list()
[15:31:04.399]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:04.399]  $ ...future.FUN:function (x, ...)  
[15:31:04.399]  - attr(*, "where")=List of 2
[15:31:04.399]   ..$ ...          :<environment: 0x000001bcbb6a0998> 
[15:31:04.399]   ..$ ...future.FUN:<environment: namespace:stats> 
[15:31:04.399]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:04.399]  - attr(*, "resolved")= logi FALSE
[15:31:04.399]  - attr(*, "total_size")= num NA
[15:31:04.404] Packages to be attached in all futures: [n=1] 'stats'
[15:31:04.404] getGlobalsAndPackagesXApply() ... DONE
[15:31:04.405] Number of futures (= number of chunks): 1
[15:31:04.405] Launching 1 futures (chunks) ...
[15:31:04.405] Chunk #1 of 1 ...
[15:31:04.405]  - seeds: <none>
[15:31:04.406]  - All globals exported: [n=5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:04.406] getGlobalsAndPackages() ...
[15:31:04.406] - globals passed as-is: [5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:04.406] Resolving globals: FALSE
[15:31:04.407] Tweak future expression to call with '...' arguments ...
[15:31:04.407] {
[15:31:04.407]     do.call(function(...) {
[15:31:04.407]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:04.407]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:04.407]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:04.407]             on.exit(options(oopts), add = TRUE)
[15:31:04.407]         }
[15:31:04.407]         {
[15:31:04.407]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:04.407]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:04.407]                 ...future.FUN(...future.X_jj, ...)
[15:31:04.407]             })
[15:31:04.407]         }
[15:31:04.407]     }, args = future.call.arguments)
[15:31:04.407] }
[15:31:04.408] Tweak future expression to call with '...' arguments ... DONE
[15:31:04.409] - globals: [5] 'future.call.arguments', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:04.409] - packages: [1] 'stats'
[15:31:04.409] getGlobalsAndPackages() ... DONE
[15:31:04.410] run() for 'Future' ...
[15:31:04.410] - state: 'created'
[15:31:04.410] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:31:04.411] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:04.411] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:31:04.411]   - Field: 'label'
[15:31:04.412]   - Field: 'local'
[15:31:04.412]   - Field: 'owner'
[15:31:04.412]   - Field: 'envir'
[15:31:04.415]   - Field: 'packages'
[15:31:04.415]   - Field: 'gc'
[15:31:04.416]   - Field: 'conditions'
[15:31:04.416]   - Field: 'expr'
[15:31:04.416]   - Field: 'uuid'
[15:31:04.416]   - Field: 'seed'
[15:31:04.417]   - Field: 'version'
[15:31:04.417]   - Field: 'result'
[15:31:04.417]   - Field: 'asynchronous'
[15:31:04.417]   - Field: 'calls'
[15:31:04.418]   - Field: 'globals'
[15:31:04.418]   - Field: 'stdout'
[15:31:04.418]   - Field: 'earlySignal'
[15:31:04.418]   - Field: 'lazy'
[15:31:04.419]   - Field: 'state'
[15:31:04.419] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:31:04.419] - Launch lazy future ...
[15:31:04.419] Packages needed by the future expression (n = 1): 'stats'
[15:31:04.420] Packages needed by future strategies (n = 0): <none>
[15:31:04.421] {
[15:31:04.421]     {
[15:31:04.421]         {
[15:31:04.421]             ...future.startTime <- base::Sys.time()
[15:31:04.421]             {
[15:31:04.421]                 {
[15:31:04.421]                   {
[15:31:04.421]                     {
[15:31:04.421]                       base::local({
[15:31:04.421]                         has_future <- base::requireNamespace("future", 
[15:31:04.421]                           quietly = TRUE)
[15:31:04.421]                         if (has_future) {
[15:31:04.421]                           ns <- base::getNamespace("future")
[15:31:04.421]                           version <- ns[[".package"]][["version"]]
[15:31:04.421]                           if (is.null(version)) 
[15:31:04.421]                             version <- utils::packageVersion("future")
[15:31:04.421]                         }
[15:31:04.421]                         else {
[15:31:04.421]                           version <- NULL
[15:31:04.421]                         }
[15:31:04.421]                         if (!has_future || version < "1.8.0") {
[15:31:04.421]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:04.421]                             "", base::R.version$version.string), 
[15:31:04.421]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:04.421]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:04.421]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:04.421]                               "release", "version")], collapse = " "), 
[15:31:04.421]                             hostname = base::Sys.info()[["nodename"]])
[15:31:04.421]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:04.421]                             info)
[15:31:04.421]                           info <- base::paste(info, collapse = "; ")
[15:31:04.421]                           if (!has_future) {
[15:31:04.421]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:04.421]                               info)
[15:31:04.421]                           }
[15:31:04.421]                           else {
[15:31:04.421]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:04.421]                               info, version)
[15:31:04.421]                           }
[15:31:04.421]                           base::stop(msg)
[15:31:04.421]                         }
[15:31:04.421]                       })
[15:31:04.421]                     }
[15:31:04.421]                     base::local({
[15:31:04.421]                       for (pkg in "stats") {
[15:31:04.421]                         base::loadNamespace(pkg)
[15:31:04.421]                         base::library(pkg, character.only = TRUE)
[15:31:04.421]                       }
[15:31:04.421]                     })
[15:31:04.421]                   }
[15:31:04.421]                   ...future.strategy.old <- future::plan("list")
[15:31:04.421]                   options(future.plan = NULL)
[15:31:04.421]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:04.421]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:04.421]                 }
[15:31:04.421]                 ...future.workdir <- getwd()
[15:31:04.421]             }
[15:31:04.421]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:04.421]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:04.421]         }
[15:31:04.421]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:04.421]             future.globals.maxSize = Inf, future.globals.method = NULL, 
[15:31:04.421]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:04.421]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:04.421]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:04.421]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:04.421]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:04.421]             base::names(...future.oldOptions))
[15:31:04.421]     }
[15:31:04.421]     if (FALSE) {
[15:31:04.421]     }
[15:31:04.421]     else {
[15:31:04.421]         if (TRUE) {
[15:31:04.421]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:04.421]                 open = "w")
[15:31:04.421]         }
[15:31:04.421]         else {
[15:31:04.421]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:04.421]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:04.421]         }
[15:31:04.421]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:04.421]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:04.421]             base::sink(type = "output", split = FALSE)
[15:31:04.421]             base::close(...future.stdout)
[15:31:04.421]         }, add = TRUE)
[15:31:04.421]     }
[15:31:04.421]     ...future.frame <- base::sys.nframe()
[15:31:04.421]     ...future.conditions <- base::list()
[15:31:04.421]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:04.421]     if (FALSE) {
[15:31:04.421]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:04.421]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:04.421]     }
[15:31:04.421]     ...future.result <- base::tryCatch({
[15:31:04.421]         base::withCallingHandlers({
[15:31:04.421]             ...future.value <- base::withVisible(base::local({
[15:31:04.421]                 do.call(function(...) {
[15:31:04.421]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:04.421]                   if (!identical(...future.globals.maxSize.org, 
[15:31:04.421]                     ...future.globals.maxSize)) {
[15:31:04.421]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:04.421]                     on.exit(options(oopts), add = TRUE)
[15:31:04.421]                   }
[15:31:04.421]                   {
[15:31:04.421]                     lapply(seq_along(...future.elements_ii), 
[15:31:04.421]                       FUN = function(jj) {
[15:31:04.421]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:04.421]                         ...future.FUN(...future.X_jj, ...)
[15:31:04.421]                       })
[15:31:04.421]                   }
[15:31:04.421]                 }, args = future.call.arguments)
[15:31:04.421]             }))
[15:31:04.421]             future::FutureResult(value = ...future.value$value, 
[15:31:04.421]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:04.421]                   ...future.rng), globalenv = if (FALSE) 
[15:31:04.421]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:04.421]                     ...future.globalenv.names))
[15:31:04.421]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:04.421]         }, condition = base::local({
[15:31:04.421]             c <- base::c
[15:31:04.421]             inherits <- base::inherits
[15:31:04.421]             invokeRestart <- base::invokeRestart
[15:31:04.421]             length <- base::length
[15:31:04.421]             list <- base::list
[15:31:04.421]             seq.int <- base::seq.int
[15:31:04.421]             signalCondition <- base::signalCondition
[15:31:04.421]             sys.calls <- base::sys.calls
[15:31:04.421]             `[[` <- base::`[[`
[15:31:04.421]             `+` <- base::`+`
[15:31:04.421]             `<<-` <- base::`<<-`
[15:31:04.421]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:04.421]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:04.421]                   3L)]
[15:31:04.421]             }
[15:31:04.421]             function(cond) {
[15:31:04.421]                 is_error <- inherits(cond, "error")
[15:31:04.421]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:04.421]                   NULL)
[15:31:04.421]                 if (is_error) {
[15:31:04.421]                   sessionInformation <- function() {
[15:31:04.421]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:04.421]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:04.421]                       search = base::search(), system = base::Sys.info())
[15:31:04.421]                   }
[15:31:04.421]                   ...future.conditions[[length(...future.conditions) + 
[15:31:04.421]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:04.421]                     cond$call), session = sessionInformation(), 
[15:31:04.421]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:04.421]                   signalCondition(cond)
[15:31:04.421]                 }
[15:31:04.421]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:04.421]                 "immediateCondition"))) {
[15:31:04.421]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:04.421]                   ...future.conditions[[length(...future.conditions) + 
[15:31:04.421]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:04.421]                   if (TRUE && !signal) {
[15:31:04.421]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:04.421]                     {
[15:31:04.421]                       inherits <- base::inherits
[15:31:04.421]                       invokeRestart <- base::invokeRestart
[15:31:04.421]                       is.null <- base::is.null
[15:31:04.421]                       muffled <- FALSE
[15:31:04.421]                       if (inherits(cond, "message")) {
[15:31:04.421]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:04.421]                         if (muffled) 
[15:31:04.421]                           invokeRestart("muffleMessage")
[15:31:04.421]                       }
[15:31:04.421]                       else if (inherits(cond, "warning")) {
[15:31:04.421]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:04.421]                         if (muffled) 
[15:31:04.421]                           invokeRestart("muffleWarning")
[15:31:04.421]                       }
[15:31:04.421]                       else if (inherits(cond, "condition")) {
[15:31:04.421]                         if (!is.null(pattern)) {
[15:31:04.421]                           computeRestarts <- base::computeRestarts
[15:31:04.421]                           grepl <- base::grepl
[15:31:04.421]                           restarts <- computeRestarts(cond)
[15:31:04.421]                           for (restart in restarts) {
[15:31:04.421]                             name <- restart$name
[15:31:04.421]                             if (is.null(name)) 
[15:31:04.421]                               next
[15:31:04.421]                             if (!grepl(pattern, name)) 
[15:31:04.421]                               next
[15:31:04.421]                             invokeRestart(restart)
[15:31:04.421]                             muffled <- TRUE
[15:31:04.421]                             break
[15:31:04.421]                           }
[15:31:04.421]                         }
[15:31:04.421]                       }
[15:31:04.421]                       invisible(muffled)
[15:31:04.421]                     }
[15:31:04.421]                     muffleCondition(cond, pattern = "^muffle")
[15:31:04.421]                   }
[15:31:04.421]                 }
[15:31:04.421]                 else {
[15:31:04.421]                   if (TRUE) {
[15:31:04.421]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:04.421]                     {
[15:31:04.421]                       inherits <- base::inherits
[15:31:04.421]                       invokeRestart <- base::invokeRestart
[15:31:04.421]                       is.null <- base::is.null
[15:31:04.421]                       muffled <- FALSE
[15:31:04.421]                       if (inherits(cond, "message")) {
[15:31:04.421]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:04.421]                         if (muffled) 
[15:31:04.421]                           invokeRestart("muffleMessage")
[15:31:04.421]                       }
[15:31:04.421]                       else if (inherits(cond, "warning")) {
[15:31:04.421]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:04.421]                         if (muffled) 
[15:31:04.421]                           invokeRestart("muffleWarning")
[15:31:04.421]                       }
[15:31:04.421]                       else if (inherits(cond, "condition")) {
[15:31:04.421]                         if (!is.null(pattern)) {
[15:31:04.421]                           computeRestarts <- base::computeRestarts
[15:31:04.421]                           grepl <- base::grepl
[15:31:04.421]                           restarts <- computeRestarts(cond)
[15:31:04.421]                           for (restart in restarts) {
[15:31:04.421]                             name <- restart$name
[15:31:04.421]                             if (is.null(name)) 
[15:31:04.421]                               next
[15:31:04.421]                             if (!grepl(pattern, name)) 
[15:31:04.421]                               next
[15:31:04.421]                             invokeRestart(restart)
[15:31:04.421]                             muffled <- TRUE
[15:31:04.421]                             break
[15:31:04.421]                           }
[15:31:04.421]                         }
[15:31:04.421]                       }
[15:31:04.421]                       invisible(muffled)
[15:31:04.421]                     }
[15:31:04.421]                     muffleCondition(cond, pattern = "^muffle")
[15:31:04.421]                   }
[15:31:04.421]                 }
[15:31:04.421]             }
[15:31:04.421]         }))
[15:31:04.421]     }, error = function(ex) {
[15:31:04.421]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:04.421]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:04.421]                 ...future.rng), started = ...future.startTime, 
[15:31:04.421]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:04.421]             version = "1.8"), class = "FutureResult")
[15:31:04.421]     }, finally = {
[15:31:04.421]         if (!identical(...future.workdir, getwd())) 
[15:31:04.421]             setwd(...future.workdir)
[15:31:04.421]         {
[15:31:04.421]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:04.421]                 ...future.oldOptions$nwarnings <- NULL
[15:31:04.421]             }
[15:31:04.421]             base::options(...future.oldOptions)
[15:31:04.421]             if (.Platform$OS.type == "windows") {
[15:31:04.421]                 old_names <- names(...future.oldEnvVars)
[15:31:04.421]                 envs <- base::Sys.getenv()
[15:31:04.421]                 names <- names(envs)
[15:31:04.421]                 common <- intersect(names, old_names)
[15:31:04.421]                 added <- setdiff(names, old_names)
[15:31:04.421]                 removed <- setdiff(old_names, names)
[15:31:04.421]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:04.421]                   envs[common]]
[15:31:04.421]                 NAMES <- toupper(changed)
[15:31:04.421]                 args <- list()
[15:31:04.421]                 for (kk in seq_along(NAMES)) {
[15:31:04.421]                   name <- changed[[kk]]
[15:31:04.421]                   NAME <- NAMES[[kk]]
[15:31:04.421]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:04.421]                     next
[15:31:04.421]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:04.421]                 }
[15:31:04.421]                 NAMES <- toupper(added)
[15:31:04.421]                 for (kk in seq_along(NAMES)) {
[15:31:04.421]                   name <- added[[kk]]
[15:31:04.421]                   NAME <- NAMES[[kk]]
[15:31:04.421]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:04.421]                     next
[15:31:04.421]                   args[[name]] <- ""
[15:31:04.421]                 }
[15:31:04.421]                 NAMES <- toupper(removed)
[15:31:04.421]                 for (kk in seq_along(NAMES)) {
[15:31:04.421]                   name <- removed[[kk]]
[15:31:04.421]                   NAME <- NAMES[[kk]]
[15:31:04.421]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:04.421]                     next
[15:31:04.421]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:04.421]                 }
[15:31:04.421]                 if (length(args) > 0) 
[15:31:04.421]                   base::do.call(base::Sys.setenv, args = args)
[15:31:04.421]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:04.421]             }
[15:31:04.421]             else {
[15:31:04.421]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:04.421]             }
[15:31:04.421]             {
[15:31:04.421]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:04.421]                   0L) {
[15:31:04.421]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:04.421]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:04.421]                   base::options(opts)
[15:31:04.421]                 }
[15:31:04.421]                 {
[15:31:04.421]                   {
[15:31:04.421]                     NULL
[15:31:04.421]                     RNGkind("Mersenne-Twister")
[15:31:04.421]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:31:04.421]                       inherits = FALSE)
[15:31:04.421]                   }
[15:31:04.421]                   options(future.plan = NULL)
[15:31:04.421]                   if (is.na(NA_character_)) 
[15:31:04.421]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:04.421]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:04.421]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:04.421]                     .init = FALSE)
[15:31:04.421]                 }
[15:31:04.421]             }
[15:31:04.421]         }
[15:31:04.421]     })
[15:31:04.421]     if (TRUE) {
[15:31:04.421]         base::sink(type = "output", split = FALSE)
[15:31:04.421]         if (TRUE) {
[15:31:04.421]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:04.421]         }
[15:31:04.421]         else {
[15:31:04.421]             ...future.result["stdout"] <- base::list(NULL)
[15:31:04.421]         }
[15:31:04.421]         base::close(...future.stdout)
[15:31:04.421]         ...future.stdout <- NULL
[15:31:04.421]     }
[15:31:04.421]     ...future.result$conditions <- ...future.conditions
[15:31:04.421]     ...future.result$finished <- base::Sys.time()
[15:31:04.421]     ...future.result
[15:31:04.421] }
[15:31:04.427] assign_globals() ...
[15:31:04.427] List of 5
[15:31:04.427]  $ future.call.arguments    : list()
[15:31:04.427]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:04.427]  $ ...future.FUN            :function (x, ...)  
[15:31:04.427]  $ ...future.elements_ii    :List of 2
[15:31:04.427]   ..$ : num [1:4] 1 3 1 7
[15:31:04.427]   ..$ : num [1:4] 2 4 6 8
[15:31:04.427]  $ ...future.seeds_ii       : NULL
[15:31:04.427]  $ ...future.globals.maxSize: num Inf
[15:31:04.427]  - attr(*, "resolved")= logi FALSE
[15:31:04.427]  - attr(*, "total_size")= num NA
[15:31:04.427]  - attr(*, "where")=List of 5
[15:31:04.427]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:31:04.427]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:31:04.427]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:31:04.427]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:31:04.427]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:31:04.427]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:04.427]  - attr(*, "already-done")= logi TRUE
[15:31:04.437] - copied 'future.call.arguments' to environment
[15:31:04.438] - copied '...future.FUN' to environment
[15:31:04.438] - copied '...future.elements_ii' to environment
[15:31:04.438] - copied '...future.seeds_ii' to environment
[15:31:04.439] - copied '...future.globals.maxSize' to environment
[15:31:04.439] assign_globals() ... done
[15:31:04.440] plan(): Setting new future strategy stack:
[15:31:04.440] List of future strategies:
[15:31:04.440] 1. sequential:
[15:31:04.440]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:04.440]    - tweaked: FALSE
[15:31:04.440]    - call: NULL
[15:31:04.441] plan(): nbrOfWorkers() = 1
[15:31:04.444] plan(): Setting new future strategy stack:
[15:31:04.444] List of future strategies:
[15:31:04.444] 1. sequential:
[15:31:04.444]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:04.444]    - tweaked: FALSE
[15:31:04.444]    - call: plan(strategy)
[15:31:04.445] plan(): nbrOfWorkers() = 1
[15:31:04.445] SequentialFuture started (and completed)
[15:31:04.446] - Launch lazy future ... done
[15:31:04.446] run() for 'SequentialFuture' ... done
[15:31:04.446] Created future:
[15:31:04.447] SequentialFuture:
[15:31:04.447] Label: 'future_apply-1'
[15:31:04.447] Expression:
[15:31:04.447] {
[15:31:04.447]     do.call(function(...) {
[15:31:04.447]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:04.447]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:04.447]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:04.447]             on.exit(options(oopts), add = TRUE)
[15:31:04.447]         }
[15:31:04.447]         {
[15:31:04.447]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:04.447]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:04.447]                 ...future.FUN(...future.X_jj, ...)
[15:31:04.447]             })
[15:31:04.447]         }
[15:31:04.447]     }, args = future.call.arguments)
[15:31:04.447] }
[15:31:04.447] Lazy evaluation: FALSE
[15:31:04.447] Asynchronous evaluation: FALSE
[15:31:04.447] Local evaluation: TRUE
[15:31:04.447] Environment: R_GlobalEnv
[15:31:04.447] Capture standard output: TRUE
[15:31:04.447] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:04.447] Globals: 5 objects totaling 1.43 KiB (DotDotDotList 'future.call.arguments' of 0 bytes, function '...future.FUN' of 1.22 KiB, list '...future.elements_ii' of 160 bytes, NULL '...future.seeds_ii' of 0 bytes, numeric '...future.globals.maxSize' of 56 bytes)
[15:31:04.447] Packages: 1 packages ('stats')
[15:31:04.447] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:04.447] Resolved: TRUE
[15:31:04.447] Value: 1.14 KiB of class 'list'
[15:31:04.447] Early signaling: FALSE
[15:31:04.447] Owner process: 6672a580-6d3c-e82f-380e-108c475ace70
[15:31:04.447] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:04.449] Chunk #1 of 1 ... DONE
[15:31:04.449] Launching 1 futures (chunks) ... DONE
[15:31:04.450] Resolving 1 futures (chunks) ...
[15:31:04.450] resolve() on list ...
[15:31:04.450]  recursive: 0
[15:31:04.451]  length: 1
[15:31:04.451] 
[15:31:04.451] resolved() for 'SequentialFuture' ...
[15:31:04.451] - state: 'finished'
[15:31:04.452] - run: TRUE
[15:31:04.452] - result: 'FutureResult'
[15:31:04.452] resolved() for 'SequentialFuture' ... done
[15:31:04.453] Future #1
[15:31:04.453] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:31:04.454] - nx: 1
[15:31:04.454] - relay: TRUE
[15:31:04.454] - stdout: TRUE
[15:31:04.454] - signal: TRUE
[15:31:04.455] - resignal: FALSE
[15:31:04.455] - force: TRUE
[15:31:04.455] - relayed: [n=1] FALSE
[15:31:04.455] - queued futures: [n=1] FALSE
[15:31:04.456]  - until=1
[15:31:04.456]  - relaying element #1
[15:31:04.457] - relayed: [n=1] TRUE
[15:31:04.457] - queued futures: [n=1] TRUE
[15:31:04.457] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:31:04.457]  length: 0 (resolved future 1)
[15:31:04.458] Relaying remaining futures
[15:31:04.458] signalConditionsASAP(NULL, pos=0) ...
[15:31:04.458] - nx: 1
[15:31:04.459] - relay: TRUE
[15:31:04.459] - stdout: TRUE
[15:31:04.459] - signal: TRUE
[15:31:04.459] - resignal: FALSE
[15:31:04.462] - force: TRUE
[15:31:04.463] - relayed: [n=1] TRUE
[15:31:04.463] - queued futures: [n=1] TRUE
 - flush all
[15:31:04.463] - relayed: [n=1] TRUE
[15:31:04.464] - queued futures: [n=1] TRUE
[15:31:04.464] signalConditionsASAP(NULL, pos=0) ... done
[15:31:04.464] resolve() on list ... DONE
[15:31:04.464]  - Number of value chunks collected: 1
[15:31:04.465] Resolving 1 futures (chunks) ... DONE
[15:31:04.465] Reducing values from 1 chunks ...
[15:31:04.465]  - Number of values collected after concatenation: 2
[15:31:04.465]  - Number of values expected: 2
[15:31:04.466] Reducing values from 1 chunks ... DONE
[15:31:04.466] future_lapply() ... DONE
     [,1] [,2]
0%      1  2.0
25%     1  3.5
50%     2  5.0
75%     4  6.5
100%    7  8.0
[15:31:04.467] getGlobalsAndPackagesXApply() ...
[15:31:04.468]  - future.globals: TRUE
[15:31:04.468] getGlobalsAndPackages() ...
[15:31:04.468] Searching for globals...
[15:31:04.470] - globals found: [1] 'FUN'
[15:31:04.470] Searching for globals ... DONE
[15:31:04.471] Resolving globals: FALSE
[15:31:04.471] The total size of the 1 globals is 848 bytes (848 bytes)
[15:31:04.472] The total size of the 1 globals exported for future expression ('FUN(X = structure(c(3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 2, 1, 2, 3,; 4, 5), dim = c(8L, 2L), dimnames = list(row = NULL, col = c("x1",; "x2"))))') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:31:04.472] - globals: [1] 'FUN'
[15:31:04.473] 
[15:31:04.473] getGlobalsAndPackages() ... DONE
[15:31:04.473]  - globals found/used: [n=1] 'FUN'
[15:31:04.474]  - needed namespaces: [n=0] 
[15:31:04.474] Finding globals ... DONE
[15:31:04.474]  - use_args: TRUE
[15:31:04.474]  - Getting '...' globals ...
[15:31:04.475] resolve() on list ...
[15:31:04.475]  recursive: 0
[15:31:04.476]  length: 1
[15:31:04.476]  elements: '...'
[15:31:04.476]  length: 0 (resolved future 1)
[15:31:04.477] resolve() on list ... DONE
[15:31:04.477]    - '...' content: [n=0] 
[15:31:04.477] List of 1
[15:31:04.477]  $ ...: list()
[15:31:04.477]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:04.477]  - attr(*, "where")=List of 1
[15:31:04.477]   ..$ ...:<environment: 0x000001bcb90b6228> 
[15:31:04.477]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:04.477]  - attr(*, "resolved")= logi TRUE
[15:31:04.477]  - attr(*, "total_size")= num NA
[15:31:04.482]  - Getting '...' globals ... DONE
[15:31:04.483] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:04.483] List of 2
[15:31:04.483]  $ ...future.FUN:function (x)  
[15:31:04.483]  $ ...          : list()
[15:31:04.483]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:04.483]  - attr(*, "where")=List of 2
[15:31:04.483]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:04.483]   ..$ ...          :<environment: 0x000001bcb90b6228> 
[15:31:04.483]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:04.483]  - attr(*, "resolved")= logi FALSE
[15:31:04.483]  - attr(*, "total_size")= num 848
[15:31:04.488] Packages to be attached in all futures: [n=0] 
[15:31:04.489] getGlobalsAndPackagesXApply() ... DONE
[15:31:04.489] future_lapply() ...
[15:31:04.490] Number of chunks: 1
[15:31:04.490] getGlobalsAndPackagesXApply() ...
[15:31:04.491]  - future.globals: <name-value list> with names 'list()'
[15:31:04.491]  - use_args: TRUE
[15:31:04.491] Globals to be used in all futures (chunks): [n=2] '...', '...future.FUN'
[15:31:04.492] List of 2
[15:31:04.492]  $ ...          : list()
[15:31:04.492]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:04.492]  $ ...future.FUN:function (x)  
[15:31:04.492]  - attr(*, "where")=List of 2
[15:31:04.492]   ..$ ...          :<environment: 0x000001bcb90b6228> 
[15:31:04.492]   ..$ ...future.FUN:<environment: namespace:base> 
[15:31:04.492]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:04.492]  - attr(*, "resolved")= logi FALSE
[15:31:04.492]  - attr(*, "total_size")= num NA
[15:31:04.536] Packages to be attached in all futures: [n=0] 
[15:31:04.536] getGlobalsAndPackagesXApply() ... DONE
[15:31:04.537] Number of futures (= number of chunks): 1
[15:31:04.537] Launching 1 futures (chunks) ...
[15:31:04.537] Chunk #1 of 1 ...
[15:31:04.538]  - seeds: <none>
[15:31:04.538]  - All globals exported: [n=5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:04.538] getGlobalsAndPackages() ...
[15:31:04.538] - globals passed as-is: [5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:04.539] Resolving globals: FALSE
[15:31:04.539] Tweak future expression to call with '...' arguments ...
[15:31:04.539] {
[15:31:04.539]     do.call(function(...) {
[15:31:04.539]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:04.539]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:04.539]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:04.539]             on.exit(options(oopts), add = TRUE)
[15:31:04.539]         }
[15:31:04.539]         {
[15:31:04.539]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:04.539]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:04.539]                 ...future.FUN(...future.X_jj, ...)
[15:31:04.539]             })
[15:31:04.539]         }
[15:31:04.539]     }, args = future.call.arguments)
[15:31:04.539] }
[15:31:04.540] Tweak future expression to call with '...' arguments ... DONE
[15:31:04.540] - globals: [5] 'future.call.arguments', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:04.540] 
[15:31:04.541] getGlobalsAndPackages() ... DONE
[15:31:04.541] run() for 'Future' ...
[15:31:04.541] - state: 'created'
[15:31:04.541] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:31:04.542] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:04.542] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:31:04.542]   - Field: 'label'
[15:31:04.542]   - Field: 'local'
[15:31:04.543]   - Field: 'owner'
[15:31:04.543]   - Field: 'envir'
[15:31:04.543]   - Field: 'packages'
[15:31:04.543]   - Field: 'gc'
[15:31:04.543]   - Field: 'conditions'
[15:31:04.544]   - Field: 'expr'
[15:31:04.544]   - Field: 'uuid'
[15:31:04.544]   - Field: 'seed'
[15:31:04.544]   - Field: 'version'
[15:31:04.544]   - Field: 'result'
[15:31:04.545]   - Field: 'asynchronous'
[15:31:04.545]   - Field: 'calls'
[15:31:04.545]   - Field: 'globals'
[15:31:04.545]   - Field: 'stdout'
[15:31:04.545]   - Field: 'earlySignal'
[15:31:04.546]   - Field: 'lazy'
[15:31:04.546]   - Field: 'state'
[15:31:04.546] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:31:04.547] - Launch lazy future ...
[15:31:04.547] Packages needed by the future expression (n = 0): <none>
[15:31:04.547] Packages needed by future strategies (n = 0): <none>
[15:31:04.548] {
[15:31:04.548]     {
[15:31:04.548]         {
[15:31:04.548]             ...future.startTime <- base::Sys.time()
[15:31:04.548]             {
[15:31:04.548]                 {
[15:31:04.548]                   {
[15:31:04.548]                     base::local({
[15:31:04.548]                       has_future <- base::requireNamespace("future", 
[15:31:04.548]                         quietly = TRUE)
[15:31:04.548]                       if (has_future) {
[15:31:04.548]                         ns <- base::getNamespace("future")
[15:31:04.548]                         version <- ns[[".package"]][["version"]]
[15:31:04.548]                         if (is.null(version)) 
[15:31:04.548]                           version <- utils::packageVersion("future")
[15:31:04.548]                       }
[15:31:04.548]                       else {
[15:31:04.548]                         version <- NULL
[15:31:04.548]                       }
[15:31:04.548]                       if (!has_future || version < "1.8.0") {
[15:31:04.548]                         info <- base::c(r_version = base::gsub("R version ", 
[15:31:04.548]                           "", base::R.version$version.string), 
[15:31:04.548]                           platform = base::sprintf("%s (%s-bit)", 
[15:31:04.548]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:04.548]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:04.548]                             "release", "version")], collapse = " "), 
[15:31:04.548]                           hostname = base::Sys.info()[["nodename"]])
[15:31:04.548]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:31:04.548]                           info)
[15:31:04.548]                         info <- base::paste(info, collapse = "; ")
[15:31:04.548]                         if (!has_future) {
[15:31:04.548]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:04.548]                             info)
[15:31:04.548]                         }
[15:31:04.548]                         else {
[15:31:04.548]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:04.548]                             info, version)
[15:31:04.548]                         }
[15:31:04.548]                         base::stop(msg)
[15:31:04.548]                       }
[15:31:04.548]                     })
[15:31:04.548]                   }
[15:31:04.548]                   ...future.strategy.old <- future::plan("list")
[15:31:04.548]                   options(future.plan = NULL)
[15:31:04.548]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:04.548]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:04.548]                 }
[15:31:04.548]                 ...future.workdir <- getwd()
[15:31:04.548]             }
[15:31:04.548]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:04.548]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:04.548]         }
[15:31:04.548]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:04.548]             future.globals.maxSize = Inf, future.globals.method = NULL, 
[15:31:04.548]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:04.548]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:04.548]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:04.548]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:04.548]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:04.548]             base::names(...future.oldOptions))
[15:31:04.548]     }
[15:31:04.548]     if (FALSE) {
[15:31:04.548]     }
[15:31:04.548]     else {
[15:31:04.548]         if (TRUE) {
[15:31:04.548]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:04.548]                 open = "w")
[15:31:04.548]         }
[15:31:04.548]         else {
[15:31:04.548]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:04.548]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:04.548]         }
[15:31:04.548]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:04.548]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:04.548]             base::sink(type = "output", split = FALSE)
[15:31:04.548]             base::close(...future.stdout)
[15:31:04.548]         }, add = TRUE)
[15:31:04.548]     }
[15:31:04.548]     ...future.frame <- base::sys.nframe()
[15:31:04.548]     ...future.conditions <- base::list()
[15:31:04.548]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:04.548]     if (FALSE) {
[15:31:04.548]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:04.548]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:04.548]     }
[15:31:04.548]     ...future.result <- base::tryCatch({
[15:31:04.548]         base::withCallingHandlers({
[15:31:04.548]             ...future.value <- base::withVisible(base::local({
[15:31:04.548]                 do.call(function(...) {
[15:31:04.548]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:04.548]                   if (!identical(...future.globals.maxSize.org, 
[15:31:04.548]                     ...future.globals.maxSize)) {
[15:31:04.548]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:04.548]                     on.exit(options(oopts), add = TRUE)
[15:31:04.548]                   }
[15:31:04.548]                   {
[15:31:04.548]                     lapply(seq_along(...future.elements_ii), 
[15:31:04.548]                       FUN = function(jj) {
[15:31:04.548]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:04.548]                         ...future.FUN(...future.X_jj, ...)
[15:31:04.548]                       })
[15:31:04.548]                   }
[15:31:04.548]                 }, args = future.call.arguments)
[15:31:04.548]             }))
[15:31:04.548]             future::FutureResult(value = ...future.value$value, 
[15:31:04.548]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:04.548]                   ...future.rng), globalenv = if (FALSE) 
[15:31:04.548]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:04.548]                     ...future.globalenv.names))
[15:31:04.548]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:04.548]         }, condition = base::local({
[15:31:04.548]             c <- base::c
[15:31:04.548]             inherits <- base::inherits
[15:31:04.548]             invokeRestart <- base::invokeRestart
[15:31:04.548]             length <- base::length
[15:31:04.548]             list <- base::list
[15:31:04.548]             seq.int <- base::seq.int
[15:31:04.548]             signalCondition <- base::signalCondition
[15:31:04.548]             sys.calls <- base::sys.calls
[15:31:04.548]             `[[` <- base::`[[`
[15:31:04.548]             `+` <- base::`+`
[15:31:04.548]             `<<-` <- base::`<<-`
[15:31:04.548]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:04.548]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:04.548]                   3L)]
[15:31:04.548]             }
[15:31:04.548]             function(cond) {
[15:31:04.548]                 is_error <- inherits(cond, "error")
[15:31:04.548]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:04.548]                   NULL)
[15:31:04.548]                 if (is_error) {
[15:31:04.548]                   sessionInformation <- function() {
[15:31:04.548]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:04.548]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:04.548]                       search = base::search(), system = base::Sys.info())
[15:31:04.548]                   }
[15:31:04.548]                   ...future.conditions[[length(...future.conditions) + 
[15:31:04.548]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:04.548]                     cond$call), session = sessionInformation(), 
[15:31:04.548]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:04.548]                   signalCondition(cond)
[15:31:04.548]                 }
[15:31:04.548]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:04.548]                 "immediateCondition"))) {
[15:31:04.548]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:04.548]                   ...future.conditions[[length(...future.conditions) + 
[15:31:04.548]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:04.548]                   if (TRUE && !signal) {
[15:31:04.548]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:04.548]                     {
[15:31:04.548]                       inherits <- base::inherits
[15:31:04.548]                       invokeRestart <- base::invokeRestart
[15:31:04.548]                       is.null <- base::is.null
[15:31:04.548]                       muffled <- FALSE
[15:31:04.548]                       if (inherits(cond, "message")) {
[15:31:04.548]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:04.548]                         if (muffled) 
[15:31:04.548]                           invokeRestart("muffleMessage")
[15:31:04.548]                       }
[15:31:04.548]                       else if (inherits(cond, "warning")) {
[15:31:04.548]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:04.548]                         if (muffled) 
[15:31:04.548]                           invokeRestart("muffleWarning")
[15:31:04.548]                       }
[15:31:04.548]                       else if (inherits(cond, "condition")) {
[15:31:04.548]                         if (!is.null(pattern)) {
[15:31:04.548]                           computeRestarts <- base::computeRestarts
[15:31:04.548]                           grepl <- base::grepl
[15:31:04.548]                           restarts <- computeRestarts(cond)
[15:31:04.548]                           for (restart in restarts) {
[15:31:04.548]                             name <- restart$name
[15:31:04.548]                             if (is.null(name)) 
[15:31:04.548]                               next
[15:31:04.548]                             if (!grepl(pattern, name)) 
[15:31:04.548]                               next
[15:31:04.548]                             invokeRestart(restart)
[15:31:04.548]                             muffled <- TRUE
[15:31:04.548]                             break
[15:31:04.548]                           }
[15:31:04.548]                         }
[15:31:04.548]                       }
[15:31:04.548]                       invisible(muffled)
[15:31:04.548]                     }
[15:31:04.548]                     muffleCondition(cond, pattern = "^muffle")
[15:31:04.548]                   }
[15:31:04.548]                 }
[15:31:04.548]                 else {
[15:31:04.548]                   if (TRUE) {
[15:31:04.548]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:04.548]                     {
[15:31:04.548]                       inherits <- base::inherits
[15:31:04.548]                       invokeRestart <- base::invokeRestart
[15:31:04.548]                       is.null <- base::is.null
[15:31:04.548]                       muffled <- FALSE
[15:31:04.548]                       if (inherits(cond, "message")) {
[15:31:04.548]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:04.548]                         if (muffled) 
[15:31:04.548]                           invokeRestart("muffleMessage")
[15:31:04.548]                       }
[15:31:04.548]                       else if (inherits(cond, "warning")) {
[15:31:04.548]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:04.548]                         if (muffled) 
[15:31:04.548]                           invokeRestart("muffleWarning")
[15:31:04.548]                       }
[15:31:04.548]                       else if (inherits(cond, "condition")) {
[15:31:04.548]                         if (!is.null(pattern)) {
[15:31:04.548]                           computeRestarts <- base::computeRestarts
[15:31:04.548]                           grepl <- base::grepl
[15:31:04.548]                           restarts <- computeRestarts(cond)
[15:31:04.548]                           for (restart in restarts) {
[15:31:04.548]                             name <- restart$name
[15:31:04.548]                             if (is.null(name)) 
[15:31:04.548]                               next
[15:31:04.548]                             if (!grepl(pattern, name)) 
[15:31:04.548]                               next
[15:31:04.548]                             invokeRestart(restart)
[15:31:04.548]                             muffled <- TRUE
[15:31:04.548]                             break
[15:31:04.548]                           }
[15:31:04.548]                         }
[15:31:04.548]                       }
[15:31:04.548]                       invisible(muffled)
[15:31:04.548]                     }
[15:31:04.548]                     muffleCondition(cond, pattern = "^muffle")
[15:31:04.548]                   }
[15:31:04.548]                 }
[15:31:04.548]             }
[15:31:04.548]         }))
[15:31:04.548]     }, error = function(ex) {
[15:31:04.548]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:04.548]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:04.548]                 ...future.rng), started = ...future.startTime, 
[15:31:04.548]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:04.548]             version = "1.8"), class = "FutureResult")
[15:31:04.548]     }, finally = {
[15:31:04.548]         if (!identical(...future.workdir, getwd())) 
[15:31:04.548]             setwd(...future.workdir)
[15:31:04.548]         {
[15:31:04.548]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:04.548]                 ...future.oldOptions$nwarnings <- NULL
[15:31:04.548]             }
[15:31:04.548]             base::options(...future.oldOptions)
[15:31:04.548]             if (.Platform$OS.type == "windows") {
[15:31:04.548]                 old_names <- names(...future.oldEnvVars)
[15:31:04.548]                 envs <- base::Sys.getenv()
[15:31:04.548]                 names <- names(envs)
[15:31:04.548]                 common <- intersect(names, old_names)
[15:31:04.548]                 added <- setdiff(names, old_names)
[15:31:04.548]                 removed <- setdiff(old_names, names)
[15:31:04.548]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:04.548]                   envs[common]]
[15:31:04.548]                 NAMES <- toupper(changed)
[15:31:04.548]                 args <- list()
[15:31:04.548]                 for (kk in seq_along(NAMES)) {
[15:31:04.548]                   name <- changed[[kk]]
[15:31:04.548]                   NAME <- NAMES[[kk]]
[15:31:04.548]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:04.548]                     next
[15:31:04.548]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:04.548]                 }
[15:31:04.548]                 NAMES <- toupper(added)
[15:31:04.548]                 for (kk in seq_along(NAMES)) {
[15:31:04.548]                   name <- added[[kk]]
[15:31:04.548]                   NAME <- NAMES[[kk]]
[15:31:04.548]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:04.548]                     next
[15:31:04.548]                   args[[name]] <- ""
[15:31:04.548]                 }
[15:31:04.548]                 NAMES <- toupper(removed)
[15:31:04.548]                 for (kk in seq_along(NAMES)) {
[15:31:04.548]                   name <- removed[[kk]]
[15:31:04.548]                   NAME <- NAMES[[kk]]
[15:31:04.548]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:04.548]                     next
[15:31:04.548]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:04.548]                 }
[15:31:04.548]                 if (length(args) > 0) 
[15:31:04.548]                   base::do.call(base::Sys.setenv, args = args)
[15:31:04.548]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:04.548]             }
[15:31:04.548]             else {
[15:31:04.548]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:04.548]             }
[15:31:04.548]             {
[15:31:04.548]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:04.548]                   0L) {
[15:31:04.548]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:04.548]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:04.548]                   base::options(opts)
[15:31:04.548]                 }
[15:31:04.548]                 {
[15:31:04.548]                   {
[15:31:04.548]                     NULL
[15:31:04.548]                     RNGkind("Mersenne-Twister")
[15:31:04.548]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:31:04.548]                       inherits = FALSE)
[15:31:04.548]                   }
[15:31:04.548]                   options(future.plan = NULL)
[15:31:04.548]                   if (is.na(NA_character_)) 
[15:31:04.548]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:04.548]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:04.548]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:04.548]                     .init = FALSE)
[15:31:04.548]                 }
[15:31:04.548]             }
[15:31:04.548]         }
[15:31:04.548]     })
[15:31:04.548]     if (TRUE) {
[15:31:04.548]         base::sink(type = "output", split = FALSE)
[15:31:04.548]         if (TRUE) {
[15:31:04.548]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:04.548]         }
[15:31:04.548]         else {
[15:31:04.548]             ...future.result["stdout"] <- base::list(NULL)
[15:31:04.548]         }
[15:31:04.548]         base::close(...future.stdout)
[15:31:04.548]         ...future.stdout <- NULL
[15:31:04.548]     }
[15:31:04.548]     ...future.result$conditions <- ...future.conditions
[15:31:04.548]     ...future.result$finished <- base::Sys.time()
[15:31:04.548]     ...future.result
[15:31:04.548] }
[15:31:04.554] assign_globals() ...
[15:31:04.555] List of 5
[15:31:04.555]  $ future.call.arguments    : list()
[15:31:04.555]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:04.555]  $ ...future.FUN            :function (x)  
[15:31:04.555]  $ ...future.elements_ii    :List of 2
[15:31:04.555]   ..$ : num [1:8] 3 3 3 3 3 3 3 3
[15:31:04.555]   ..$ : num [1:8] 4 3 2 1 2 3 4 5
[15:31:04.555]  $ ...future.seeds_ii       : NULL
[15:31:04.555]  $ ...future.globals.maxSize: num Inf
[15:31:04.555]  - attr(*, "resolved")= logi FALSE
[15:31:04.555]  - attr(*, "total_size")= num NA
[15:31:04.555]  - attr(*, "where")=List of 5
[15:31:04.555]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:31:04.555]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:31:04.555]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:31:04.555]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:31:04.555]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:31:04.555]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:04.555]  - attr(*, "already-done")= logi TRUE
[15:31:04.566] - copied 'future.call.arguments' to environment
[15:31:04.566] - copied '...future.FUN' to environment
[15:31:04.566] - copied '...future.elements_ii' to environment
[15:31:04.567] - copied '...future.seeds_ii' to environment
[15:31:04.567] - copied '...future.globals.maxSize' to environment
[15:31:04.567] assign_globals() ... done
[15:31:04.568] plan(): Setting new future strategy stack:
[15:31:04.568] List of future strategies:
[15:31:04.568] 1. sequential:
[15:31:04.568]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:04.568]    - tweaked: FALSE
[15:31:04.568]    - call: NULL
[15:31:04.569] plan(): nbrOfWorkers() = 1
[15:31:04.571] plan(): Setting new future strategy stack:
[15:31:04.572] List of future strategies:
[15:31:04.572] 1. sequential:
[15:31:04.572]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:04.572]    - tweaked: FALSE
[15:31:04.572]    - call: plan(strategy)
[15:31:04.573] plan(): nbrOfWorkers() = 1
[15:31:04.573] SequentialFuture started (and completed)
[15:31:04.574] - Launch lazy future ... done
[15:31:04.574] run() for 'SequentialFuture' ... done
[15:31:04.574] Created future:
[15:31:04.575] SequentialFuture:
[15:31:04.575] Label: 'future_apply-1'
[15:31:04.575] Expression:
[15:31:04.575] {
[15:31:04.575]     do.call(function(...) {
[15:31:04.575]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:04.575]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:04.575]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:04.575]             on.exit(options(oopts), add = TRUE)
[15:31:04.575]         }
[15:31:04.575]         {
[15:31:04.575]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:04.575]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:04.575]                 ...future.FUN(...future.X_jj, ...)
[15:31:04.575]             })
[15:31:04.575]         }
[15:31:04.575]     }, args = future.call.arguments)
[15:31:04.575] }
[15:31:04.575] Lazy evaluation: FALSE
[15:31:04.575] Asynchronous evaluation: FALSE
[15:31:04.575] Local evaluation: TRUE
[15:31:04.575] Environment: R_GlobalEnv
[15:31:04.575] Capture standard output: TRUE
[15:31:04.575] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:04.575] Globals: 5 objects totaling 1.10 KiB (DotDotDotList 'future.call.arguments' of 0 bytes, function '...future.FUN' of 848 bytes, list '...future.elements_ii' of 224 bytes, NULL '...future.seeds_ii' of 0 bytes, numeric '...future.globals.maxSize' of 56 bytes)
[15:31:04.575] Packages: <none>
[15:31:04.575] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:04.575] Resolved: TRUE
[15:31:04.575] Value: 224 bytes of class 'list'
[15:31:04.575] Early signaling: FALSE
[15:31:04.575] Owner process: 6672a580-6d3c-e82f-380e-108c475ace70
[15:31:04.575] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:04.577] Chunk #1 of 1 ... DONE
[15:31:04.577] Launching 1 futures (chunks) ... DONE
[15:31:04.577] Resolving 1 futures (chunks) ...
[15:31:04.578] resolve() on list ...
[15:31:04.578]  recursive: 0
[15:31:04.578]  length: 1
[15:31:04.578] 
[15:31:04.578] resolved() for 'SequentialFuture' ...
[15:31:04.579] - state: 'finished'
[15:31:04.579] - run: TRUE
[15:31:04.579] - result: 'FutureResult'
[15:31:04.579] resolved() for 'SequentialFuture' ... done
[15:31:04.579] Future #1
[15:31:04.580] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:31:04.580] - nx: 1
[15:31:04.580] - relay: TRUE
[15:31:04.580] - stdout: TRUE
[15:31:04.580] - signal: TRUE
[15:31:04.581] - resignal: FALSE
[15:31:04.581] - force: TRUE
[15:31:04.581] - relayed: [n=1] FALSE
[15:31:04.581] - queued futures: [n=1] FALSE
[15:31:04.581]  - until=1
[15:31:04.583]  - relaying element #1
[15:31:04.584] - relayed: [n=1] TRUE
[15:31:04.584] - queued futures: [n=1] TRUE
[15:31:04.584] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:31:04.585]  length: 0 (resolved future 1)
[15:31:04.585] Relaying remaining futures
[15:31:04.585] signalConditionsASAP(NULL, pos=0) ...
[15:31:04.585] - nx: 1
[15:31:04.585] - relay: TRUE
[15:31:04.586] - stdout: TRUE
[15:31:04.586] - signal: TRUE
[15:31:04.586] - resignal: FALSE
[15:31:04.586] - force: TRUE
[15:31:04.586] - relayed: [n=1] TRUE
[15:31:04.587] - queued futures: [n=1] TRUE
 - flush all
[15:31:04.587] - relayed: [n=1] TRUE
[15:31:04.587] - queued futures: [n=1] TRUE
[15:31:04.587] signalConditionsASAP(NULL, pos=0) ... done
[15:31:04.588] resolve() on list ... DONE
[15:31:04.588]  - Number of value chunks collected: 1
[15:31:04.588] Resolving 1 futures (chunks) ... DONE
[15:31:04.588] Reducing values from 1 chunks ...
[15:31:04.588]  - Number of values collected after concatenation: 2
[15:31:04.589]  - Number of values expected: 2
[15:31:04.589] Reducing values from 1 chunks ... DONE
[15:31:04.589] future_lapply() ... DONE
      col
row    x1 x2
  [1,]  3  4
  [2,]  3  3
  [3,]  3  2
  [4,]  3  1
  [5,]  3  2
  [6,]  3  3
  [7,]  3  4
  [8,]  3  5
[15:31:04.589] getGlobalsAndPackagesXApply() ...
[15:31:04.590]  - future.globals: TRUE
[15:31:04.590] getGlobalsAndPackages() ...
[15:31:04.590] Searching for globals...
[15:31:04.592] - globals found: [1] 'FUN'
[15:31:04.592] Searching for globals ... DONE
[15:31:04.592] Resolving globals: FALSE
[15:31:04.593] The total size of the 1 globals is 848 bytes (848 bytes)
[15:31:04.593] The total size of the 1 globals exported for future expression ('FUN(X = structure(c(3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 2, 1, 2, 3,; 4, 5, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 2, 1, 2, 3, 4, 5, 3, 3, 3,; 3, 3, 3, 3, 3, 4, 3, 2, 1, 2, 3, 4, 5), dim = c(8L, 2L, 3L), dimnames = list(; row = NULL, col = c("x1", "x2"), C = c("cop.1", "cop.2",; "cop.3"))))') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:31:04.594] - globals: [1] 'FUN'
[15:31:04.594] 
[15:31:04.594] getGlobalsAndPackages() ... DONE
[15:31:04.594]  - globals found/used: [n=1] 'FUN'
[15:31:04.594]  - needed namespaces: [n=0] 
[15:31:04.595] Finding globals ... DONE
[15:31:04.595]  - use_args: TRUE
[15:31:04.595]  - Getting '...' globals ...
[15:31:04.595] resolve() on list ...
[15:31:04.596]  recursive: 0
[15:31:04.596]  length: 1
[15:31:04.596]  elements: '...'
[15:31:04.596]  length: 0 (resolved future 1)
[15:31:04.596] resolve() on list ... DONE
[15:31:04.597]    - '...' content: [n=0] 
[15:31:04.597] List of 1
[15:31:04.597]  $ ...: list()
[15:31:04.597]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:04.597]  - attr(*, "where")=List of 1
[15:31:04.597]   ..$ ...:<environment: 0x000001bcb9288228> 
[15:31:04.597]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:04.597]  - attr(*, "resolved")= logi TRUE
[15:31:04.597]  - attr(*, "total_size")= num NA
[15:31:04.600]  - Getting '...' globals ... DONE
[15:31:04.601] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:04.601] List of 2
[15:31:04.601]  $ ...future.FUN:function (x)  
[15:31:04.601]  $ ...          : list()
[15:31:04.601]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:04.601]  - attr(*, "where")=List of 2
[15:31:04.601]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:04.601]   ..$ ...          :<environment: 0x000001bcb9288228> 
[15:31:04.601]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:04.601]  - attr(*, "resolved")= logi FALSE
[15:31:04.601]  - attr(*, "total_size")= num 848
[15:31:04.604] Packages to be attached in all futures: [n=0] 
[15:31:04.604] getGlobalsAndPackagesXApply() ... DONE
[15:31:04.605] future_lapply() ...
[15:31:04.606] Number of chunks: 1
[15:31:04.606] getGlobalsAndPackagesXApply() ...
[15:31:04.606]  - future.globals: <name-value list> with names 'list()'
[15:31:04.606]  - use_args: TRUE
[15:31:04.606] Globals to be used in all futures (chunks): [n=2] '...', '...future.FUN'
[15:31:04.607] List of 2
[15:31:04.607]  $ ...          : list()
[15:31:04.607]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:04.607]  $ ...future.FUN:function (x)  
[15:31:04.607]  - attr(*, "where")=List of 2
[15:31:04.607]   ..$ ...          :<environment: 0x000001bcb9288228> 
[15:31:04.607]   ..$ ...future.FUN:<environment: namespace:base> 
[15:31:04.607]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:04.607]  - attr(*, "resolved")= logi FALSE
[15:31:04.607]  - attr(*, "total_size")= num NA
[15:31:04.611] Packages to be attached in all futures: [n=0] 
[15:31:04.611] getGlobalsAndPackagesXApply() ... DONE
[15:31:04.612] Number of futures (= number of chunks): 1
[15:31:04.612] Launching 1 futures (chunks) ...
[15:31:04.612] Chunk #1 of 1 ...
[15:31:04.614]  - seeds: <none>
[15:31:04.614]  - All globals exported: [n=5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:04.615] getGlobalsAndPackages() ...
[15:31:04.615] - globals passed as-is: [5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:04.615] Resolving globals: FALSE
[15:31:04.615] Tweak future expression to call with '...' arguments ...
[15:31:04.616] {
[15:31:04.616]     do.call(function(...) {
[15:31:04.616]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:04.616]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:04.616]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:04.616]             on.exit(options(oopts), add = TRUE)
[15:31:04.616]         }
[15:31:04.616]         {
[15:31:04.616]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:04.616]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:04.616]                 ...future.FUN(...future.X_jj, ...)
[15:31:04.616]             })
[15:31:04.616]         }
[15:31:04.616]     }, args = future.call.arguments)
[15:31:04.616] }
[15:31:04.616] Tweak future expression to call with '...' arguments ... DONE
[15:31:04.617] - globals: [5] 'future.call.arguments', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:04.618] 
[15:31:04.618] getGlobalsAndPackages() ... DONE
[15:31:04.618] run() for 'Future' ...
[15:31:04.619] - state: 'created'
[15:31:04.619] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:31:04.619] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:04.620] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:31:04.620]   - Field: 'label'
[15:31:04.620]   - Field: 'local'
[15:31:04.620]   - Field: 'owner'
[15:31:04.620]   - Field: 'envir'
[15:31:04.620]   - Field: 'packages'
[15:31:04.621]   - Field: 'gc'
[15:31:04.621]   - Field: 'conditions'
[15:31:04.621]   - Field: 'expr'
[15:31:04.621]   - Field: 'uuid'
[15:31:04.621]   - Field: 'seed'
[15:31:04.622]   - Field: 'version'
[15:31:04.622]   - Field: 'result'
[15:31:04.622]   - Field: 'asynchronous'
[15:31:04.622]   - Field: 'calls'
[15:31:04.622]   - Field: 'globals'
[15:31:04.623]   - Field: 'stdout'
[15:31:04.623]   - Field: 'earlySignal'
[15:31:04.623]   - Field: 'lazy'
[15:31:04.623]   - Field: 'state'
[15:31:04.623] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:31:04.623] - Launch lazy future ...
[15:31:04.624] Packages needed by the future expression (n = 0): <none>
[15:31:04.624] Packages needed by future strategies (n = 0): <none>
[15:31:04.625] {
[15:31:04.625]     {
[15:31:04.625]         {
[15:31:04.625]             ...future.startTime <- base::Sys.time()
[15:31:04.625]             {
[15:31:04.625]                 {
[15:31:04.625]                   {
[15:31:04.625]                     base::local({
[15:31:04.625]                       has_future <- base::requireNamespace("future", 
[15:31:04.625]                         quietly = TRUE)
[15:31:04.625]                       if (has_future) {
[15:31:04.625]                         ns <- base::getNamespace("future")
[15:31:04.625]                         version <- ns[[".package"]][["version"]]
[15:31:04.625]                         if (is.null(version)) 
[15:31:04.625]                           version <- utils::packageVersion("future")
[15:31:04.625]                       }
[15:31:04.625]                       else {
[15:31:04.625]                         version <- NULL
[15:31:04.625]                       }
[15:31:04.625]                       if (!has_future || version < "1.8.0") {
[15:31:04.625]                         info <- base::c(r_version = base::gsub("R version ", 
[15:31:04.625]                           "", base::R.version$version.string), 
[15:31:04.625]                           platform = base::sprintf("%s (%s-bit)", 
[15:31:04.625]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:04.625]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:04.625]                             "release", "version")], collapse = " "), 
[15:31:04.625]                           hostname = base::Sys.info()[["nodename"]])
[15:31:04.625]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:31:04.625]                           info)
[15:31:04.625]                         info <- base::paste(info, collapse = "; ")
[15:31:04.625]                         if (!has_future) {
[15:31:04.625]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:04.625]                             info)
[15:31:04.625]                         }
[15:31:04.625]                         else {
[15:31:04.625]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:04.625]                             info, version)
[15:31:04.625]                         }
[15:31:04.625]                         base::stop(msg)
[15:31:04.625]                       }
[15:31:04.625]                     })
[15:31:04.625]                   }
[15:31:04.625]                   ...future.strategy.old <- future::plan("list")
[15:31:04.625]                   options(future.plan = NULL)
[15:31:04.625]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:04.625]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:04.625]                 }
[15:31:04.625]                 ...future.workdir <- getwd()
[15:31:04.625]             }
[15:31:04.625]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:04.625]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:04.625]         }
[15:31:04.625]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:04.625]             future.globals.maxSize = Inf, future.globals.method = NULL, 
[15:31:04.625]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:04.625]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:04.625]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:04.625]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:04.625]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:04.625]             base::names(...future.oldOptions))
[15:31:04.625]     }
[15:31:04.625]     if (FALSE) {
[15:31:04.625]     }
[15:31:04.625]     else {
[15:31:04.625]         if (TRUE) {
[15:31:04.625]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:04.625]                 open = "w")
[15:31:04.625]         }
[15:31:04.625]         else {
[15:31:04.625]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:04.625]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:04.625]         }
[15:31:04.625]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:04.625]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:04.625]             base::sink(type = "output", split = FALSE)
[15:31:04.625]             base::close(...future.stdout)
[15:31:04.625]         }, add = TRUE)
[15:31:04.625]     }
[15:31:04.625]     ...future.frame <- base::sys.nframe()
[15:31:04.625]     ...future.conditions <- base::list()
[15:31:04.625]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:04.625]     if (FALSE) {
[15:31:04.625]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:04.625]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:04.625]     }
[15:31:04.625]     ...future.result <- base::tryCatch({
[15:31:04.625]         base::withCallingHandlers({
[15:31:04.625]             ...future.value <- base::withVisible(base::local({
[15:31:04.625]                 do.call(function(...) {
[15:31:04.625]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:04.625]                   if (!identical(...future.globals.maxSize.org, 
[15:31:04.625]                     ...future.globals.maxSize)) {
[15:31:04.625]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:04.625]                     on.exit(options(oopts), add = TRUE)
[15:31:04.625]                   }
[15:31:04.625]                   {
[15:31:04.625]                     lapply(seq_along(...future.elements_ii), 
[15:31:04.625]                       FUN = function(jj) {
[15:31:04.625]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:04.625]                         ...future.FUN(...future.X_jj, ...)
[15:31:04.625]                       })
[15:31:04.625]                   }
[15:31:04.625]                 }, args = future.call.arguments)
[15:31:04.625]             }))
[15:31:04.625]             future::FutureResult(value = ...future.value$value, 
[15:31:04.625]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:04.625]                   ...future.rng), globalenv = if (FALSE) 
[15:31:04.625]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:04.625]                     ...future.globalenv.names))
[15:31:04.625]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:04.625]         }, condition = base::local({
[15:31:04.625]             c <- base::c
[15:31:04.625]             inherits <- base::inherits
[15:31:04.625]             invokeRestart <- base::invokeRestart
[15:31:04.625]             length <- base::length
[15:31:04.625]             list <- base::list
[15:31:04.625]             seq.int <- base::seq.int
[15:31:04.625]             signalCondition <- base::signalCondition
[15:31:04.625]             sys.calls <- base::sys.calls
[15:31:04.625]             `[[` <- base::`[[`
[15:31:04.625]             `+` <- base::`+`
[15:31:04.625]             `<<-` <- base::`<<-`
[15:31:04.625]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:04.625]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:04.625]                   3L)]
[15:31:04.625]             }
[15:31:04.625]             function(cond) {
[15:31:04.625]                 is_error <- inherits(cond, "error")
[15:31:04.625]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:04.625]                   NULL)
[15:31:04.625]                 if (is_error) {
[15:31:04.625]                   sessionInformation <- function() {
[15:31:04.625]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:04.625]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:04.625]                       search = base::search(), system = base::Sys.info())
[15:31:04.625]                   }
[15:31:04.625]                   ...future.conditions[[length(...future.conditions) + 
[15:31:04.625]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:04.625]                     cond$call), session = sessionInformation(), 
[15:31:04.625]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:04.625]                   signalCondition(cond)
[15:31:04.625]                 }
[15:31:04.625]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:04.625]                 "immediateCondition"))) {
[15:31:04.625]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:04.625]                   ...future.conditions[[length(...future.conditions) + 
[15:31:04.625]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:04.625]                   if (TRUE && !signal) {
[15:31:04.625]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:04.625]                     {
[15:31:04.625]                       inherits <- base::inherits
[15:31:04.625]                       invokeRestart <- base::invokeRestart
[15:31:04.625]                       is.null <- base::is.null
[15:31:04.625]                       muffled <- FALSE
[15:31:04.625]                       if (inherits(cond, "message")) {
[15:31:04.625]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:04.625]                         if (muffled) 
[15:31:04.625]                           invokeRestart("muffleMessage")
[15:31:04.625]                       }
[15:31:04.625]                       else if (inherits(cond, "warning")) {
[15:31:04.625]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:04.625]                         if (muffled) 
[15:31:04.625]                           invokeRestart("muffleWarning")
[15:31:04.625]                       }
[15:31:04.625]                       else if (inherits(cond, "condition")) {
[15:31:04.625]                         if (!is.null(pattern)) {
[15:31:04.625]                           computeRestarts <- base::computeRestarts
[15:31:04.625]                           grepl <- base::grepl
[15:31:04.625]                           restarts <- computeRestarts(cond)
[15:31:04.625]                           for (restart in restarts) {
[15:31:04.625]                             name <- restart$name
[15:31:04.625]                             if (is.null(name)) 
[15:31:04.625]                               next
[15:31:04.625]                             if (!grepl(pattern, name)) 
[15:31:04.625]                               next
[15:31:04.625]                             invokeRestart(restart)
[15:31:04.625]                             muffled <- TRUE
[15:31:04.625]                             break
[15:31:04.625]                           }
[15:31:04.625]                         }
[15:31:04.625]                       }
[15:31:04.625]                       invisible(muffled)
[15:31:04.625]                     }
[15:31:04.625]                     muffleCondition(cond, pattern = "^muffle")
[15:31:04.625]                   }
[15:31:04.625]                 }
[15:31:04.625]                 else {
[15:31:04.625]                   if (TRUE) {
[15:31:04.625]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:04.625]                     {
[15:31:04.625]                       inherits <- base::inherits
[15:31:04.625]                       invokeRestart <- base::invokeRestart
[15:31:04.625]                       is.null <- base::is.null
[15:31:04.625]                       muffled <- FALSE
[15:31:04.625]                       if (inherits(cond, "message")) {
[15:31:04.625]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:04.625]                         if (muffled) 
[15:31:04.625]                           invokeRestart("muffleMessage")
[15:31:04.625]                       }
[15:31:04.625]                       else if (inherits(cond, "warning")) {
[15:31:04.625]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:04.625]                         if (muffled) 
[15:31:04.625]                           invokeRestart("muffleWarning")
[15:31:04.625]                       }
[15:31:04.625]                       else if (inherits(cond, "condition")) {
[15:31:04.625]                         if (!is.null(pattern)) {
[15:31:04.625]                           computeRestarts <- base::computeRestarts
[15:31:04.625]                           grepl <- base::grepl
[15:31:04.625]                           restarts <- computeRestarts(cond)
[15:31:04.625]                           for (restart in restarts) {
[15:31:04.625]                             name <- restart$name
[15:31:04.625]                             if (is.null(name)) 
[15:31:04.625]                               next
[15:31:04.625]                             if (!grepl(pattern, name)) 
[15:31:04.625]                               next
[15:31:04.625]                             invokeRestart(restart)
[15:31:04.625]                             muffled <- TRUE
[15:31:04.625]                             break
[15:31:04.625]                           }
[15:31:04.625]                         }
[15:31:04.625]                       }
[15:31:04.625]                       invisible(muffled)
[15:31:04.625]                     }
[15:31:04.625]                     muffleCondition(cond, pattern = "^muffle")
[15:31:04.625]                   }
[15:31:04.625]                 }
[15:31:04.625]             }
[15:31:04.625]         }))
[15:31:04.625]     }, error = function(ex) {
[15:31:04.625]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:04.625]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:04.625]                 ...future.rng), started = ...future.startTime, 
[15:31:04.625]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:04.625]             version = "1.8"), class = "FutureResult")
[15:31:04.625]     }, finally = {
[15:31:04.625]         if (!identical(...future.workdir, getwd())) 
[15:31:04.625]             setwd(...future.workdir)
[15:31:04.625]         {
[15:31:04.625]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:04.625]                 ...future.oldOptions$nwarnings <- NULL
[15:31:04.625]             }
[15:31:04.625]             base::options(...future.oldOptions)
[15:31:04.625]             if (.Platform$OS.type == "windows") {
[15:31:04.625]                 old_names <- names(...future.oldEnvVars)
[15:31:04.625]                 envs <- base::Sys.getenv()
[15:31:04.625]                 names <- names(envs)
[15:31:04.625]                 common <- intersect(names, old_names)
[15:31:04.625]                 added <- setdiff(names, old_names)
[15:31:04.625]                 removed <- setdiff(old_names, names)
[15:31:04.625]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:04.625]                   envs[common]]
[15:31:04.625]                 NAMES <- toupper(changed)
[15:31:04.625]                 args <- list()
[15:31:04.625]                 for (kk in seq_along(NAMES)) {
[15:31:04.625]                   name <- changed[[kk]]
[15:31:04.625]                   NAME <- NAMES[[kk]]
[15:31:04.625]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:04.625]                     next
[15:31:04.625]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:04.625]                 }
[15:31:04.625]                 NAMES <- toupper(added)
[15:31:04.625]                 for (kk in seq_along(NAMES)) {
[15:31:04.625]                   name <- added[[kk]]
[15:31:04.625]                   NAME <- NAMES[[kk]]
[15:31:04.625]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:04.625]                     next
[15:31:04.625]                   args[[name]] <- ""
[15:31:04.625]                 }
[15:31:04.625]                 NAMES <- toupper(removed)
[15:31:04.625]                 for (kk in seq_along(NAMES)) {
[15:31:04.625]                   name <- removed[[kk]]
[15:31:04.625]                   NAME <- NAMES[[kk]]
[15:31:04.625]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:04.625]                     next
[15:31:04.625]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:04.625]                 }
[15:31:04.625]                 if (length(args) > 0) 
[15:31:04.625]                   base::do.call(base::Sys.setenv, args = args)
[15:31:04.625]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:04.625]             }
[15:31:04.625]             else {
[15:31:04.625]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:04.625]             }
[15:31:04.625]             {
[15:31:04.625]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:04.625]                   0L) {
[15:31:04.625]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:04.625]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:04.625]                   base::options(opts)
[15:31:04.625]                 }
[15:31:04.625]                 {
[15:31:04.625]                   {
[15:31:04.625]                     NULL
[15:31:04.625]                     RNGkind("Mersenne-Twister")
[15:31:04.625]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:31:04.625]                       inherits = FALSE)
[15:31:04.625]                   }
[15:31:04.625]                   options(future.plan = NULL)
[15:31:04.625]                   if (is.na(NA_character_)) 
[15:31:04.625]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:04.625]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:04.625]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:04.625]                     .init = FALSE)
[15:31:04.625]                 }
[15:31:04.625]             }
[15:31:04.625]         }
[15:31:04.625]     })
[15:31:04.625]     if (TRUE) {
[15:31:04.625]         base::sink(type = "output", split = FALSE)
[15:31:04.625]         if (TRUE) {
[15:31:04.625]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:04.625]         }
[15:31:04.625]         else {
[15:31:04.625]             ...future.result["stdout"] <- base::list(NULL)
[15:31:04.625]         }
[15:31:04.625]         base::close(...future.stdout)
[15:31:04.625]         ...future.stdout <- NULL
[15:31:04.625]     }
[15:31:04.625]     ...future.result$conditions <- ...future.conditions
[15:31:04.625]     ...future.result$finished <- base::Sys.time()
[15:31:04.625]     ...future.result
[15:31:04.625] }
[15:31:04.629] assign_globals() ...
[15:31:04.629] List of 5
[15:31:04.629]  $ future.call.arguments    : list()
[15:31:04.629]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:04.629]  $ ...future.FUN            :function (x)  
[15:31:04.629]  $ ...future.elements_ii    :List of 6
[15:31:04.629]   ..$ : num [1:8] 3 3 3 3 3 3 3 3
[15:31:04.629]   ..$ : num [1:8] 4 3 2 1 2 3 4 5
[15:31:04.629]   ..$ : num [1:8] 3 3 3 3 3 3 3 3
[15:31:04.629]   ..$ : num [1:8] 4 3 2 1 2 3 4 5
[15:31:04.629]   ..$ : num [1:8] 3 3 3 3 3 3 3 3
[15:31:04.629]   ..$ : num [1:8] 4 3 2 1 2 3 4 5
[15:31:04.629]  $ ...future.seeds_ii       : NULL
[15:31:04.629]  $ ...future.globals.maxSize: num Inf
[15:31:04.629]  - attr(*, "resolved")= logi FALSE
[15:31:04.629]  - attr(*, "total_size")= num NA
[15:31:04.629]  - attr(*, "where")=List of 5
[15:31:04.629]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:31:04.629]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:31:04.629]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:31:04.629]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:31:04.629]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:31:04.629]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:04.629]  - attr(*, "already-done")= logi TRUE
[15:31:04.638] - copied 'future.call.arguments' to environment
[15:31:04.638] - copied '...future.FUN' to environment
[15:31:04.638] - copied '...future.elements_ii' to environment
[15:31:04.639] - copied '...future.seeds_ii' to environment
[15:31:04.639] - copied '...future.globals.maxSize' to environment
[15:31:04.639] assign_globals() ... done
[15:31:04.640] plan(): Setting new future strategy stack:
[15:31:04.640] List of future strategies:
[15:31:04.640] 1. sequential:
[15:31:04.640]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:04.640]    - tweaked: FALSE
[15:31:04.640]    - call: NULL
[15:31:04.641] plan(): nbrOfWorkers() = 1
[15:31:04.642] plan(): Setting new future strategy stack:
[15:31:04.642] List of future strategies:
[15:31:04.642] 1. sequential:
[15:31:04.642]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:04.642]    - tweaked: FALSE
[15:31:04.642]    - call: plan(strategy)
[15:31:04.643] plan(): nbrOfWorkers() = 1
[15:31:04.643] SequentialFuture started (and completed)
[15:31:04.644] - Launch lazy future ... done
[15:31:04.644] run() for 'SequentialFuture' ... done
[15:31:04.644] Created future:
[15:31:04.644] SequentialFuture:
[15:31:04.644] Label: 'future_apply-1'
[15:31:04.644] Expression:
[15:31:04.644] {
[15:31:04.644]     do.call(function(...) {
[15:31:04.644]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:04.644]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:04.644]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:04.644]             on.exit(options(oopts), add = TRUE)
[15:31:04.644]         }
[15:31:04.644]         {
[15:31:04.644]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:04.644]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:04.644]                 ...future.FUN(...future.X_jj, ...)
[15:31:04.644]             })
[15:31:04.644]         }
[15:31:04.644]     }, args = future.call.arguments)
[15:31:04.644] }
[15:31:04.644] Lazy evaluation: FALSE
[15:31:04.644] Asynchronous evaluation: FALSE
[15:31:04.644] Local evaluation: TRUE
[15:31:04.644] Environment: R_GlobalEnv
[15:31:04.644] Capture standard output: TRUE
[15:31:04.644] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:04.644] Globals: 5 objects totaling 1.54 KiB (DotDotDotList 'future.call.arguments' of 0 bytes, function '...future.FUN' of 848 bytes, list '...future.elements_ii' of 672 bytes, NULL '...future.seeds_ii' of 0 bytes, numeric '...future.globals.maxSize' of 56 bytes)
[15:31:04.644] Packages: <none>
[15:31:04.644] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:04.644] Resolved: TRUE
[15:31:04.644] Value: 672 bytes of class 'list'
[15:31:04.644] Early signaling: FALSE
[15:31:04.644] Owner process: 6672a580-6d3c-e82f-380e-108c475ace70
[15:31:04.644] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:04.646] Chunk #1 of 1 ... DONE
[15:31:04.646] Launching 1 futures (chunks) ... DONE
[15:31:04.647] Resolving 1 futures (chunks) ...
[15:31:04.647] resolve() on list ...
[15:31:04.647]  recursive: 0
[15:31:04.647]  length: 1
[15:31:04.647] 
[15:31:04.648] resolved() for 'SequentialFuture' ...
[15:31:04.648] - state: 'finished'
[15:31:04.648] - run: TRUE
[15:31:04.648] - result: 'FutureResult'
[15:31:04.648] resolved() for 'SequentialFuture' ... done
[15:31:04.649] Future #1
[15:31:04.651] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:31:04.651] - nx: 1
[15:31:04.651] - relay: TRUE
[15:31:04.651] - stdout: TRUE
[15:31:04.652] - signal: TRUE
[15:31:04.652] - resignal: FALSE
[15:31:04.652] - force: TRUE
[15:31:04.652] - relayed: [n=1] FALSE
[15:31:04.652] - queued futures: [n=1] FALSE
[15:31:04.653]  - until=1
[15:31:04.653]  - relaying element #1
[15:31:04.653] - relayed: [n=1] TRUE
[15:31:04.653] - queued futures: [n=1] TRUE
[15:31:04.654] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:31:04.654]  length: 0 (resolved future 1)
[15:31:04.654] Relaying remaining futures
[15:31:04.654] signalConditionsASAP(NULL, pos=0) ...
[15:31:04.654] - nx: 1
[15:31:04.654] - relay: TRUE
[15:31:04.655] - stdout: TRUE
[15:31:04.655] - signal: TRUE
[15:31:04.655] - resignal: FALSE
[15:31:04.655] - force: TRUE
[15:31:04.655] - relayed: [n=1] TRUE
[15:31:04.656] - queued futures: [n=1] TRUE
 - flush all
[15:31:04.656] - relayed: [n=1] TRUE
[15:31:04.656] - queued futures: [n=1] TRUE
[15:31:04.656] signalConditionsASAP(NULL, pos=0) ... done
[15:31:04.657] resolve() on list ... DONE
[15:31:04.657]  - Number of value chunks collected: 1
[15:31:04.657] Resolving 1 futures (chunks) ... DONE
[15:31:04.657] Reducing values from 1 chunks ...
[15:31:04.657]  - Number of values collected after concatenation: 6
[15:31:04.658]  - Number of values expected: 6
[15:31:04.658] Reducing values from 1 chunks ... DONE
[15:31:04.658] future_lapply() ... DONE
, , C = cop.1

      col
row    x1 x2
  [1,]  3  4
  [2,]  3  3
  [3,]  3  2
  [4,]  3  1
  [5,]  3  2
  [6,]  3  3
  [7,]  3  4
  [8,]  3  5

, , C = cop.2

      col
row    x1 x2
  [1,]  3  4
  [2,]  3  3
  [3,]  3  2
  [4,]  3  1
  [5,]  3  2
  [6,]  3  3
  [7,]  3  4
  [8,]  3  5

, , C = cop.3

      col
row    x1 x2
  [1,]  3  4
  [2,]  3  3
  [3,]  3  2
  [4,]  3  1
  [5,]  3  2
  [6,]  3  3
  [7,]  3  4
  [8,]  3  5

[15:31:04.659] getGlobalsAndPackagesXApply() ...
[15:31:04.659]  - future.globals: TRUE
[15:31:04.659] getGlobalsAndPackages() ...
[15:31:04.659] Searching for globals...
[15:31:04.661] - globals found: [3] 'FUN', 'seq_len', 'max'
[15:31:04.661] Searching for globals ... DONE
[15:31:04.662] Resolving globals: FALSE
[15:31:04.662] The total size of the 1 globals is 1.73 KiB (1768 bytes)
[15:31:04.663] The total size of the 1 globals exported for future expression ('FUN(X = structure(1:24, dim = 2:4))') is 1.73 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.73 KiB of class 'function')
[15:31:04.663] - globals: [1] 'FUN'
[15:31:04.663] 
[15:31:04.663] getGlobalsAndPackages() ... DONE
[15:31:04.664]  - globals found/used: [n=1] 'FUN'
[15:31:04.664]  - needed namespaces: [n=0] 
[15:31:04.664] Finding globals ... DONE
[15:31:04.664]  - use_args: TRUE
[15:31:04.664]  - Getting '...' globals ...
[15:31:04.665] resolve() on list ...
[15:31:04.665]  recursive: 0
[15:31:04.665]  length: 1
[15:31:04.665]  elements: '...'
[15:31:04.666]  length: 0 (resolved future 1)
[15:31:04.666] resolve() on list ... DONE
[15:31:04.666]    - '...' content: [n=0] 
[15:31:04.666] List of 1
[15:31:04.666]  $ ...: list()
[15:31:04.666]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:04.666]  - attr(*, "where")=List of 1
[15:31:04.666]   ..$ ...:<environment: 0x000001bcb7f9be28> 
[15:31:04.666]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:04.666]  - attr(*, "resolved")= logi TRUE
[15:31:04.666]  - attr(*, "total_size")= num NA
[15:31:04.670]  - Getting '...' globals ... DONE
[15:31:04.670] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:04.671] List of 2
[15:31:04.671]  $ ...future.FUN:function (x)  
[15:31:04.671]  $ ...          : list()
[15:31:04.671]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:04.671]  - attr(*, "where")=List of 2
[15:31:04.671]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:04.671]   ..$ ...          :<environment: 0x000001bcb7f9be28> 
[15:31:04.671]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:04.671]  - attr(*, "resolved")= logi FALSE
[15:31:04.671]  - attr(*, "total_size")= num 1768
[15:31:04.674] Packages to be attached in all futures: [n=0] 
[15:31:04.674] getGlobalsAndPackagesXApply() ... DONE
[15:31:04.675] future_lapply() ...
[15:31:04.676] Number of chunks: 1
[15:31:04.676] getGlobalsAndPackagesXApply() ...
[15:31:04.676]  - future.globals: <name-value list> with names 'list()'
[15:31:04.676]  - use_args: TRUE
[15:31:04.677] Globals to be used in all futures (chunks): [n=2] '...', '...future.FUN'
[15:31:04.677] List of 2
[15:31:04.677]  $ ...          : list()
[15:31:04.677]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:04.677]  $ ...future.FUN:function (x)  
[15:31:04.677]  - attr(*, "where")=List of 2
[15:31:04.677]   ..$ ...          :<environment: 0x000001bcb7f9be28> 
[15:31:04.677]   ..$ ...future.FUN:<environment: R_GlobalEnv> 
[15:31:04.677]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:04.677]  - attr(*, "resolved")= logi FALSE
[15:31:04.677]  - attr(*, "total_size")= num NA
[15:31:04.682] Packages to be attached in all futures: [n=0] 
[15:31:04.683] getGlobalsAndPackagesXApply() ... DONE
[15:31:04.683] Number of futures (= number of chunks): 1
[15:31:04.683] Launching 1 futures (chunks) ...
[15:31:04.683] Chunk #1 of 1 ...
[15:31:04.684]  - seeds: <none>
[15:31:04.684]  - All globals exported: [n=5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:04.684] getGlobalsAndPackages() ...
[15:31:04.684] - globals passed as-is: [5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:04.685] Resolving globals: FALSE
[15:31:04.685] Tweak future expression to call with '...' arguments ...
[15:31:04.685] {
[15:31:04.685]     do.call(function(...) {
[15:31:04.685]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:04.685]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:04.685]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:04.685]             on.exit(options(oopts), add = TRUE)
[15:31:04.685]         }
[15:31:04.685]         {
[15:31:04.685]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:04.685]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:04.685]                 ...future.FUN(...future.X_jj, ...)
[15:31:04.685]             })
[15:31:04.685]         }
[15:31:04.685]     }, args = future.call.arguments)
[15:31:04.685] }
[15:31:04.685] Tweak future expression to call with '...' arguments ... DONE
[15:31:04.686] - globals: [5] 'future.call.arguments', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:04.686] 
[15:31:04.687] getGlobalsAndPackages() ... DONE
[15:31:04.687] run() for 'Future' ...
[15:31:04.687] - state: 'created'
[15:31:04.688] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:31:04.688] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:04.689] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:31:04.689]   - Field: 'label'
[15:31:04.689]   - Field: 'local'
[15:31:04.689]   - Field: 'owner'
[15:31:04.690]   - Field: 'envir'
[15:31:04.690]   - Field: 'packages'
[15:31:04.690]   - Field: 'gc'
[15:31:04.691]   - Field: 'conditions'
[15:31:04.691]   - Field: 'expr'
[15:31:04.692]   - Field: 'uuid'
[15:31:04.692]   - Field: 'seed'
[15:31:04.693]   - Field: 'version'
[15:31:04.693]   - Field: 'result'
[15:31:04.693]   - Field: 'asynchronous'
[15:31:04.694]   - Field: 'calls'
[15:31:04.694]   - Field: 'globals'
[15:31:04.694]   - Field: 'stdout'
[15:31:04.695]   - Field: 'earlySignal'
[15:31:04.695]   - Field: 'lazy'
[15:31:04.696]   - Field: 'state'
[15:31:04.696] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:31:04.697] - Launch lazy future ...
[15:31:04.697] Packages needed by the future expression (n = 0): <none>
[15:31:04.698] Packages needed by future strategies (n = 0): <none>
[15:31:04.699] {
[15:31:04.699]     {
[15:31:04.699]         {
[15:31:04.699]             ...future.startTime <- base::Sys.time()
[15:31:04.699]             {
[15:31:04.699]                 {
[15:31:04.699]                   {
[15:31:04.699]                     base::local({
[15:31:04.699]                       has_future <- base::requireNamespace("future", 
[15:31:04.699]                         quietly = TRUE)
[15:31:04.699]                       if (has_future) {
[15:31:04.699]                         ns <- base::getNamespace("future")
[15:31:04.699]                         version <- ns[[".package"]][["version"]]
[15:31:04.699]                         if (is.null(version)) 
[15:31:04.699]                           version <- utils::packageVersion("future")
[15:31:04.699]                       }
[15:31:04.699]                       else {
[15:31:04.699]                         version <- NULL
[15:31:04.699]                       }
[15:31:04.699]                       if (!has_future || version < "1.8.0") {
[15:31:04.699]                         info <- base::c(r_version = base::gsub("R version ", 
[15:31:04.699]                           "", base::R.version$version.string), 
[15:31:04.699]                           platform = base::sprintf("%s (%s-bit)", 
[15:31:04.699]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:04.699]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:04.699]                             "release", "version")], collapse = " "), 
[15:31:04.699]                           hostname = base::Sys.info()[["nodename"]])
[15:31:04.699]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:31:04.699]                           info)
[15:31:04.699]                         info <- base::paste(info, collapse = "; ")
[15:31:04.699]                         if (!has_future) {
[15:31:04.699]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:04.699]                             info)
[15:31:04.699]                         }
[15:31:04.699]                         else {
[15:31:04.699]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:04.699]                             info, version)
[15:31:04.699]                         }
[15:31:04.699]                         base::stop(msg)
[15:31:04.699]                       }
[15:31:04.699]                     })
[15:31:04.699]                   }
[15:31:04.699]                   ...future.strategy.old <- future::plan("list")
[15:31:04.699]                   options(future.plan = NULL)
[15:31:04.699]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:04.699]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:04.699]                 }
[15:31:04.699]                 ...future.workdir <- getwd()
[15:31:04.699]             }
[15:31:04.699]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:04.699]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:04.699]         }
[15:31:04.699]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:04.699]             future.globals.maxSize = Inf, future.globals.method = NULL, 
[15:31:04.699]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:04.699]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:04.699]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:04.699]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:04.699]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:04.699]             base::names(...future.oldOptions))
[15:31:04.699]     }
[15:31:04.699]     if (FALSE) {
[15:31:04.699]     }
[15:31:04.699]     else {
[15:31:04.699]         if (TRUE) {
[15:31:04.699]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:04.699]                 open = "w")
[15:31:04.699]         }
[15:31:04.699]         else {
[15:31:04.699]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:04.699]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:04.699]         }
[15:31:04.699]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:04.699]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:04.699]             base::sink(type = "output", split = FALSE)
[15:31:04.699]             base::close(...future.stdout)
[15:31:04.699]         }, add = TRUE)
[15:31:04.699]     }
[15:31:04.699]     ...future.frame <- base::sys.nframe()
[15:31:04.699]     ...future.conditions <- base::list()
[15:31:04.699]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:04.699]     if (FALSE) {
[15:31:04.699]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:04.699]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:04.699]     }
[15:31:04.699]     ...future.result <- base::tryCatch({
[15:31:04.699]         base::withCallingHandlers({
[15:31:04.699]             ...future.value <- base::withVisible(base::local({
[15:31:04.699]                 do.call(function(...) {
[15:31:04.699]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:04.699]                   if (!identical(...future.globals.maxSize.org, 
[15:31:04.699]                     ...future.globals.maxSize)) {
[15:31:04.699]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:04.699]                     on.exit(options(oopts), add = TRUE)
[15:31:04.699]                   }
[15:31:04.699]                   {
[15:31:04.699]                     lapply(seq_along(...future.elements_ii), 
[15:31:04.699]                       FUN = function(jj) {
[15:31:04.699]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:04.699]                         ...future.FUN(...future.X_jj, ...)
[15:31:04.699]                       })
[15:31:04.699]                   }
[15:31:04.699]                 }, args = future.call.arguments)
[15:31:04.699]             }))
[15:31:04.699]             future::FutureResult(value = ...future.value$value, 
[15:31:04.699]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:04.699]                   ...future.rng), globalenv = if (FALSE) 
[15:31:04.699]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:04.699]                     ...future.globalenv.names))
[15:31:04.699]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:04.699]         }, condition = base::local({
[15:31:04.699]             c <- base::c
[15:31:04.699]             inherits <- base::inherits
[15:31:04.699]             invokeRestart <- base::invokeRestart
[15:31:04.699]             length <- base::length
[15:31:04.699]             list <- base::list
[15:31:04.699]             seq.int <- base::seq.int
[15:31:04.699]             signalCondition <- base::signalCondition
[15:31:04.699]             sys.calls <- base::sys.calls
[15:31:04.699]             `[[` <- base::`[[`
[15:31:04.699]             `+` <- base::`+`
[15:31:04.699]             `<<-` <- base::`<<-`
[15:31:04.699]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:04.699]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:04.699]                   3L)]
[15:31:04.699]             }
[15:31:04.699]             function(cond) {
[15:31:04.699]                 is_error <- inherits(cond, "error")
[15:31:04.699]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:04.699]                   NULL)
[15:31:04.699]                 if (is_error) {
[15:31:04.699]                   sessionInformation <- function() {
[15:31:04.699]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:04.699]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:04.699]                       search = base::search(), system = base::Sys.info())
[15:31:04.699]                   }
[15:31:04.699]                   ...future.conditions[[length(...future.conditions) + 
[15:31:04.699]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:04.699]                     cond$call), session = sessionInformation(), 
[15:31:04.699]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:04.699]                   signalCondition(cond)
[15:31:04.699]                 }
[15:31:04.699]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:04.699]                 "immediateCondition"))) {
[15:31:04.699]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:04.699]                   ...future.conditions[[length(...future.conditions) + 
[15:31:04.699]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:04.699]                   if (TRUE && !signal) {
[15:31:04.699]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:04.699]                     {
[15:31:04.699]                       inherits <- base::inherits
[15:31:04.699]                       invokeRestart <- base::invokeRestart
[15:31:04.699]                       is.null <- base::is.null
[15:31:04.699]                       muffled <- FALSE
[15:31:04.699]                       if (inherits(cond, "message")) {
[15:31:04.699]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:04.699]                         if (muffled) 
[15:31:04.699]                           invokeRestart("muffleMessage")
[15:31:04.699]                       }
[15:31:04.699]                       else if (inherits(cond, "warning")) {
[15:31:04.699]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:04.699]                         if (muffled) 
[15:31:04.699]                           invokeRestart("muffleWarning")
[15:31:04.699]                       }
[15:31:04.699]                       else if (inherits(cond, "condition")) {
[15:31:04.699]                         if (!is.null(pattern)) {
[15:31:04.699]                           computeRestarts <- base::computeRestarts
[15:31:04.699]                           grepl <- base::grepl
[15:31:04.699]                           restarts <- computeRestarts(cond)
[15:31:04.699]                           for (restart in restarts) {
[15:31:04.699]                             name <- restart$name
[15:31:04.699]                             if (is.null(name)) 
[15:31:04.699]                               next
[15:31:04.699]                             if (!grepl(pattern, name)) 
[15:31:04.699]                               next
[15:31:04.699]                             invokeRestart(restart)
[15:31:04.699]                             muffled <- TRUE
[15:31:04.699]                             break
[15:31:04.699]                           }
[15:31:04.699]                         }
[15:31:04.699]                       }
[15:31:04.699]                       invisible(muffled)
[15:31:04.699]                     }
[15:31:04.699]                     muffleCondition(cond, pattern = "^muffle")
[15:31:04.699]                   }
[15:31:04.699]                 }
[15:31:04.699]                 else {
[15:31:04.699]                   if (TRUE) {
[15:31:04.699]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:04.699]                     {
[15:31:04.699]                       inherits <- base::inherits
[15:31:04.699]                       invokeRestart <- base::invokeRestart
[15:31:04.699]                       is.null <- base::is.null
[15:31:04.699]                       muffled <- FALSE
[15:31:04.699]                       if (inherits(cond, "message")) {
[15:31:04.699]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:04.699]                         if (muffled) 
[15:31:04.699]                           invokeRestart("muffleMessage")
[15:31:04.699]                       }
[15:31:04.699]                       else if (inherits(cond, "warning")) {
[15:31:04.699]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:04.699]                         if (muffled) 
[15:31:04.699]                           invokeRestart("muffleWarning")
[15:31:04.699]                       }
[15:31:04.699]                       else if (inherits(cond, "condition")) {
[15:31:04.699]                         if (!is.null(pattern)) {
[15:31:04.699]                           computeRestarts <- base::computeRestarts
[15:31:04.699]                           grepl <- base::grepl
[15:31:04.699]                           restarts <- computeRestarts(cond)
[15:31:04.699]                           for (restart in restarts) {
[15:31:04.699]                             name <- restart$name
[15:31:04.699]                             if (is.null(name)) 
[15:31:04.699]                               next
[15:31:04.699]                             if (!grepl(pattern, name)) 
[15:31:04.699]                               next
[15:31:04.699]                             invokeRestart(restart)
[15:31:04.699]                             muffled <- TRUE
[15:31:04.699]                             break
[15:31:04.699]                           }
[15:31:04.699]                         }
[15:31:04.699]                       }
[15:31:04.699]                       invisible(muffled)
[15:31:04.699]                     }
[15:31:04.699]                     muffleCondition(cond, pattern = "^muffle")
[15:31:04.699]                   }
[15:31:04.699]                 }
[15:31:04.699]             }
[15:31:04.699]         }))
[15:31:04.699]     }, error = function(ex) {
[15:31:04.699]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:04.699]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:04.699]                 ...future.rng), started = ...future.startTime, 
[15:31:04.699]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:04.699]             version = "1.8"), class = "FutureResult")
[15:31:04.699]     }, finally = {
[15:31:04.699]         if (!identical(...future.workdir, getwd())) 
[15:31:04.699]             setwd(...future.workdir)
[15:31:04.699]         {
[15:31:04.699]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:04.699]                 ...future.oldOptions$nwarnings <- NULL
[15:31:04.699]             }
[15:31:04.699]             base::options(...future.oldOptions)
[15:31:04.699]             if (.Platform$OS.type == "windows") {
[15:31:04.699]                 old_names <- names(...future.oldEnvVars)
[15:31:04.699]                 envs <- base::Sys.getenv()
[15:31:04.699]                 names <- names(envs)
[15:31:04.699]                 common <- intersect(names, old_names)
[15:31:04.699]                 added <- setdiff(names, old_names)
[15:31:04.699]                 removed <- setdiff(old_names, names)
[15:31:04.699]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:04.699]                   envs[common]]
[15:31:04.699]                 NAMES <- toupper(changed)
[15:31:04.699]                 args <- list()
[15:31:04.699]                 for (kk in seq_along(NAMES)) {
[15:31:04.699]                   name <- changed[[kk]]
[15:31:04.699]                   NAME <- NAMES[[kk]]
[15:31:04.699]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:04.699]                     next
[15:31:04.699]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:04.699]                 }
[15:31:04.699]                 NAMES <- toupper(added)
[15:31:04.699]                 for (kk in seq_along(NAMES)) {
[15:31:04.699]                   name <- added[[kk]]
[15:31:04.699]                   NAME <- NAMES[[kk]]
[15:31:04.699]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:04.699]                     next
[15:31:04.699]                   args[[name]] <- ""
[15:31:04.699]                 }
[15:31:04.699]                 NAMES <- toupper(removed)
[15:31:04.699]                 for (kk in seq_along(NAMES)) {
[15:31:04.699]                   name <- removed[[kk]]
[15:31:04.699]                   NAME <- NAMES[[kk]]
[15:31:04.699]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:04.699]                     next
[15:31:04.699]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:04.699]                 }
[15:31:04.699]                 if (length(args) > 0) 
[15:31:04.699]                   base::do.call(base::Sys.setenv, args = args)
[15:31:04.699]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:04.699]             }
[15:31:04.699]             else {
[15:31:04.699]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:04.699]             }
[15:31:04.699]             {
[15:31:04.699]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:04.699]                   0L) {
[15:31:04.699]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:04.699]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:04.699]                   base::options(opts)
[15:31:04.699]                 }
[15:31:04.699]                 {
[15:31:04.699]                   {
[15:31:04.699]                     NULL
[15:31:04.699]                     RNGkind("Mersenne-Twister")
[15:31:04.699]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:31:04.699]                       inherits = FALSE)
[15:31:04.699]                   }
[15:31:04.699]                   options(future.plan = NULL)
[15:31:04.699]                   if (is.na(NA_character_)) 
[15:31:04.699]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:04.699]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:04.699]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:04.699]                     .init = FALSE)
[15:31:04.699]                 }
[15:31:04.699]             }
[15:31:04.699]         }
[15:31:04.699]     })
[15:31:04.699]     if (TRUE) {
[15:31:04.699]         base::sink(type = "output", split = FALSE)
[15:31:04.699]         if (TRUE) {
[15:31:04.699]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:04.699]         }
[15:31:04.699]         else {
[15:31:04.699]             ...future.result["stdout"] <- base::list(NULL)
[15:31:04.699]         }
[15:31:04.699]         base::close(...future.stdout)
[15:31:04.699]         ...future.stdout <- NULL
[15:31:04.699]     }
[15:31:04.699]     ...future.result$conditions <- ...future.conditions
[15:31:04.699]     ...future.result$finished <- base::Sys.time()
[15:31:04.699]     ...future.result
[15:31:04.699] }
[15:31:04.706] assign_globals() ...
[15:31:04.706] List of 5
[15:31:04.706]  $ future.call.arguments    : list()
[15:31:04.706]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:04.706]  $ ...future.FUN            :function (x)  
[15:31:04.706]  $ ...future.elements_ii    :List of 6
[15:31:04.706]   ..$ : int [1:4] 1 7 13 19
[15:31:04.706]   ..$ : int [1:4] 2 8 14 20
[15:31:04.706]   ..$ : int [1:4] 3 9 15 21
[15:31:04.706]   ..$ : int [1:4] 4 10 16 22
[15:31:04.706]   ..$ : int [1:4] 5 11 17 23
[15:31:04.706]   ..$ : int [1:4] 6 12 18 24
[15:31:04.706]  $ ...future.seeds_ii       : NULL
[15:31:04.706]  $ ...future.globals.maxSize: num Inf
[15:31:04.706]  - attr(*, "resolved")= logi FALSE
[15:31:04.706]  - attr(*, "total_size")= num NA
[15:31:04.706]  - attr(*, "where")=List of 5
[15:31:04.706]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:31:04.706]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:31:04.706]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:31:04.706]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:31:04.706]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:31:04.706]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:04.706]  - attr(*, "already-done")= logi TRUE
[15:31:04.722] - copied 'future.call.arguments' to environment
[15:31:04.723] - reassign environment for '...future.FUN'
[15:31:04.723] - copied '...future.FUN' to environment
[15:31:04.723] - copied '...future.elements_ii' to environment
[15:31:04.723] - copied '...future.seeds_ii' to environment
[15:31:04.723] - copied '...future.globals.maxSize' to environment
[15:31:04.724] assign_globals() ... done
[15:31:04.724] plan(): Setting new future strategy stack:
[15:31:04.724] List of future strategies:
[15:31:04.724] 1. sequential:
[15:31:04.724]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:04.724]    - tweaked: FALSE
[15:31:04.724]    - call: NULL
[15:31:04.725] plan(): nbrOfWorkers() = 1
[15:31:04.727] plan(): Setting new future strategy stack:
[15:31:04.727] List of future strategies:
[15:31:04.727] 1. sequential:
[15:31:04.727]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:04.727]    - tweaked: FALSE
[15:31:04.727]    - call: plan(strategy)
[15:31:04.728] plan(): nbrOfWorkers() = 1
[15:31:04.728] SequentialFuture started (and completed)
[15:31:04.728] - Launch lazy future ... done
[15:31:04.729] run() for 'SequentialFuture' ... done
[15:31:04.729] Created future:
[15:31:04.729] SequentialFuture:
[15:31:04.729] Label: 'future_apply-1'
[15:31:04.729] Expression:
[15:31:04.729] {
[15:31:04.729]     do.call(function(...) {
[15:31:04.729]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:04.729]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:04.729]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:04.729]             on.exit(options(oopts), add = TRUE)
[15:31:04.729]         }
[15:31:04.729]         {
[15:31:04.729]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:04.729]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:04.729]                 ...future.FUN(...future.X_jj, ...)
[15:31:04.729]             })
[15:31:04.729]         }
[15:31:04.729]     }, args = future.call.arguments)
[15:31:04.729] }
[15:31:04.729] Lazy evaluation: FALSE
[15:31:04.729] Asynchronous evaluation: FALSE
[15:31:04.729] Local evaluation: TRUE
[15:31:04.729] Environment: R_GlobalEnv
[15:31:04.729] Capture standard output: TRUE
[15:31:04.729] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:04.729] Globals: 5 objects totaling 2.16 KiB (DotDotDotList 'future.call.arguments' of 0 bytes, function '...future.FUN' of 1.73 KiB, list '...future.elements_ii' of 384 bytes, NULL '...future.seeds_ii' of 0 bytes, numeric '...future.globals.maxSize' of 56 bytes)
[15:31:04.729] Packages: <none>
[15:31:04.729] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:04.729] Resolved: TRUE
[15:31:04.729] Value: 1.03 KiB of class 'list'
[15:31:04.729] Early signaling: FALSE
[15:31:04.729] Owner process: 6672a580-6d3c-e82f-380e-108c475ace70
[15:31:04.729] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:04.735] Chunk #1 of 1 ... DONE
[15:31:04.735] Launching 1 futures (chunks) ... DONE
[15:31:04.736] Resolving 1 futures (chunks) ...
[15:31:04.736] resolve() on list ...
[15:31:04.737]  recursive: 0
[15:31:04.737]  length: 1
[15:31:04.738] 
[15:31:04.738] resolved() for 'SequentialFuture' ...
[15:31:04.738] - state: 'finished'
[15:31:04.739] - run: TRUE
[15:31:04.739] - result: 'FutureResult'
[15:31:04.739] resolved() for 'SequentialFuture' ... done
[15:31:04.740] Future #1
[15:31:04.740] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:31:04.741] - nx: 1
[15:31:04.741] - relay: TRUE
[15:31:04.741] - stdout: TRUE
[15:31:04.741] - signal: TRUE
[15:31:04.742] - resignal: FALSE
[15:31:04.742] - force: TRUE
[15:31:04.742] - relayed: [n=1] FALSE
[15:31:04.743] - queued futures: [n=1] FALSE
[15:31:04.743]  - until=1
[15:31:04.743]  - relaying element #1
[15:31:04.744] - relayed: [n=1] TRUE
[15:31:04.744] - queued futures: [n=1] TRUE
[15:31:04.744] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:31:04.745]  length: 0 (resolved future 1)
[15:31:04.745] Relaying remaining futures
[15:31:04.745] signalConditionsASAP(NULL, pos=0) ...
[15:31:04.746] - nx: 1
[15:31:04.746] - relay: TRUE
[15:31:04.746] - stdout: TRUE
[15:31:04.746] - signal: TRUE
[15:31:04.747] - resignal: FALSE
[15:31:04.747] - force: TRUE
[15:31:04.747] - relayed: [n=1] TRUE
[15:31:04.748] - queued futures: [n=1] TRUE
 - flush all
[15:31:04.748] - relayed: [n=1] TRUE
[15:31:04.748] - queued futures: [n=1] TRUE
[15:31:04.749] signalConditionsASAP(NULL, pos=0) ... done
[15:31:04.749] resolve() on list ... DONE
[15:31:04.749]  - Number of value chunks collected: 1
[15:31:04.750] Resolving 1 futures (chunks) ... DONE
[15:31:04.750] Reducing values from 1 chunks ...
[15:31:04.750]  - Number of values collected after concatenation: 6
[15:31:04.751]  - Number of values expected: 6
[15:31:04.751] Reducing values from 1 chunks ... DONE
[15:31:04.752] future_lapply() ... DONE
     [,1]       [,2]       [,3]      
[1,] integer,19 integer,21 integer,23
[2,] integer,20 integer,22 integer,24
- apply(X, MARGIN = <character>, ...) ...
[15:31:04.752] getGlobalsAndPackagesXApply() ...
[15:31:04.753]  - future.globals: TRUE
[15:31:04.753] getGlobalsAndPackages() ...
[15:31:04.753] Searching for globals...
[15:31:04.756] - globals found: [1] 'FUN'
[15:31:04.756] Searching for globals ... DONE
[15:31:04.756] Resolving globals: FALSE
[15:31:04.757] The total size of the 1 globals is 848 bytes (848 bytes)
[15:31:04.758] The total size of the 1 globals exported for future expression ('FUN(X = structure(1:2, dim = 2:1, dimnames = list(rows = c("a",; "b"), NULL)))') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:31:04.758] - globals: [1] 'FUN'
[15:31:04.759] 
[15:31:04.759] getGlobalsAndPackages() ... DONE
[15:31:04.759]  - globals found/used: [n=1] 'FUN'
[15:31:04.760]  - needed namespaces: [n=0] 
[15:31:04.760] Finding globals ... DONE
[15:31:04.760]  - use_args: TRUE
[15:31:04.761]  - Getting '...' globals ...
[15:31:04.761] resolve() on list ...
[15:31:04.762]  recursive: 0
[15:31:04.762]  length: 1
[15:31:04.762]  elements: '...'
[15:31:04.763]  length: 0 (resolved future 1)
[15:31:04.763] resolve() on list ... DONE
[15:31:04.763]    - '...' content: [n=0] 
[15:31:04.764] List of 1
[15:31:04.764]  $ ...: list()
[15:31:04.764]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:04.764]  - attr(*, "where")=List of 1
[15:31:04.764]   ..$ ...:<environment: 0x000001bcb7916848> 
[15:31:04.764]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:04.764]  - attr(*, "resolved")= logi TRUE
[15:31:04.764]  - attr(*, "total_size")= num NA
[15:31:04.768]  - Getting '...' globals ... DONE
[15:31:04.769] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:04.769] List of 2
[15:31:04.769]  $ ...future.FUN:function (x)  
[15:31:04.769]  $ ...          : list()
[15:31:04.769]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:04.769]  - attr(*, "where")=List of 2
[15:31:04.769]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:04.769]   ..$ ...          :<environment: 0x000001bcb7916848> 
[15:31:04.769]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:04.769]  - attr(*, "resolved")= logi FALSE
[15:31:04.769]  - attr(*, "total_size")= num 848
[15:31:04.774] Packages to be attached in all futures: [n=0] 
[15:31:04.774] getGlobalsAndPackagesXApply() ... DONE
[15:31:04.775] future_lapply() ...
[15:31:04.776] Number of chunks: 1
[15:31:04.776] getGlobalsAndPackagesXApply() ...
[15:31:04.776]  - future.globals: <name-value list> with names 'list()'
[15:31:04.777]  - use_args: TRUE
[15:31:04.777] Globals to be used in all futures (chunks): [n=2] '...', '...future.FUN'
[15:31:04.778] List of 2
[15:31:04.778]  $ ...          : list()
[15:31:04.778]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:04.778]  $ ...future.FUN:function (x)  
[15:31:04.778]  - attr(*, "where")=List of 2
[15:31:04.778]   ..$ ...          :<environment: 0x000001bcb7916848> 
[15:31:04.778]   ..$ ...future.FUN:<environment: namespace:base> 
[15:31:04.778]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:04.778]  - attr(*, "resolved")= logi FALSE
[15:31:04.778]  - attr(*, "total_size")= num NA
[15:31:04.790] Packages to be attached in all futures: [n=0] 
[15:31:04.791] getGlobalsAndPackagesXApply() ... DONE
[15:31:04.791] Number of futures (= number of chunks): 1
[15:31:04.791] Launching 1 futures (chunks) ...
[15:31:04.792] Chunk #1 of 1 ...
[15:31:04.792]  - seeds: <none>
[15:31:04.792]  - All globals exported: [n=5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:04.792] getGlobalsAndPackages() ...
[15:31:04.793] - globals passed as-is: [5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:04.793] Resolving globals: FALSE
[15:31:04.793] Tweak future expression to call with '...' arguments ...
[15:31:04.794] {
[15:31:04.794]     do.call(function(...) {
[15:31:04.794]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:04.794]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:04.794]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:04.794]             on.exit(options(oopts), add = TRUE)
[15:31:04.794]         }
[15:31:04.794]         {
[15:31:04.794]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:04.794]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:04.794]                 ...future.FUN(...future.X_jj, ...)
[15:31:04.794]             })
[15:31:04.794]         }
[15:31:04.794]     }, args = future.call.arguments)
[15:31:04.794] }
[15:31:04.794] Tweak future expression to call with '...' arguments ... DONE
[15:31:04.795] - globals: [5] 'future.call.arguments', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:04.795] 
[15:31:04.796] getGlobalsAndPackages() ... DONE
[15:31:04.796] run() for 'Future' ...
[15:31:04.797] - state: 'created'
[15:31:04.797] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:31:04.798] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:04.798] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:31:04.798]   - Field: 'label'
[15:31:04.799]   - Field: 'local'
[15:31:04.799]   - Field: 'owner'
[15:31:04.799]   - Field: 'envir'
[15:31:04.800]   - Field: 'packages'
[15:31:04.800]   - Field: 'gc'
[15:31:04.800]   - Field: 'conditions'
[15:31:04.801]   - Field: 'expr'
[15:31:04.801]   - Field: 'uuid'
[15:31:04.801]   - Field: 'seed'
[15:31:04.802]   - Field: 'version'
[15:31:04.802]   - Field: 'result'
[15:31:04.802]   - Field: 'asynchronous'
[15:31:04.803]   - Field: 'calls'
[15:31:04.803]   - Field: 'globals'
[15:31:04.803]   - Field: 'stdout'
[15:31:04.803]   - Field: 'earlySignal'
[15:31:04.804]   - Field: 'lazy'
[15:31:04.804]   - Field: 'state'
[15:31:04.804] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:31:04.805] - Launch lazy future ...
[15:31:04.805] Packages needed by the future expression (n = 0): <none>
[15:31:04.805] Packages needed by future strategies (n = 0): <none>
[15:31:04.807] {
[15:31:04.807]     {
[15:31:04.807]         {
[15:31:04.807]             ...future.startTime <- base::Sys.time()
[15:31:04.807]             {
[15:31:04.807]                 {
[15:31:04.807]                   {
[15:31:04.807]                     base::local({
[15:31:04.807]                       has_future <- base::requireNamespace("future", 
[15:31:04.807]                         quietly = TRUE)
[15:31:04.807]                       if (has_future) {
[15:31:04.807]                         ns <- base::getNamespace("future")
[15:31:04.807]                         version <- ns[[".package"]][["version"]]
[15:31:04.807]                         if (is.null(version)) 
[15:31:04.807]                           version <- utils::packageVersion("future")
[15:31:04.807]                       }
[15:31:04.807]                       else {
[15:31:04.807]                         version <- NULL
[15:31:04.807]                       }
[15:31:04.807]                       if (!has_future || version < "1.8.0") {
[15:31:04.807]                         info <- base::c(r_version = base::gsub("R version ", 
[15:31:04.807]                           "", base::R.version$version.string), 
[15:31:04.807]                           platform = base::sprintf("%s (%s-bit)", 
[15:31:04.807]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:04.807]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:04.807]                             "release", "version")], collapse = " "), 
[15:31:04.807]                           hostname = base::Sys.info()[["nodename"]])
[15:31:04.807]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:31:04.807]                           info)
[15:31:04.807]                         info <- base::paste(info, collapse = "; ")
[15:31:04.807]                         if (!has_future) {
[15:31:04.807]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:04.807]                             info)
[15:31:04.807]                         }
[15:31:04.807]                         else {
[15:31:04.807]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:04.807]                             info, version)
[15:31:04.807]                         }
[15:31:04.807]                         base::stop(msg)
[15:31:04.807]                       }
[15:31:04.807]                     })
[15:31:04.807]                   }
[15:31:04.807]                   ...future.strategy.old <- future::plan("list")
[15:31:04.807]                   options(future.plan = NULL)
[15:31:04.807]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:04.807]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:04.807]                 }
[15:31:04.807]                 ...future.workdir <- getwd()
[15:31:04.807]             }
[15:31:04.807]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:04.807]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:04.807]         }
[15:31:04.807]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:04.807]             future.globals.maxSize = Inf, future.globals.method = NULL, 
[15:31:04.807]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:04.807]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:04.807]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:04.807]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:04.807]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:04.807]             base::names(...future.oldOptions))
[15:31:04.807]     }
[15:31:04.807]     if (FALSE) {
[15:31:04.807]     }
[15:31:04.807]     else {
[15:31:04.807]         if (TRUE) {
[15:31:04.807]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:04.807]                 open = "w")
[15:31:04.807]         }
[15:31:04.807]         else {
[15:31:04.807]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:04.807]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:04.807]         }
[15:31:04.807]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:04.807]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:04.807]             base::sink(type = "output", split = FALSE)
[15:31:04.807]             base::close(...future.stdout)
[15:31:04.807]         }, add = TRUE)
[15:31:04.807]     }
[15:31:04.807]     ...future.frame <- base::sys.nframe()
[15:31:04.807]     ...future.conditions <- base::list()
[15:31:04.807]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:04.807]     if (FALSE) {
[15:31:04.807]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:04.807]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:04.807]     }
[15:31:04.807]     ...future.result <- base::tryCatch({
[15:31:04.807]         base::withCallingHandlers({
[15:31:04.807]             ...future.value <- base::withVisible(base::local({
[15:31:04.807]                 do.call(function(...) {
[15:31:04.807]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:04.807]                   if (!identical(...future.globals.maxSize.org, 
[15:31:04.807]                     ...future.globals.maxSize)) {
[15:31:04.807]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:04.807]                     on.exit(options(oopts), add = TRUE)
[15:31:04.807]                   }
[15:31:04.807]                   {
[15:31:04.807]                     lapply(seq_along(...future.elements_ii), 
[15:31:04.807]                       FUN = function(jj) {
[15:31:04.807]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:04.807]                         ...future.FUN(...future.X_jj, ...)
[15:31:04.807]                       })
[15:31:04.807]                   }
[15:31:04.807]                 }, args = future.call.arguments)
[15:31:04.807]             }))
[15:31:04.807]             future::FutureResult(value = ...future.value$value, 
[15:31:04.807]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:04.807]                   ...future.rng), globalenv = if (FALSE) 
[15:31:04.807]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:04.807]                     ...future.globalenv.names))
[15:31:04.807]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:04.807]         }, condition = base::local({
[15:31:04.807]             c <- base::c
[15:31:04.807]             inherits <- base::inherits
[15:31:04.807]             invokeRestart <- base::invokeRestart
[15:31:04.807]             length <- base::length
[15:31:04.807]             list <- base::list
[15:31:04.807]             seq.int <- base::seq.int
[15:31:04.807]             signalCondition <- base::signalCondition
[15:31:04.807]             sys.calls <- base::sys.calls
[15:31:04.807]             `[[` <- base::`[[`
[15:31:04.807]             `+` <- base::`+`
[15:31:04.807]             `<<-` <- base::`<<-`
[15:31:04.807]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:04.807]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:04.807]                   3L)]
[15:31:04.807]             }
[15:31:04.807]             function(cond) {
[15:31:04.807]                 is_error <- inherits(cond, "error")
[15:31:04.807]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:04.807]                   NULL)
[15:31:04.807]                 if (is_error) {
[15:31:04.807]                   sessionInformation <- function() {
[15:31:04.807]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:04.807]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:04.807]                       search = base::search(), system = base::Sys.info())
[15:31:04.807]                   }
[15:31:04.807]                   ...future.conditions[[length(...future.conditions) + 
[15:31:04.807]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:04.807]                     cond$call), session = sessionInformation(), 
[15:31:04.807]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:04.807]                   signalCondition(cond)
[15:31:04.807]                 }
[15:31:04.807]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:04.807]                 "immediateCondition"))) {
[15:31:04.807]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:04.807]                   ...future.conditions[[length(...future.conditions) + 
[15:31:04.807]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:04.807]                   if (TRUE && !signal) {
[15:31:04.807]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:04.807]                     {
[15:31:04.807]                       inherits <- base::inherits
[15:31:04.807]                       invokeRestart <- base::invokeRestart
[15:31:04.807]                       is.null <- base::is.null
[15:31:04.807]                       muffled <- FALSE
[15:31:04.807]                       if (inherits(cond, "message")) {
[15:31:04.807]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:04.807]                         if (muffled) 
[15:31:04.807]                           invokeRestart("muffleMessage")
[15:31:04.807]                       }
[15:31:04.807]                       else if (inherits(cond, "warning")) {
[15:31:04.807]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:04.807]                         if (muffled) 
[15:31:04.807]                           invokeRestart("muffleWarning")
[15:31:04.807]                       }
[15:31:04.807]                       else if (inherits(cond, "condition")) {
[15:31:04.807]                         if (!is.null(pattern)) {
[15:31:04.807]                           computeRestarts <- base::computeRestarts
[15:31:04.807]                           grepl <- base::grepl
[15:31:04.807]                           restarts <- computeRestarts(cond)
[15:31:04.807]                           for (restart in restarts) {
[15:31:04.807]                             name <- restart$name
[15:31:04.807]                             if (is.null(name)) 
[15:31:04.807]                               next
[15:31:04.807]                             if (!grepl(pattern, name)) 
[15:31:04.807]                               next
[15:31:04.807]                             invokeRestart(restart)
[15:31:04.807]                             muffled <- TRUE
[15:31:04.807]                             break
[15:31:04.807]                           }
[15:31:04.807]                         }
[15:31:04.807]                       }
[15:31:04.807]                       invisible(muffled)
[15:31:04.807]                     }
[15:31:04.807]                     muffleCondition(cond, pattern = "^muffle")
[15:31:04.807]                   }
[15:31:04.807]                 }
[15:31:04.807]                 else {
[15:31:04.807]                   if (TRUE) {
[15:31:04.807]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:04.807]                     {
[15:31:04.807]                       inherits <- base::inherits
[15:31:04.807]                       invokeRestart <- base::invokeRestart
[15:31:04.807]                       is.null <- base::is.null
[15:31:04.807]                       muffled <- FALSE
[15:31:04.807]                       if (inherits(cond, "message")) {
[15:31:04.807]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:04.807]                         if (muffled) 
[15:31:04.807]                           invokeRestart("muffleMessage")
[15:31:04.807]                       }
[15:31:04.807]                       else if (inherits(cond, "warning")) {
[15:31:04.807]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:04.807]                         if (muffled) 
[15:31:04.807]                           invokeRestart("muffleWarning")
[15:31:04.807]                       }
[15:31:04.807]                       else if (inherits(cond, "condition")) {
[15:31:04.807]                         if (!is.null(pattern)) {
[15:31:04.807]                           computeRestarts <- base::computeRestarts
[15:31:04.807]                           grepl <- base::grepl
[15:31:04.807]                           restarts <- computeRestarts(cond)
[15:31:04.807]                           for (restart in restarts) {
[15:31:04.807]                             name <- restart$name
[15:31:04.807]                             if (is.null(name)) 
[15:31:04.807]                               next
[15:31:04.807]                             if (!grepl(pattern, name)) 
[15:31:04.807]                               next
[15:31:04.807]                             invokeRestart(restart)
[15:31:04.807]                             muffled <- TRUE
[15:31:04.807]                             break
[15:31:04.807]                           }
[15:31:04.807]                         }
[15:31:04.807]                       }
[15:31:04.807]                       invisible(muffled)
[15:31:04.807]                     }
[15:31:04.807]                     muffleCondition(cond, pattern = "^muffle")
[15:31:04.807]                   }
[15:31:04.807]                 }
[15:31:04.807]             }
[15:31:04.807]         }))
[15:31:04.807]     }, error = function(ex) {
[15:31:04.807]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:04.807]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:04.807]                 ...future.rng), started = ...future.startTime, 
[15:31:04.807]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:04.807]             version = "1.8"), class = "FutureResult")
[15:31:04.807]     }, finally = {
[15:31:04.807]         if (!identical(...future.workdir, getwd())) 
[15:31:04.807]             setwd(...future.workdir)
[15:31:04.807]         {
[15:31:04.807]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:04.807]                 ...future.oldOptions$nwarnings <- NULL
[15:31:04.807]             }
[15:31:04.807]             base::options(...future.oldOptions)
[15:31:04.807]             if (.Platform$OS.type == "windows") {
[15:31:04.807]                 old_names <- names(...future.oldEnvVars)
[15:31:04.807]                 envs <- base::Sys.getenv()
[15:31:04.807]                 names <- names(envs)
[15:31:04.807]                 common <- intersect(names, old_names)
[15:31:04.807]                 added <- setdiff(names, old_names)
[15:31:04.807]                 removed <- setdiff(old_names, names)
[15:31:04.807]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:04.807]                   envs[common]]
[15:31:04.807]                 NAMES <- toupper(changed)
[15:31:04.807]                 args <- list()
[15:31:04.807]                 for (kk in seq_along(NAMES)) {
[15:31:04.807]                   name <- changed[[kk]]
[15:31:04.807]                   NAME <- NAMES[[kk]]
[15:31:04.807]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:04.807]                     next
[15:31:04.807]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:04.807]                 }
[15:31:04.807]                 NAMES <- toupper(added)
[15:31:04.807]                 for (kk in seq_along(NAMES)) {
[15:31:04.807]                   name <- added[[kk]]
[15:31:04.807]                   NAME <- NAMES[[kk]]
[15:31:04.807]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:04.807]                     next
[15:31:04.807]                   args[[name]] <- ""
[15:31:04.807]                 }
[15:31:04.807]                 NAMES <- toupper(removed)
[15:31:04.807]                 for (kk in seq_along(NAMES)) {
[15:31:04.807]                   name <- removed[[kk]]
[15:31:04.807]                   NAME <- NAMES[[kk]]
[15:31:04.807]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:04.807]                     next
[15:31:04.807]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:04.807]                 }
[15:31:04.807]                 if (length(args) > 0) 
[15:31:04.807]                   base::do.call(base::Sys.setenv, args = args)
[15:31:04.807]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:04.807]             }
[15:31:04.807]             else {
[15:31:04.807]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:04.807]             }
[15:31:04.807]             {
[15:31:04.807]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:04.807]                   0L) {
[15:31:04.807]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:04.807]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:04.807]                   base::options(opts)
[15:31:04.807]                 }
[15:31:04.807]                 {
[15:31:04.807]                   {
[15:31:04.807]                     NULL
[15:31:04.807]                     RNGkind("Mersenne-Twister")
[15:31:04.807]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:31:04.807]                       inherits = FALSE)
[15:31:04.807]                   }
[15:31:04.807]                   options(future.plan = NULL)
[15:31:04.807]                   if (is.na(NA_character_)) 
[15:31:04.807]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:04.807]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:04.807]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:04.807]                     .init = FALSE)
[15:31:04.807]                 }
[15:31:04.807]             }
[15:31:04.807]         }
[15:31:04.807]     })
[15:31:04.807]     if (TRUE) {
[15:31:04.807]         base::sink(type = "output", split = FALSE)
[15:31:04.807]         if (TRUE) {
[15:31:04.807]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:04.807]         }
[15:31:04.807]         else {
[15:31:04.807]             ...future.result["stdout"] <- base::list(NULL)
[15:31:04.807]         }
[15:31:04.807]         base::close(...future.stdout)
[15:31:04.807]         ...future.stdout <- NULL
[15:31:04.807]     }
[15:31:04.807]     ...future.result$conditions <- ...future.conditions
[15:31:04.807]     ...future.result$finished <- base::Sys.time()
[15:31:04.807]     ...future.result
[15:31:04.807] }
[15:31:04.813] assign_globals() ...
[15:31:04.814] List of 5
[15:31:04.814]  $ future.call.arguments    : list()
[15:31:04.814]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:04.814]  $ ...future.FUN            :function (x)  
[15:31:04.814]  $ ...future.elements_ii    :List of 2
[15:31:04.814]   ..$ : int 1
[15:31:04.814]   ..$ : int 2
[15:31:04.814]  $ ...future.seeds_ii       : NULL
[15:31:04.814]  $ ...future.globals.maxSize: num Inf
[15:31:04.814]  - attr(*, "resolved")= logi FALSE
[15:31:04.814]  - attr(*, "total_size")= num NA
[15:31:04.814]  - attr(*, "where")=List of 5
[15:31:04.814]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:31:04.814]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:31:04.814]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:31:04.814]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:31:04.814]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:31:04.814]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:04.814]  - attr(*, "already-done")= logi TRUE
[15:31:04.824] - copied 'future.call.arguments' to environment
[15:31:04.824] - copied '...future.FUN' to environment
[15:31:04.824] - copied '...future.elements_ii' to environment
[15:31:04.825] - copied '...future.seeds_ii' to environment
[15:31:04.825] - copied '...future.globals.maxSize' to environment
[15:31:04.825] assign_globals() ... done
[15:31:04.826] plan(): Setting new future strategy stack:
[15:31:04.826] List of future strategies:
[15:31:04.826] 1. sequential:
[15:31:04.826]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:04.826]    - tweaked: FALSE
[15:31:04.826]    - call: NULL
[15:31:04.827] plan(): nbrOfWorkers() = 1
[15:31:04.829] plan(): Setting new future strategy stack:
[15:31:04.829] List of future strategies:
[15:31:04.829] 1. sequential:
[15:31:04.829]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:04.829]    - tweaked: FALSE
[15:31:04.829]    - call: plan(strategy)
[15:31:04.830] plan(): nbrOfWorkers() = 1
[15:31:04.831] SequentialFuture started (and completed)
[15:31:04.831] - Launch lazy future ... done
[15:31:04.834] run() for 'SequentialFuture' ... done
[15:31:04.835] Created future:
[15:31:04.835] SequentialFuture:
[15:31:04.835] Label: 'future_apply-1'
[15:31:04.835] Expression:
[15:31:04.835] {
[15:31:04.835]     do.call(function(...) {
[15:31:04.835]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:04.835]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:04.835]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:04.835]             on.exit(options(oopts), add = TRUE)
[15:31:04.835]         }
[15:31:04.835]         {
[15:31:04.835]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:04.835]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:04.835]                 ...future.FUN(...future.X_jj, ...)
[15:31:04.835]             })
[15:31:04.835]         }
[15:31:04.835]     }, args = future.call.arguments)
[15:31:04.835] }
[15:31:04.835] Lazy evaluation: FALSE
[15:31:04.835] Asynchronous evaluation: FALSE
[15:31:04.835] Local evaluation: TRUE
[15:31:04.835] Environment: R_GlobalEnv
[15:31:04.835] Capture standard output: TRUE
[15:31:04.835] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:04.835] Globals: 5 objects totaling 0.99 KiB (DotDotDotList 'future.call.arguments' of 0 bytes, function '...future.FUN' of 848 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, numeric '...future.globals.maxSize' of 56 bytes)
[15:31:04.835] Packages: <none>
[15:31:04.835] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:04.835] Resolved: TRUE
[15:31:04.835] Value: 112 bytes of class 'list'
[15:31:04.835] Early signaling: FALSE
[15:31:04.835] Owner process: 6672a580-6d3c-e82f-380e-108c475ace70
[15:31:04.835] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:04.837] Chunk #1 of 1 ... DONE
[15:31:04.838] Launching 1 futures (chunks) ... DONE
[15:31:04.838] Resolving 1 futures (chunks) ...
[15:31:04.838] resolve() on list ...
[15:31:04.838]  recursive: 0
[15:31:04.839]  length: 1
[15:31:04.839] 
[15:31:04.839] resolved() for 'SequentialFuture' ...
[15:31:04.840] - state: 'finished'
[15:31:04.840] - run: TRUE
[15:31:04.840] - result: 'FutureResult'
[15:31:04.840] resolved() for 'SequentialFuture' ... done
[15:31:04.841] Future #1
[15:31:04.841] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:31:04.841] - nx: 1
[15:31:04.842] - relay: TRUE
[15:31:04.842] - stdout: TRUE
[15:31:04.842] - signal: TRUE
[15:31:04.842] - resignal: FALSE
[15:31:04.843] - force: TRUE
[15:31:04.843] - relayed: [n=1] FALSE
[15:31:04.843] - queued futures: [n=1] FALSE
[15:31:04.843]  - until=1
[15:31:04.844]  - relaying element #1
[15:31:04.844] - relayed: [n=1] TRUE
[15:31:04.844] - queued futures: [n=1] TRUE
[15:31:04.845] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:31:04.845]  length: 0 (resolved future 1)
[15:31:04.845] Relaying remaining futures
[15:31:04.845] signalConditionsASAP(NULL, pos=0) ...
[15:31:04.846] - nx: 1
[15:31:04.846] - relay: TRUE
[15:31:04.846] - stdout: TRUE
[15:31:04.846] - signal: TRUE
[15:31:04.847] - resignal: FALSE
[15:31:04.847] - force: TRUE
[15:31:04.847] - relayed: [n=1] TRUE
[15:31:04.847] - queued futures: [n=1] TRUE
 - flush all
[15:31:04.848] - relayed: [n=1] TRUE
[15:31:04.848] - queued futures: [n=1] TRUE
[15:31:04.848] signalConditionsASAP(NULL, pos=0) ... done
[15:31:04.848] resolve() on list ... DONE
[15:31:04.849]  - Number of value chunks collected: 1
[15:31:04.849] Resolving 1 futures (chunks) ... DONE
[15:31:04.849] Reducing values from 1 chunks ...
[15:31:04.849]  - Number of values collected after concatenation: 2
[15:31:04.850]  - Number of values expected: 2
[15:31:04.850] Reducing values from 1 chunks ... DONE
[15:31:04.850] future_lapply() ... DONE
a b 
1 2 
- apply(X, ...) - dim(X) > 2 ...
[15:31:04.851] getGlobalsAndPackagesXApply() ...
[15:31:04.851]  - future.globals: TRUE
[15:31:04.851] getGlobalsAndPackages() ...
[15:31:04.852] Searching for globals...
[15:31:04.854] - globals found: [1] 'FUN'
[15:31:04.854] Searching for globals ... DONE
[15:31:04.854] Resolving globals: FALSE
[15:31:04.855] The total size of the 1 globals is 848 bytes (848 bytes)
[15:31:04.856] The total size of the 1 globals exported for future expression ('FUN(X = structure(1:12, dim = c(2L, 2L, 3L)))') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:31:04.856] - globals: [1] 'FUN'
[15:31:04.856] 
[15:31:04.857] getGlobalsAndPackages() ... DONE
[15:31:04.857]  - globals found/used: [n=1] 'FUN'
[15:31:04.857]  - needed namespaces: [n=0] 
[15:31:04.857] Finding globals ... DONE
[15:31:04.858]  - use_args: TRUE
[15:31:04.858]  - Getting '...' globals ...
[15:31:04.859] resolve() on list ...
[15:31:04.859]  recursive: 0
[15:31:04.859]  length: 1
[15:31:04.860]  elements: '...'
[15:31:04.860]  length: 0 (resolved future 1)
[15:31:04.860] resolve() on list ... DONE
[15:31:04.860]    - '...' content: [n=0] 
[15:31:04.861] List of 1
[15:31:04.861]  $ ...: list()
[15:31:04.861]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:04.861]  - attr(*, "where")=List of 1
[15:31:04.861]   ..$ ...:<environment: 0x000001bcba019a70> 
[15:31:04.861]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:04.861]  - attr(*, "resolved")= logi TRUE
[15:31:04.861]  - attr(*, "total_size")= num NA
[15:31:04.866]  - Getting '...' globals ... DONE
[15:31:04.866] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:04.867] List of 2
[15:31:04.867]  $ ...future.FUN:function (x)  
[15:31:04.867]  $ ...          : list()
[15:31:04.867]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:04.867]  - attr(*, "where")=List of 2
[15:31:04.867]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:04.867]   ..$ ...          :<environment: 0x000001bcba019a70> 
[15:31:04.867]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:04.867]  - attr(*, "resolved")= logi FALSE
[15:31:04.867]  - attr(*, "total_size")= num 848
[15:31:04.872] Packages to be attached in all futures: [n=0] 
[15:31:04.872] getGlobalsAndPackagesXApply() ... DONE
[15:31:04.873] future_lapply() ...
[15:31:04.874] Number of chunks: 1
[15:31:04.874] getGlobalsAndPackagesXApply() ...
[15:31:04.878]  - future.globals: <name-value list> with names 'list()'
[15:31:04.879]  - use_args: TRUE
[15:31:04.879] Globals to be used in all futures (chunks): [n=2] '...', '...future.FUN'
[15:31:04.880] List of 2
[15:31:04.880]  $ ...          : list()
[15:31:04.880]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:04.880]  $ ...future.FUN:function (x)  
[15:31:04.880]  - attr(*, "where")=List of 2
[15:31:04.880]   ..$ ...          :<environment: 0x000001bcba019a70> 
[15:31:04.880]   ..$ ...future.FUN:<environment: namespace:base> 
[15:31:04.880]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:04.880]  - attr(*, "resolved")= logi FALSE
[15:31:04.880]  - attr(*, "total_size")= num NA
[15:31:04.885] Packages to be attached in all futures: [n=0] 
[15:31:04.886] getGlobalsAndPackagesXApply() ... DONE
[15:31:04.886] Number of futures (= number of chunks): 1
[15:31:04.886] Launching 1 futures (chunks) ...
[15:31:04.886] Chunk #1 of 1 ...
[15:31:04.887]  - seeds: <none>
[15:31:04.887]  - All globals exported: [n=5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:04.887] getGlobalsAndPackages() ...
[15:31:04.887] - globals passed as-is: [5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:04.888] Resolving globals: FALSE
[15:31:04.888] Tweak future expression to call with '...' arguments ...
[15:31:04.888] {
[15:31:04.888]     do.call(function(...) {
[15:31:04.888]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:04.888]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:04.888]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:04.888]             on.exit(options(oopts), add = TRUE)
[15:31:04.888]         }
[15:31:04.888]         {
[15:31:04.888]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:04.888]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:04.888]                 ...future.FUN(...future.X_jj, ...)
[15:31:04.888]             })
[15:31:04.888]         }
[15:31:04.888]     }, args = future.call.arguments)
[15:31:04.888] }
[15:31:04.889] Tweak future expression to call with '...' arguments ... DONE
[15:31:04.889] - globals: [5] 'future.call.arguments', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:04.889] 
[15:31:04.890] getGlobalsAndPackages() ... DONE
[15:31:04.890] run() for 'Future' ...
[15:31:04.890] - state: 'created'
[15:31:04.891] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:31:04.891] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:04.891] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:31:04.892]   - Field: 'label'
[15:31:04.892]   - Field: 'local'
[15:31:04.892]   - Field: 'owner'
[15:31:04.892]   - Field: 'envir'
[15:31:04.892]   - Field: 'packages'
[15:31:04.892]   - Field: 'gc'
[15:31:04.893]   - Field: 'conditions'
[15:31:04.893]   - Field: 'expr'
[15:31:04.893]   - Field: 'uuid'
[15:31:04.893]   - Field: 'seed'
[15:31:04.893]   - Field: 'version'
[15:31:04.894]   - Field: 'result'
[15:31:04.894]   - Field: 'asynchronous'
[15:31:04.894]   - Field: 'calls'
[15:31:04.894]   - Field: 'globals'
[15:31:04.894]   - Field: 'stdout'
[15:31:04.895]   - Field: 'earlySignal'
[15:31:04.895]   - Field: 'lazy'
[15:31:04.895]   - Field: 'state'
[15:31:04.895] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:31:04.896] - Launch lazy future ...
[15:31:04.896] Packages needed by the future expression (n = 0): <none>
[15:31:04.896] Packages needed by future strategies (n = 0): <none>
[15:31:04.897] {
[15:31:04.897]     {
[15:31:04.897]         {
[15:31:04.897]             ...future.startTime <- base::Sys.time()
[15:31:04.897]             {
[15:31:04.897]                 {
[15:31:04.897]                   {
[15:31:04.897]                     base::local({
[15:31:04.897]                       has_future <- base::requireNamespace("future", 
[15:31:04.897]                         quietly = TRUE)
[15:31:04.897]                       if (has_future) {
[15:31:04.897]                         ns <- base::getNamespace("future")
[15:31:04.897]                         version <- ns[[".package"]][["version"]]
[15:31:04.897]                         if (is.null(version)) 
[15:31:04.897]                           version <- utils::packageVersion("future")
[15:31:04.897]                       }
[15:31:04.897]                       else {
[15:31:04.897]                         version <- NULL
[15:31:04.897]                       }
[15:31:04.897]                       if (!has_future || version < "1.8.0") {
[15:31:04.897]                         info <- base::c(r_version = base::gsub("R version ", 
[15:31:04.897]                           "", base::R.version$version.string), 
[15:31:04.897]                           platform = base::sprintf("%s (%s-bit)", 
[15:31:04.897]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:04.897]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:04.897]                             "release", "version")], collapse = " "), 
[15:31:04.897]                           hostname = base::Sys.info()[["nodename"]])
[15:31:04.897]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:31:04.897]                           info)
[15:31:04.897]                         info <- base::paste(info, collapse = "; ")
[15:31:04.897]                         if (!has_future) {
[15:31:04.897]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:04.897]                             info)
[15:31:04.897]                         }
[15:31:04.897]                         else {
[15:31:04.897]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:04.897]                             info, version)
[15:31:04.897]                         }
[15:31:04.897]                         base::stop(msg)
[15:31:04.897]                       }
[15:31:04.897]                     })
[15:31:04.897]                   }
[15:31:04.897]                   ...future.strategy.old <- future::plan("list")
[15:31:04.897]                   options(future.plan = NULL)
[15:31:04.897]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:04.897]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:04.897]                 }
[15:31:04.897]                 ...future.workdir <- getwd()
[15:31:04.897]             }
[15:31:04.897]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:04.897]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:04.897]         }
[15:31:04.897]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:04.897]             future.globals.maxSize = Inf, future.globals.method = NULL, 
[15:31:04.897]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:04.897]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:04.897]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:04.897]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:04.897]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:04.897]             base::names(...future.oldOptions))
[15:31:04.897]     }
[15:31:04.897]     if (FALSE) {
[15:31:04.897]     }
[15:31:04.897]     else {
[15:31:04.897]         if (TRUE) {
[15:31:04.897]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:04.897]                 open = "w")
[15:31:04.897]         }
[15:31:04.897]         else {
[15:31:04.897]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:04.897]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:04.897]         }
[15:31:04.897]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:04.897]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:04.897]             base::sink(type = "output", split = FALSE)
[15:31:04.897]             base::close(...future.stdout)
[15:31:04.897]         }, add = TRUE)
[15:31:04.897]     }
[15:31:04.897]     ...future.frame <- base::sys.nframe()
[15:31:04.897]     ...future.conditions <- base::list()
[15:31:04.897]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:04.897]     if (FALSE) {
[15:31:04.897]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:04.897]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:04.897]     }
[15:31:04.897]     ...future.result <- base::tryCatch({
[15:31:04.897]         base::withCallingHandlers({
[15:31:04.897]             ...future.value <- base::withVisible(base::local({
[15:31:04.897]                 do.call(function(...) {
[15:31:04.897]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:04.897]                   if (!identical(...future.globals.maxSize.org, 
[15:31:04.897]                     ...future.globals.maxSize)) {
[15:31:04.897]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:04.897]                     on.exit(options(oopts), add = TRUE)
[15:31:04.897]                   }
[15:31:04.897]                   {
[15:31:04.897]                     lapply(seq_along(...future.elements_ii), 
[15:31:04.897]                       FUN = function(jj) {
[15:31:04.897]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:04.897]                         ...future.FUN(...future.X_jj, ...)
[15:31:04.897]                       })
[15:31:04.897]                   }
[15:31:04.897]                 }, args = future.call.arguments)
[15:31:04.897]             }))
[15:31:04.897]             future::FutureResult(value = ...future.value$value, 
[15:31:04.897]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:04.897]                   ...future.rng), globalenv = if (FALSE) 
[15:31:04.897]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:04.897]                     ...future.globalenv.names))
[15:31:04.897]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:04.897]         }, condition = base::local({
[15:31:04.897]             c <- base::c
[15:31:04.897]             inherits <- base::inherits
[15:31:04.897]             invokeRestart <- base::invokeRestart
[15:31:04.897]             length <- base::length
[15:31:04.897]             list <- base::list
[15:31:04.897]             seq.int <- base::seq.int
[15:31:04.897]             signalCondition <- base::signalCondition
[15:31:04.897]             sys.calls <- base::sys.calls
[15:31:04.897]             `[[` <- base::`[[`
[15:31:04.897]             `+` <- base::`+`
[15:31:04.897]             `<<-` <- base::`<<-`
[15:31:04.897]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:04.897]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:04.897]                   3L)]
[15:31:04.897]             }
[15:31:04.897]             function(cond) {
[15:31:04.897]                 is_error <- inherits(cond, "error")
[15:31:04.897]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:04.897]                   NULL)
[15:31:04.897]                 if (is_error) {
[15:31:04.897]                   sessionInformation <- function() {
[15:31:04.897]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:04.897]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:04.897]                       search = base::search(), system = base::Sys.info())
[15:31:04.897]                   }
[15:31:04.897]                   ...future.conditions[[length(...future.conditions) + 
[15:31:04.897]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:04.897]                     cond$call), session = sessionInformation(), 
[15:31:04.897]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:04.897]                   signalCondition(cond)
[15:31:04.897]                 }
[15:31:04.897]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:04.897]                 "immediateCondition"))) {
[15:31:04.897]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:04.897]                   ...future.conditions[[length(...future.conditions) + 
[15:31:04.897]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:04.897]                   if (TRUE && !signal) {
[15:31:04.897]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:04.897]                     {
[15:31:04.897]                       inherits <- base::inherits
[15:31:04.897]                       invokeRestart <- base::invokeRestart
[15:31:04.897]                       is.null <- base::is.null
[15:31:04.897]                       muffled <- FALSE
[15:31:04.897]                       if (inherits(cond, "message")) {
[15:31:04.897]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:04.897]                         if (muffled) 
[15:31:04.897]                           invokeRestart("muffleMessage")
[15:31:04.897]                       }
[15:31:04.897]                       else if (inherits(cond, "warning")) {
[15:31:04.897]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:04.897]                         if (muffled) 
[15:31:04.897]                           invokeRestart("muffleWarning")
[15:31:04.897]                       }
[15:31:04.897]                       else if (inherits(cond, "condition")) {
[15:31:04.897]                         if (!is.null(pattern)) {
[15:31:04.897]                           computeRestarts <- base::computeRestarts
[15:31:04.897]                           grepl <- base::grepl
[15:31:04.897]                           restarts <- computeRestarts(cond)
[15:31:04.897]                           for (restart in restarts) {
[15:31:04.897]                             name <- restart$name
[15:31:04.897]                             if (is.null(name)) 
[15:31:04.897]                               next
[15:31:04.897]                             if (!grepl(pattern, name)) 
[15:31:04.897]                               next
[15:31:04.897]                             invokeRestart(restart)
[15:31:04.897]                             muffled <- TRUE
[15:31:04.897]                             break
[15:31:04.897]                           }
[15:31:04.897]                         }
[15:31:04.897]                       }
[15:31:04.897]                       invisible(muffled)
[15:31:04.897]                     }
[15:31:04.897]                     muffleCondition(cond, pattern = "^muffle")
[15:31:04.897]                   }
[15:31:04.897]                 }
[15:31:04.897]                 else {
[15:31:04.897]                   if (TRUE) {
[15:31:04.897]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:04.897]                     {
[15:31:04.897]                       inherits <- base::inherits
[15:31:04.897]                       invokeRestart <- base::invokeRestart
[15:31:04.897]                       is.null <- base::is.null
[15:31:04.897]                       muffled <- FALSE
[15:31:04.897]                       if (inherits(cond, "message")) {
[15:31:04.897]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:04.897]                         if (muffled) 
[15:31:04.897]                           invokeRestart("muffleMessage")
[15:31:04.897]                       }
[15:31:04.897]                       else if (inherits(cond, "warning")) {
[15:31:04.897]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:04.897]                         if (muffled) 
[15:31:04.897]                           invokeRestart("muffleWarning")
[15:31:04.897]                       }
[15:31:04.897]                       else if (inherits(cond, "condition")) {
[15:31:04.897]                         if (!is.null(pattern)) {
[15:31:04.897]                           computeRestarts <- base::computeRestarts
[15:31:04.897]                           grepl <- base::grepl
[15:31:04.897]                           restarts <- computeRestarts(cond)
[15:31:04.897]                           for (restart in restarts) {
[15:31:04.897]                             name <- restart$name
[15:31:04.897]                             if (is.null(name)) 
[15:31:04.897]                               next
[15:31:04.897]                             if (!grepl(pattern, name)) 
[15:31:04.897]                               next
[15:31:04.897]                             invokeRestart(restart)
[15:31:04.897]                             muffled <- TRUE
[15:31:04.897]                             break
[15:31:04.897]                           }
[15:31:04.897]                         }
[15:31:04.897]                       }
[15:31:04.897]                       invisible(muffled)
[15:31:04.897]                     }
[15:31:04.897]                     muffleCondition(cond, pattern = "^muffle")
[15:31:04.897]                   }
[15:31:04.897]                 }
[15:31:04.897]             }
[15:31:04.897]         }))
[15:31:04.897]     }, error = function(ex) {
[15:31:04.897]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:04.897]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:04.897]                 ...future.rng), started = ...future.startTime, 
[15:31:04.897]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:04.897]             version = "1.8"), class = "FutureResult")
[15:31:04.897]     }, finally = {
[15:31:04.897]         if (!identical(...future.workdir, getwd())) 
[15:31:04.897]             setwd(...future.workdir)
[15:31:04.897]         {
[15:31:04.897]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:04.897]                 ...future.oldOptions$nwarnings <- NULL
[15:31:04.897]             }
[15:31:04.897]             base::options(...future.oldOptions)
[15:31:04.897]             if (.Platform$OS.type == "windows") {
[15:31:04.897]                 old_names <- names(...future.oldEnvVars)
[15:31:04.897]                 envs <- base::Sys.getenv()
[15:31:04.897]                 names <- names(envs)
[15:31:04.897]                 common <- intersect(names, old_names)
[15:31:04.897]                 added <- setdiff(names, old_names)
[15:31:04.897]                 removed <- setdiff(old_names, names)
[15:31:04.897]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:04.897]                   envs[common]]
[15:31:04.897]                 NAMES <- toupper(changed)
[15:31:04.897]                 args <- list()
[15:31:04.897]                 for (kk in seq_along(NAMES)) {
[15:31:04.897]                   name <- changed[[kk]]
[15:31:04.897]                   NAME <- NAMES[[kk]]
[15:31:04.897]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:04.897]                     next
[15:31:04.897]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:04.897]                 }
[15:31:04.897]                 NAMES <- toupper(added)
[15:31:04.897]                 for (kk in seq_along(NAMES)) {
[15:31:04.897]                   name <- added[[kk]]
[15:31:04.897]                   NAME <- NAMES[[kk]]
[15:31:04.897]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:04.897]                     next
[15:31:04.897]                   args[[name]] <- ""
[15:31:04.897]                 }
[15:31:04.897]                 NAMES <- toupper(removed)
[15:31:04.897]                 for (kk in seq_along(NAMES)) {
[15:31:04.897]                   name <- removed[[kk]]
[15:31:04.897]                   NAME <- NAMES[[kk]]
[15:31:04.897]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:04.897]                     next
[15:31:04.897]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:04.897]                 }
[15:31:04.897]                 if (length(args) > 0) 
[15:31:04.897]                   base::do.call(base::Sys.setenv, args = args)
[15:31:04.897]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:04.897]             }
[15:31:04.897]             else {
[15:31:04.897]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:04.897]             }
[15:31:04.897]             {
[15:31:04.897]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:04.897]                   0L) {
[15:31:04.897]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:04.897]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:04.897]                   base::options(opts)
[15:31:04.897]                 }
[15:31:04.897]                 {
[15:31:04.897]                   {
[15:31:04.897]                     NULL
[15:31:04.897]                     RNGkind("Mersenne-Twister")
[15:31:04.897]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:31:04.897]                       inherits = FALSE)
[15:31:04.897]                   }
[15:31:04.897]                   options(future.plan = NULL)
[15:31:04.897]                   if (is.na(NA_character_)) 
[15:31:04.897]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:04.897]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:04.897]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:04.897]                     .init = FALSE)
[15:31:04.897]                 }
[15:31:04.897]             }
[15:31:04.897]         }
[15:31:04.897]     })
[15:31:04.897]     if (TRUE) {
[15:31:04.897]         base::sink(type = "output", split = FALSE)
[15:31:04.897]         if (TRUE) {
[15:31:04.897]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:04.897]         }
[15:31:04.897]         else {
[15:31:04.897]             ...future.result["stdout"] <- base::list(NULL)
[15:31:04.897]         }
[15:31:04.897]         base::close(...future.stdout)
[15:31:04.897]         ...future.stdout <- NULL
[15:31:04.897]     }
[15:31:04.897]     ...future.result$conditions <- ...future.conditions
[15:31:04.897]     ...future.result$finished <- base::Sys.time()
[15:31:04.897]     ...future.result
[15:31:04.897] }
[15:31:04.902] assign_globals() ...
[15:31:04.902] List of 5
[15:31:04.902]  $ future.call.arguments    : list()
[15:31:04.902]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:04.902]  $ ...future.FUN            :function (x)  
[15:31:04.902]  $ ...future.elements_ii    :List of 2
[15:31:04.902]   ..$ : int [1:2, 1:3] 1 3 5 7 9 11
[15:31:04.902]   ..$ : int [1:2, 1:3] 2 4 6 8 10 12
[15:31:04.902]  $ ...future.seeds_ii       : NULL
[15:31:04.902]  $ ...future.globals.maxSize: num Inf
[15:31:04.902]  - attr(*, "resolved")= logi FALSE
[15:31:04.902]  - attr(*, "total_size")= num NA
[15:31:04.902]  - attr(*, "where")=List of 5
[15:31:04.902]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:31:04.902]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:31:04.902]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:31:04.902]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:31:04.902]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:31:04.902]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:04.902]  - attr(*, "already-done")= logi TRUE
[15:31:04.913] - copied 'future.call.arguments' to environment
[15:31:04.913] - copied '...future.FUN' to environment
[15:31:04.914] - copied '...future.elements_ii' to environment
[15:31:04.914] - copied '...future.seeds_ii' to environment
[15:31:04.914] - copied '...future.globals.maxSize' to environment
[15:31:04.914] assign_globals() ... done
[15:31:04.915] plan(): Setting new future strategy stack:
[15:31:04.916] List of future strategies:
[15:31:04.916] 1. sequential:
[15:31:04.916]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:04.916]    - tweaked: FALSE
[15:31:04.916]    - call: NULL
[15:31:04.917] plan(): nbrOfWorkers() = 1
[15:31:04.923] plan(): Setting new future strategy stack:
[15:31:04.923] List of future strategies:
[15:31:04.923] 1. sequential:
[15:31:04.923]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:04.923]    - tweaked: FALSE
[15:31:04.923]    - call: plan(strategy)
[15:31:04.925] plan(): nbrOfWorkers() = 1
[15:31:04.925] SequentialFuture started (and completed)
[15:31:04.926] - Launch lazy future ... done
[15:31:04.926] run() for 'SequentialFuture' ... done
[15:31:04.927] Created future:
[15:31:04.927] SequentialFuture:
[15:31:04.927] Label: 'future_apply-1'
[15:31:04.927] Expression:
[15:31:04.927] {
[15:31:04.927]     do.call(function(...) {
[15:31:04.927]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:04.927]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:04.927]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:04.927]             on.exit(options(oopts), add = TRUE)
[15:31:04.927]         }
[15:31:04.927]         {
[15:31:04.927]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:04.927]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:04.927]                 ...future.FUN(...future.X_jj, ...)
[15:31:04.927]             })
[15:31:04.927]         }
[15:31:04.927]     }, args = future.call.arguments)
[15:31:04.927] }
[15:31:04.927] Lazy evaluation: FALSE
[15:31:04.927] Asynchronous evaluation: FALSE
[15:31:04.927] Local evaluation: TRUE
[15:31:04.927] Environment: R_GlobalEnv
[15:31:04.927] Capture standard output: TRUE
[15:31:04.927] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:04.927] Globals: 5 objects totaling 1.37 KiB (DotDotDotList 'future.call.arguments' of 0 bytes, function '...future.FUN' of 848 bytes, list '...future.elements_ii' of 496 bytes, NULL '...future.seeds_ii' of 0 bytes, numeric '...future.globals.maxSize' of 56 bytes)
[15:31:04.927] Packages: <none>
[15:31:04.927] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:04.927] Resolved: TRUE
[15:31:04.927] Value: 496 bytes of class 'list'
[15:31:04.927] Early signaling: FALSE
[15:31:04.927] Owner process: 6672a580-6d3c-e82f-380e-108c475ace70
[15:31:04.927] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:04.930] Chunk #1 of 1 ... DONE
[15:31:04.930] Launching 1 futures (chunks) ... DONE
[15:31:04.930] Resolving 1 futures (chunks) ...
[15:31:04.931] resolve() on list ...
[15:31:04.931]  recursive: 0
[15:31:04.931]  length: 1
[15:31:04.932] 
[15:31:04.932] resolved() for 'SequentialFuture' ...
[15:31:04.932] - state: 'finished'
[15:31:04.933] - run: TRUE
[15:31:04.933] - result: 'FutureResult'
[15:31:04.933] resolved() for 'SequentialFuture' ... done
[15:31:04.934] Future #1
[15:31:04.934] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:31:04.935] - nx: 1
[15:31:04.935] - relay: TRUE
[15:31:04.935] - stdout: TRUE
[15:31:04.936] - signal: TRUE
[15:31:04.936] - resignal: FALSE
[15:31:04.936] - force: TRUE
[15:31:04.936] - relayed: [n=1] FALSE
[15:31:04.937] - queued futures: [n=1] FALSE
[15:31:04.937]  - until=1
[15:31:04.937]  - relaying element #1
[15:31:04.938] - relayed: [n=1] TRUE
[15:31:04.938] - queued futures: [n=1] TRUE
[15:31:04.939] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:31:04.939]  length: 0 (resolved future 1)
[15:31:04.939] Relaying remaining futures
[15:31:04.939] signalConditionsASAP(NULL, pos=0) ...
[15:31:04.940] - nx: 1
[15:31:04.940] - relay: TRUE
[15:31:04.940] - stdout: TRUE
[15:31:04.941] - signal: TRUE
[15:31:04.941] - resignal: FALSE
[15:31:04.941] - force: TRUE
[15:31:04.942] - relayed: [n=1] TRUE
[15:31:04.942] - queued futures: [n=1] TRUE
 - flush all
[15:31:04.942] - relayed: [n=1] TRUE
[15:31:04.943] - queued futures: [n=1] TRUE
[15:31:04.943] signalConditionsASAP(NULL, pos=0) ... done
[15:31:04.943] resolve() on list ... DONE
[15:31:04.944]  - Number of value chunks collected: 1
[15:31:04.944] Resolving 1 futures (chunks) ... DONE
[15:31:04.944] Reducing values from 1 chunks ...
[15:31:04.945]  - Number of values collected after concatenation: 2
[15:31:04.945]  - Number of values expected: 2
[15:31:04.945] Reducing values from 1 chunks ... DONE
[15:31:04.946] future_lapply() ... DONE
     [,1] [,2]
[1,]    1    2
[2,]    3    4
[3,]    5    6
[4,]    7    8
[5,]    9   10
[6,]   11   12
- apply(X, ...) - not all same names ...
[15:31:04.947] getGlobalsAndPackagesXApply() ...
[15:31:04.947]  - future.globals: TRUE
[15:31:04.947] getGlobalsAndPackages() ...
[15:31:04.947] Searching for globals...
[15:31:04.953] - globals found: [10] 'FUN', '{', 'if', '==', '[', '<-', 'names', 'names<-', 'letters', 'seq_along'
[15:31:04.953] Searching for globals ... DONE
[15:31:04.954] Resolving globals: FALSE
[15:31:04.955] The total size of the 1 globals is 9.66 KiB (9888 bytes)
[15:31:04.955] The total size of the 1 globals exported for future expression ('FUN(X = structure(1:4, dim = c(2L, 2L)))') is 9.66 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (9.66 KiB of class 'function')
[15:31:04.955] - globals: [1] 'FUN'
[15:31:04.956] 
[15:31:04.956] getGlobalsAndPackages() ... DONE
[15:31:04.956]  - globals found/used: [n=1] 'FUN'
[15:31:04.957]  - needed namespaces: [n=0] 
[15:31:04.957] Finding globals ... DONE
[15:31:04.957]  - use_args: TRUE
[15:31:04.958]  - Getting '...' globals ...
[15:31:04.958] resolve() on list ...
[15:31:04.959]  recursive: 0
[15:31:04.959]  length: 1
[15:31:04.959]  elements: '...'
[15:31:04.960]  length: 0 (resolved future 1)
[15:31:04.960] resolve() on list ... DONE
[15:31:04.960]    - '...' content: [n=0] 
[15:31:04.960] List of 1
[15:31:04.960]  $ ...: list()
[15:31:04.960]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:04.960]  - attr(*, "where")=List of 1
[15:31:04.960]   ..$ ...:<environment: 0x000001bcb9371aa8> 
[15:31:04.960]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:04.960]  - attr(*, "resolved")= logi TRUE
[15:31:04.960]  - attr(*, "total_size")= num NA
[15:31:04.966]  - Getting '...' globals ... DONE
[15:31:04.966] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:04.966] List of 2
[15:31:04.966]  $ ...future.FUN:function (x)  
[15:31:04.966]  $ ...          : list()
[15:31:04.966]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:04.966]  - attr(*, "where")=List of 2
[15:31:04.966]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:04.966]   ..$ ...          :<environment: 0x000001bcb9371aa8> 
[15:31:04.966]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:04.966]  - attr(*, "resolved")= logi FALSE
[15:31:04.966]  - attr(*, "total_size")= num 9888
[15:31:04.977] Packages to be attached in all futures: [n=0] 
[15:31:04.977] getGlobalsAndPackagesXApply() ... DONE
[15:31:04.977] future_lapply() ...
[15:31:04.980] Number of chunks: 1
[15:31:04.980] getGlobalsAndPackagesXApply() ...
[15:31:04.980]  - future.globals: <name-value list> with names 'list()'
[15:31:04.981]  - use_args: TRUE
[15:31:04.981] Globals to be used in all futures (chunks): [n=2] '...', '...future.FUN'
[15:31:04.981] List of 2
[15:31:04.981]  $ ...          : list()
[15:31:04.981]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:04.981]  $ ...future.FUN:function (x)  
[15:31:04.981]  - attr(*, "where")=List of 2
[15:31:04.981]   ..$ ...          :<environment: 0x000001bcb9371aa8> 
[15:31:04.981]   ..$ ...future.FUN:<environment: R_GlobalEnv> 
[15:31:04.981]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:04.981]  - attr(*, "resolved")= logi FALSE
[15:31:04.981]  - attr(*, "total_size")= num NA
[15:31:04.988] Packages to be attached in all futures: [n=0] 
[15:31:04.988] getGlobalsAndPackagesXApply() ... DONE
[15:31:04.989] Number of futures (= number of chunks): 1
[15:31:04.989] Launching 1 futures (chunks) ...
[15:31:04.989] Chunk #1 of 1 ...
[15:31:04.990]  - seeds: <none>
[15:31:04.990]  - All globals exported: [n=5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:04.990] getGlobalsAndPackages() ...
[15:31:04.991] - globals passed as-is: [5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:04.991] Resolving globals: FALSE
[15:31:04.991] Tweak future expression to call with '...' arguments ...
[15:31:04.992] {
[15:31:04.992]     do.call(function(...) {
[15:31:04.992]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:04.992]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:04.992]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:04.992]             on.exit(options(oopts), add = TRUE)
[15:31:04.992]         }
[15:31:04.992]         {
[15:31:04.992]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:04.992]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:04.992]                 ...future.FUN(...future.X_jj, ...)
[15:31:04.992]             })
[15:31:04.992]         }
[15:31:04.992]     }, args = future.call.arguments)
[15:31:04.992] }
[15:31:04.993] Tweak future expression to call with '...' arguments ... DONE
[15:31:04.993] - globals: [5] 'future.call.arguments', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:04.994] 
[15:31:04.994] getGlobalsAndPackages() ... DONE
[15:31:04.995] run() for 'Future' ...
[15:31:04.995] - state: 'created'
[15:31:04.996] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:31:04.996] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:04.997] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:31:04.997]   - Field: 'label'
[15:31:04.997]   - Field: 'local'
[15:31:04.998]   - Field: 'owner'
[15:31:04.998]   - Field: 'envir'
[15:31:04.998]   - Field: 'packages'
[15:31:04.999]   - Field: 'gc'
[15:31:04.999]   - Field: 'conditions'
[15:31:04.999]   - Field: 'expr'
[15:31:05.000]   - Field: 'uuid'
[15:31:05.000]   - Field: 'seed'
[15:31:05.000]   - Field: 'version'
[15:31:05.001]   - Field: 'result'
[15:31:05.001]   - Field: 'asynchronous'
[15:31:05.001]   - Field: 'calls'
[15:31:05.002]   - Field: 'globals'
[15:31:05.002]   - Field: 'stdout'
[15:31:05.002]   - Field: 'earlySignal'
[15:31:05.003]   - Field: 'lazy'
[15:31:05.003]   - Field: 'state'
[15:31:05.003] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:31:05.004] - Launch lazy future ...
[15:31:05.004] Packages needed by the future expression (n = 0): <none>
[15:31:05.005] Packages needed by future strategies (n = 0): <none>
[15:31:05.006] {
[15:31:05.006]     {
[15:31:05.006]         {
[15:31:05.006]             ...future.startTime <- base::Sys.time()
[15:31:05.006]             {
[15:31:05.006]                 {
[15:31:05.006]                   {
[15:31:05.006]                     base::local({
[15:31:05.006]                       has_future <- base::requireNamespace("future", 
[15:31:05.006]                         quietly = TRUE)
[15:31:05.006]                       if (has_future) {
[15:31:05.006]                         ns <- base::getNamespace("future")
[15:31:05.006]                         version <- ns[[".package"]][["version"]]
[15:31:05.006]                         if (is.null(version)) 
[15:31:05.006]                           version <- utils::packageVersion("future")
[15:31:05.006]                       }
[15:31:05.006]                       else {
[15:31:05.006]                         version <- NULL
[15:31:05.006]                       }
[15:31:05.006]                       if (!has_future || version < "1.8.0") {
[15:31:05.006]                         info <- base::c(r_version = base::gsub("R version ", 
[15:31:05.006]                           "", base::R.version$version.string), 
[15:31:05.006]                           platform = base::sprintf("%s (%s-bit)", 
[15:31:05.006]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:05.006]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:05.006]                             "release", "version")], collapse = " "), 
[15:31:05.006]                           hostname = base::Sys.info()[["nodename"]])
[15:31:05.006]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:31:05.006]                           info)
[15:31:05.006]                         info <- base::paste(info, collapse = "; ")
[15:31:05.006]                         if (!has_future) {
[15:31:05.006]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:05.006]                             info)
[15:31:05.006]                         }
[15:31:05.006]                         else {
[15:31:05.006]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:05.006]                             info, version)
[15:31:05.006]                         }
[15:31:05.006]                         base::stop(msg)
[15:31:05.006]                       }
[15:31:05.006]                     })
[15:31:05.006]                   }
[15:31:05.006]                   ...future.strategy.old <- future::plan("list")
[15:31:05.006]                   options(future.plan = NULL)
[15:31:05.006]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:05.006]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:05.006]                 }
[15:31:05.006]                 ...future.workdir <- getwd()
[15:31:05.006]             }
[15:31:05.006]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:05.006]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:05.006]         }
[15:31:05.006]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:05.006]             future.globals.maxSize = Inf, future.globals.method = NULL, 
[15:31:05.006]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:05.006]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:05.006]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:05.006]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:05.006]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:05.006]             base::names(...future.oldOptions))
[15:31:05.006]     }
[15:31:05.006]     if (FALSE) {
[15:31:05.006]     }
[15:31:05.006]     else {
[15:31:05.006]         if (TRUE) {
[15:31:05.006]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:05.006]                 open = "w")
[15:31:05.006]         }
[15:31:05.006]         else {
[15:31:05.006]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:05.006]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:05.006]         }
[15:31:05.006]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:05.006]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:05.006]             base::sink(type = "output", split = FALSE)
[15:31:05.006]             base::close(...future.stdout)
[15:31:05.006]         }, add = TRUE)
[15:31:05.006]     }
[15:31:05.006]     ...future.frame <- base::sys.nframe()
[15:31:05.006]     ...future.conditions <- base::list()
[15:31:05.006]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:05.006]     if (FALSE) {
[15:31:05.006]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:05.006]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:05.006]     }
[15:31:05.006]     ...future.result <- base::tryCatch({
[15:31:05.006]         base::withCallingHandlers({
[15:31:05.006]             ...future.value <- base::withVisible(base::local({
[15:31:05.006]                 do.call(function(...) {
[15:31:05.006]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:05.006]                   if (!identical(...future.globals.maxSize.org, 
[15:31:05.006]                     ...future.globals.maxSize)) {
[15:31:05.006]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:05.006]                     on.exit(options(oopts), add = TRUE)
[15:31:05.006]                   }
[15:31:05.006]                   {
[15:31:05.006]                     lapply(seq_along(...future.elements_ii), 
[15:31:05.006]                       FUN = function(jj) {
[15:31:05.006]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:05.006]                         ...future.FUN(...future.X_jj, ...)
[15:31:05.006]                       })
[15:31:05.006]                   }
[15:31:05.006]                 }, args = future.call.arguments)
[15:31:05.006]             }))
[15:31:05.006]             future::FutureResult(value = ...future.value$value, 
[15:31:05.006]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:05.006]                   ...future.rng), globalenv = if (FALSE) 
[15:31:05.006]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:05.006]                     ...future.globalenv.names))
[15:31:05.006]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:05.006]         }, condition = base::local({
[15:31:05.006]             c <- base::c
[15:31:05.006]             inherits <- base::inherits
[15:31:05.006]             invokeRestart <- base::invokeRestart
[15:31:05.006]             length <- base::length
[15:31:05.006]             list <- base::list
[15:31:05.006]             seq.int <- base::seq.int
[15:31:05.006]             signalCondition <- base::signalCondition
[15:31:05.006]             sys.calls <- base::sys.calls
[15:31:05.006]             `[[` <- base::`[[`
[15:31:05.006]             `+` <- base::`+`
[15:31:05.006]             `<<-` <- base::`<<-`
[15:31:05.006]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:05.006]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:05.006]                   3L)]
[15:31:05.006]             }
[15:31:05.006]             function(cond) {
[15:31:05.006]                 is_error <- inherits(cond, "error")
[15:31:05.006]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:05.006]                   NULL)
[15:31:05.006]                 if (is_error) {
[15:31:05.006]                   sessionInformation <- function() {
[15:31:05.006]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:05.006]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:05.006]                       search = base::search(), system = base::Sys.info())
[15:31:05.006]                   }
[15:31:05.006]                   ...future.conditions[[length(...future.conditions) + 
[15:31:05.006]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:05.006]                     cond$call), session = sessionInformation(), 
[15:31:05.006]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:05.006]                   signalCondition(cond)
[15:31:05.006]                 }
[15:31:05.006]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:05.006]                 "immediateCondition"))) {
[15:31:05.006]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:05.006]                   ...future.conditions[[length(...future.conditions) + 
[15:31:05.006]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:05.006]                   if (TRUE && !signal) {
[15:31:05.006]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:05.006]                     {
[15:31:05.006]                       inherits <- base::inherits
[15:31:05.006]                       invokeRestart <- base::invokeRestart
[15:31:05.006]                       is.null <- base::is.null
[15:31:05.006]                       muffled <- FALSE
[15:31:05.006]                       if (inherits(cond, "message")) {
[15:31:05.006]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:05.006]                         if (muffled) 
[15:31:05.006]                           invokeRestart("muffleMessage")
[15:31:05.006]                       }
[15:31:05.006]                       else if (inherits(cond, "warning")) {
[15:31:05.006]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:05.006]                         if (muffled) 
[15:31:05.006]                           invokeRestart("muffleWarning")
[15:31:05.006]                       }
[15:31:05.006]                       else if (inherits(cond, "condition")) {
[15:31:05.006]                         if (!is.null(pattern)) {
[15:31:05.006]                           computeRestarts <- base::computeRestarts
[15:31:05.006]                           grepl <- base::grepl
[15:31:05.006]                           restarts <- computeRestarts(cond)
[15:31:05.006]                           for (restart in restarts) {
[15:31:05.006]                             name <- restart$name
[15:31:05.006]                             if (is.null(name)) 
[15:31:05.006]                               next
[15:31:05.006]                             if (!grepl(pattern, name)) 
[15:31:05.006]                               next
[15:31:05.006]                             invokeRestart(restart)
[15:31:05.006]                             muffled <- TRUE
[15:31:05.006]                             break
[15:31:05.006]                           }
[15:31:05.006]                         }
[15:31:05.006]                       }
[15:31:05.006]                       invisible(muffled)
[15:31:05.006]                     }
[15:31:05.006]                     muffleCondition(cond, pattern = "^muffle")
[15:31:05.006]                   }
[15:31:05.006]                 }
[15:31:05.006]                 else {
[15:31:05.006]                   if (TRUE) {
[15:31:05.006]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:05.006]                     {
[15:31:05.006]                       inherits <- base::inherits
[15:31:05.006]                       invokeRestart <- base::invokeRestart
[15:31:05.006]                       is.null <- base::is.null
[15:31:05.006]                       muffled <- FALSE
[15:31:05.006]                       if (inherits(cond, "message")) {
[15:31:05.006]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:05.006]                         if (muffled) 
[15:31:05.006]                           invokeRestart("muffleMessage")
[15:31:05.006]                       }
[15:31:05.006]                       else if (inherits(cond, "warning")) {
[15:31:05.006]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:05.006]                         if (muffled) 
[15:31:05.006]                           invokeRestart("muffleWarning")
[15:31:05.006]                       }
[15:31:05.006]                       else if (inherits(cond, "condition")) {
[15:31:05.006]                         if (!is.null(pattern)) {
[15:31:05.006]                           computeRestarts <- base::computeRestarts
[15:31:05.006]                           grepl <- base::grepl
[15:31:05.006]                           restarts <- computeRestarts(cond)
[15:31:05.006]                           for (restart in restarts) {
[15:31:05.006]                             name <- restart$name
[15:31:05.006]                             if (is.null(name)) 
[15:31:05.006]                               next
[15:31:05.006]                             if (!grepl(pattern, name)) 
[15:31:05.006]                               next
[15:31:05.006]                             invokeRestart(restart)
[15:31:05.006]                             muffled <- TRUE
[15:31:05.006]                             break
[15:31:05.006]                           }
[15:31:05.006]                         }
[15:31:05.006]                       }
[15:31:05.006]                       invisible(muffled)
[15:31:05.006]                     }
[15:31:05.006]                     muffleCondition(cond, pattern = "^muffle")
[15:31:05.006]                   }
[15:31:05.006]                 }
[15:31:05.006]             }
[15:31:05.006]         }))
[15:31:05.006]     }, error = function(ex) {
[15:31:05.006]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:05.006]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:05.006]                 ...future.rng), started = ...future.startTime, 
[15:31:05.006]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:05.006]             version = "1.8"), class = "FutureResult")
[15:31:05.006]     }, finally = {
[15:31:05.006]         if (!identical(...future.workdir, getwd())) 
[15:31:05.006]             setwd(...future.workdir)
[15:31:05.006]         {
[15:31:05.006]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:05.006]                 ...future.oldOptions$nwarnings <- NULL
[15:31:05.006]             }
[15:31:05.006]             base::options(...future.oldOptions)
[15:31:05.006]             if (.Platform$OS.type == "windows") {
[15:31:05.006]                 old_names <- names(...future.oldEnvVars)
[15:31:05.006]                 envs <- base::Sys.getenv()
[15:31:05.006]                 names <- names(envs)
[15:31:05.006]                 common <- intersect(names, old_names)
[15:31:05.006]                 added <- setdiff(names, old_names)
[15:31:05.006]                 removed <- setdiff(old_names, names)
[15:31:05.006]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:05.006]                   envs[common]]
[15:31:05.006]                 NAMES <- toupper(changed)
[15:31:05.006]                 args <- list()
[15:31:05.006]                 for (kk in seq_along(NAMES)) {
[15:31:05.006]                   name <- changed[[kk]]
[15:31:05.006]                   NAME <- NAMES[[kk]]
[15:31:05.006]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:05.006]                     next
[15:31:05.006]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:05.006]                 }
[15:31:05.006]                 NAMES <- toupper(added)
[15:31:05.006]                 for (kk in seq_along(NAMES)) {
[15:31:05.006]                   name <- added[[kk]]
[15:31:05.006]                   NAME <- NAMES[[kk]]
[15:31:05.006]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:05.006]                     next
[15:31:05.006]                   args[[name]] <- ""
[15:31:05.006]                 }
[15:31:05.006]                 NAMES <- toupper(removed)
[15:31:05.006]                 for (kk in seq_along(NAMES)) {
[15:31:05.006]                   name <- removed[[kk]]
[15:31:05.006]                   NAME <- NAMES[[kk]]
[15:31:05.006]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:05.006]                     next
[15:31:05.006]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:05.006]                 }
[15:31:05.006]                 if (length(args) > 0) 
[15:31:05.006]                   base::do.call(base::Sys.setenv, args = args)
[15:31:05.006]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:05.006]             }
[15:31:05.006]             else {
[15:31:05.006]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:05.006]             }
[15:31:05.006]             {
[15:31:05.006]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:05.006]                   0L) {
[15:31:05.006]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:05.006]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:05.006]                   base::options(opts)
[15:31:05.006]                 }
[15:31:05.006]                 {
[15:31:05.006]                   {
[15:31:05.006]                     NULL
[15:31:05.006]                     RNGkind("Mersenne-Twister")
[15:31:05.006]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:31:05.006]                       inherits = FALSE)
[15:31:05.006]                   }
[15:31:05.006]                   options(future.plan = NULL)
[15:31:05.006]                   if (is.na(NA_character_)) 
[15:31:05.006]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:05.006]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:05.006]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:05.006]                     .init = FALSE)
[15:31:05.006]                 }
[15:31:05.006]             }
[15:31:05.006]         }
[15:31:05.006]     })
[15:31:05.006]     if (TRUE) {
[15:31:05.006]         base::sink(type = "output", split = FALSE)
[15:31:05.006]         if (TRUE) {
[15:31:05.006]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:05.006]         }
[15:31:05.006]         else {
[15:31:05.006]             ...future.result["stdout"] <- base::list(NULL)
[15:31:05.006]         }
[15:31:05.006]         base::close(...future.stdout)
[15:31:05.006]         ...future.stdout <- NULL
[15:31:05.006]     }
[15:31:05.006]     ...future.result$conditions <- ...future.conditions
[15:31:05.006]     ...future.result$finished <- base::Sys.time()
[15:31:05.006]     ...future.result
[15:31:05.006] }
[15:31:05.013] assign_globals() ...
[15:31:05.013] List of 5
[15:31:05.013]  $ future.call.arguments    : list()
[15:31:05.013]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:05.013]  $ ...future.FUN            :function (x)  
[15:31:05.013]  $ ...future.elements_ii    :List of 2
[15:31:05.013]   ..$ : int [1:2] 1 3
[15:31:05.013]   ..$ : int [1:2] 2 4
[15:31:05.013]  $ ...future.seeds_ii       : NULL
[15:31:05.013]  $ ...future.globals.maxSize: num Inf
[15:31:05.013]  - attr(*, "resolved")= logi FALSE
[15:31:05.013]  - attr(*, "total_size")= num NA
[15:31:05.013]  - attr(*, "where")=List of 5
[15:31:05.013]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:31:05.013]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:31:05.013]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:31:05.013]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:31:05.013]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:31:05.013]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:05.013]  - attr(*, "already-done")= logi TRUE
[15:31:05.026] - copied 'future.call.arguments' to environment
[15:31:05.027] - reassign environment for '...future.FUN'
[15:31:05.027] - copied '...future.FUN' to environment
[15:31:05.027] - copied '...future.elements_ii' to environment
[15:31:05.028] - copied '...future.seeds_ii' to environment
[15:31:05.028] - copied '...future.globals.maxSize' to environment
[15:31:05.028] assign_globals() ... done
[15:31:05.029] plan(): Setting new future strategy stack:
[15:31:05.029] List of future strategies:
[15:31:05.029] 1. sequential:
[15:31:05.029]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:05.029]    - tweaked: FALSE
[15:31:05.029]    - call: NULL
[15:31:05.030] plan(): nbrOfWorkers() = 1
[15:31:05.032] plan(): Setting new future strategy stack:
[15:31:05.032] List of future strategies:
[15:31:05.032] 1. sequential:
[15:31:05.032]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:05.032]    - tweaked: FALSE
[15:31:05.032]    - call: plan(strategy)
[15:31:05.033] plan(): nbrOfWorkers() = 1
[15:31:05.034] SequentialFuture started (and completed)
[15:31:05.034] - Launch lazy future ... done
[15:31:05.035] run() for 'SequentialFuture' ... done
[15:31:05.035] Created future:
[15:31:05.035] SequentialFuture:
[15:31:05.035] Label: 'future_apply-1'
[15:31:05.035] Expression:
[15:31:05.035] {
[15:31:05.035]     do.call(function(...) {
[15:31:05.035]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:05.035]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:05.035]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:05.035]             on.exit(options(oopts), add = TRUE)
[15:31:05.035]         }
[15:31:05.035]         {
[15:31:05.035]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:05.035]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:05.035]                 ...future.FUN(...future.X_jj, ...)
[15:31:05.035]             })
[15:31:05.035]         }
[15:31:05.035]     }, args = future.call.arguments)
[15:31:05.035] }
[15:31:05.035] Lazy evaluation: FALSE
[15:31:05.035] Asynchronous evaluation: FALSE
[15:31:05.035] Local evaluation: TRUE
[15:31:05.035] Environment: R_GlobalEnv
[15:31:05.035] Capture standard output: TRUE
[15:31:05.035] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:05.035] Globals: 5 objects totaling 9.82 KiB (DotDotDotList 'future.call.arguments' of 0 bytes, function '...future.FUN' of 9.66 KiB, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, numeric '...future.globals.maxSize' of 56 bytes)
[15:31:05.035] Packages: <none>
[15:31:05.035] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:05.035] Resolved: TRUE
[15:31:05.035] Value: 400 bytes of class 'list'
[15:31:05.035] Early signaling: FALSE
[15:31:05.035] Owner process: 6672a580-6d3c-e82f-380e-108c475ace70
[15:31:05.035] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:05.037] Chunk #1 of 1 ... DONE
[15:31:05.038] Launching 1 futures (chunks) ... DONE
[15:31:05.038] Resolving 1 futures (chunks) ...
[15:31:05.038] resolve() on list ...
[15:31:05.039]  recursive: 0
[15:31:05.039]  length: 1
[15:31:05.039] 
[15:31:05.039] resolved() for 'SequentialFuture' ...
[15:31:05.040] - state: 'finished'
[15:31:05.040] - run: TRUE
[15:31:05.040] - result: 'FutureResult'
[15:31:05.041] resolved() for 'SequentialFuture' ... done
[15:31:05.041] Future #1
[15:31:05.041] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:31:05.042] - nx: 1
[15:31:05.042] - relay: TRUE
[15:31:05.042] - stdout: TRUE
[15:31:05.042] - signal: TRUE
[15:31:05.043] - resignal: FALSE
[15:31:05.043] - force: TRUE
[15:31:05.043] - relayed: [n=1] FALSE
[15:31:05.043] - queued futures: [n=1] FALSE
[15:31:05.044]  - until=1
[15:31:05.044]  - relaying element #1
[15:31:05.045] - relayed: [n=1] TRUE
[15:31:05.045] - queued futures: [n=1] TRUE
[15:31:05.045] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:31:05.045]  length: 0 (resolved future 1)
[15:31:05.046] Relaying remaining futures
[15:31:05.046] signalConditionsASAP(NULL, pos=0) ...
[15:31:05.046] - nx: 1
[15:31:05.047] - relay: TRUE
[15:31:05.047] - stdout: TRUE
[15:31:05.047] - signal: TRUE
[15:31:05.047] - resignal: FALSE
[15:31:05.048] - force: TRUE
[15:31:05.048] - relayed: [n=1] TRUE
[15:31:05.048] - queued futures: [n=1] TRUE
 - flush all
[15:31:05.048] - relayed: [n=1] TRUE
[15:31:05.049] - queued futures: [n=1] TRUE
[15:31:05.049] signalConditionsASAP(NULL, pos=0) ... done
[15:31:05.049] resolve() on list ... DONE
[15:31:05.050]  - Number of value chunks collected: 1
[15:31:05.050] Resolving 1 futures (chunks) ... DONE
[15:31:05.051] Reducing values from 1 chunks ...
[15:31:05.051]  - Number of values collected after concatenation: 2
[15:31:05.051]  - Number of values expected: 2
[15:31:05.052] Reducing values from 1 chunks ... DONE
[15:31:05.052] future_lapply() ... DONE
     [,1] [,2]
[1,]    1    2
[2,]    3    4
- example(future_apply) - reproducible RNG ...
[15:31:05.053] getGlobalsAndPackagesXApply() ...
[15:31:05.054]  - future.globals: TRUE
[15:31:05.054] getGlobalsAndPackages() ...
[15:31:05.054] Searching for globals...
[15:31:05.062] - globals found: [13] 'FUN', '{', 'if', '&&', '==', 'length', 'is.numeric', 'is.finite', '>=', 'missing', '<-', 'sample.int', '['
[15:31:05.063] Searching for globals ... DONE
[15:31:05.063] Resolving globals: FALSE
[15:31:05.066] The total size of the 1 globals is 35.45 KiB (36296 bytes)
[15:31:05.067] The total size of the 1 globals exported for future expression ('FUN(X = structure(1:4, dim = c(2L, 2L)))') is 35.45 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (35.45 KiB of class 'function')
[15:31:05.067] - globals: [1] 'FUN'
[15:31:05.067] 
[15:31:05.068] getGlobalsAndPackages() ... DONE
[15:31:05.068]  - globals found/used: [n=1] 'FUN'
[15:31:05.068]  - needed namespaces: [n=0] 
[15:31:05.068] Finding globals ... DONE
[15:31:05.068]  - use_args: TRUE
[15:31:05.069]  - Getting '...' globals ...
[15:31:05.069] resolve() on list ...
[15:31:05.069]  recursive: 0
[15:31:05.070]  length: 1
[15:31:05.070]  elements: '...'
[15:31:05.070]  length: 0 (resolved future 1)
[15:31:05.070] resolve() on list ... DONE
[15:31:05.070]    - '...' content: [n=0] 
[15:31:05.071] List of 1
[15:31:05.071]  $ ...: list()
[15:31:05.071]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:05.071]  - attr(*, "where")=List of 1
[15:31:05.071]   ..$ ...:<environment: 0x000001bcbaf6a878> 
[15:31:05.071]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:05.071]  - attr(*, "resolved")= logi TRUE
[15:31:05.071]  - attr(*, "total_size")= num NA
[15:31:05.074]  - Getting '...' globals ... DONE
[15:31:05.075] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:05.075] List of 2
[15:31:05.075]  $ ...future.FUN:function (x, size, replace = FALSE, prob = NULL)  
[15:31:05.075]  $ ...          : list()
[15:31:05.075]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:05.075]  - attr(*, "where")=List of 2
[15:31:05.075]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:05.075]   ..$ ...          :<environment: 0x000001bcbaf6a878> 
[15:31:05.075]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:05.075]  - attr(*, "resolved")= logi FALSE
[15:31:05.075]  - attr(*, "total_size")= num 36296
[15:31:05.078] Packages to be attached in all futures: [n=0] 
[15:31:05.079] getGlobalsAndPackagesXApply() ... DONE
[15:31:05.079] future_lapply() ...
[15:31:05.082] Generating random seeds ...
[15:31:05.082] Generating random seed streams for 2 elements ...
[15:31:05.083] Generating random seed streams for 2 elements ... DONE
[15:31:05.083] Generating random seeds ... DONE
[15:31:05.083] Will set RNG state on exit: 10407, 356628882, 1215358059, 1505531436, 1161298033, 1312496802, 1386288591
[15:31:05.083] Number of chunks: 1
[15:31:05.084] getGlobalsAndPackagesXApply() ...
[15:31:05.084]  - future.globals: <name-value list> with names 'list()'
[15:31:05.084]  - use_args: TRUE
[15:31:05.084] Globals to be used in all futures (chunks): [n=2] '...', '...future.FUN'
[15:31:05.085] List of 2
[15:31:05.085]  $ ...          : list()
[15:31:05.085]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:05.085]  $ ...future.FUN:function (x, size, replace = FALSE, prob = NULL)  
[15:31:05.085]  - attr(*, "where")=List of 2
[15:31:05.085]   ..$ ...          :<environment: 0x000001bcbaf6a878> 
[15:31:05.085]   ..$ ...future.FUN:<environment: namespace:base> 
[15:31:05.085]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:05.085]  - attr(*, "resolved")= logi FALSE
[15:31:05.085]  - attr(*, "total_size")= num NA
[15:31:05.089] Packages to be attached in all futures: [n=0] 
[15:31:05.089] getGlobalsAndPackagesXApply() ... DONE
[15:31:05.089] Number of futures (= number of chunks): 1
[15:31:05.089] Launching 1 futures (chunks) ...
[15:31:05.090] Chunk #1 of 1 ...
[15:31:05.090]  - seeds: [2] <seeds>
[15:31:05.090]  - All globals exported: [n=5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:05.090] getGlobalsAndPackages() ...
[15:31:05.090] - globals passed as-is: [5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:05.092] Resolving globals: FALSE
[15:31:05.092] Tweak future expression to call with '...' arguments ...
[15:31:05.093] {
[15:31:05.093]     do.call(function(...) {
[15:31:05.093]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:05.093]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:05.093]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:05.093]             on.exit(options(oopts), add = TRUE)
[15:31:05.093]         }
[15:31:05.093]         {
[15:31:05.093]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:05.093]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:05.093]                 assign(".Random.seed", ...future.seeds_ii[[jj]], 
[15:31:05.093]                   envir = globalenv(), inherits = FALSE)
[15:31:05.093]                 ...future.FUN(...future.X_jj, ...)
[15:31:05.093]             })
[15:31:05.093]         }
[15:31:05.093]     }, args = future.call.arguments)
[15:31:05.093] }
[15:31:05.093] Tweak future expression to call with '...' arguments ... DONE
[15:31:05.094] - globals: [5] 'future.call.arguments', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:05.094] 
[15:31:05.095] getGlobalsAndPackages() ... DONE
[15:31:05.095] run() for 'Future' ...
[15:31:05.095] - state: 'created'
[15:31:05.095] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:31:05.096] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:05.096] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:31:05.096]   - Field: 'label'
[15:31:05.097]   - Field: 'local'
[15:31:05.097]   - Field: 'owner'
[15:31:05.097]   - Field: 'envir'
[15:31:05.097]   - Field: 'packages'
[15:31:05.097]   - Field: 'gc'
[15:31:05.098]   - Field: 'conditions'
[15:31:05.098]   - Field: 'expr'
[15:31:05.098]   - Field: 'uuid'
[15:31:05.098]   - Field: 'seed'
[15:31:05.098]   - Field: 'version'
[15:31:05.099]   - Field: 'result'
[15:31:05.099]   - Field: 'asynchronous'
[15:31:05.099]   - Field: 'calls'
[15:31:05.099]   - Field: 'globals'
[15:31:05.099]   - Field: 'stdout'
[15:31:05.100]   - Field: 'earlySignal'
[15:31:05.100]   - Field: 'lazy'
[15:31:05.100]   - Field: 'state'
[15:31:05.101] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:31:05.101] - Launch lazy future ...
[15:31:05.101] Packages needed by the future expression (n = 0): <none>
[15:31:05.101] Packages needed by future strategies (n = 0): <none>
[15:31:05.102] {
[15:31:05.102]     {
[15:31:05.102]         {
[15:31:05.102]             ...future.startTime <- base::Sys.time()
[15:31:05.102]             {
[15:31:05.102]                 {
[15:31:05.102]                   {
[15:31:05.102]                     base::local({
[15:31:05.102]                       has_future <- base::requireNamespace("future", 
[15:31:05.102]                         quietly = TRUE)
[15:31:05.102]                       if (has_future) {
[15:31:05.102]                         ns <- base::getNamespace("future")
[15:31:05.102]                         version <- ns[[".package"]][["version"]]
[15:31:05.102]                         if (is.null(version)) 
[15:31:05.102]                           version <- utils::packageVersion("future")
[15:31:05.102]                       }
[15:31:05.102]                       else {
[15:31:05.102]                         version <- NULL
[15:31:05.102]                       }
[15:31:05.102]                       if (!has_future || version < "1.8.0") {
[15:31:05.102]                         info <- base::c(r_version = base::gsub("R version ", 
[15:31:05.102]                           "", base::R.version$version.string), 
[15:31:05.102]                           platform = base::sprintf("%s (%s-bit)", 
[15:31:05.102]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:05.102]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:05.102]                             "release", "version")], collapse = " "), 
[15:31:05.102]                           hostname = base::Sys.info()[["nodename"]])
[15:31:05.102]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:31:05.102]                           info)
[15:31:05.102]                         info <- base::paste(info, collapse = "; ")
[15:31:05.102]                         if (!has_future) {
[15:31:05.102]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:05.102]                             info)
[15:31:05.102]                         }
[15:31:05.102]                         else {
[15:31:05.102]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:05.102]                             info, version)
[15:31:05.102]                         }
[15:31:05.102]                         base::stop(msg)
[15:31:05.102]                       }
[15:31:05.102]                     })
[15:31:05.102]                   }
[15:31:05.102]                   ...future.strategy.old <- future::plan("list")
[15:31:05.102]                   options(future.plan = NULL)
[15:31:05.102]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:05.102]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:05.102]                 }
[15:31:05.102]                 ...future.workdir <- getwd()
[15:31:05.102]             }
[15:31:05.102]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:05.102]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:05.102]         }
[15:31:05.102]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:05.102]             future.globals.maxSize = Inf, future.globals.method = NULL, 
[15:31:05.102]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:05.102]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:05.102]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:05.102]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:05.102]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:05.102]             base::names(...future.oldOptions))
[15:31:05.102]     }
[15:31:05.102]     if (FALSE) {
[15:31:05.102]     }
[15:31:05.102]     else {
[15:31:05.102]         if (TRUE) {
[15:31:05.102]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:05.102]                 open = "w")
[15:31:05.102]         }
[15:31:05.102]         else {
[15:31:05.102]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:05.102]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:05.102]         }
[15:31:05.102]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:05.102]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:05.102]             base::sink(type = "output", split = FALSE)
[15:31:05.102]             base::close(...future.stdout)
[15:31:05.102]         }, add = TRUE)
[15:31:05.102]     }
[15:31:05.102]     ...future.frame <- base::sys.nframe()
[15:31:05.102]     ...future.conditions <- base::list()
[15:31:05.102]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:05.102]     if (FALSE) {
[15:31:05.102]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:05.102]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:05.102]     }
[15:31:05.102]     ...future.result <- base::tryCatch({
[15:31:05.102]         base::withCallingHandlers({
[15:31:05.102]             ...future.value <- base::withVisible(base::local({
[15:31:05.102]                 do.call(function(...) {
[15:31:05.102]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:05.102]                   if (!identical(...future.globals.maxSize.org, 
[15:31:05.102]                     ...future.globals.maxSize)) {
[15:31:05.102]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:05.102]                     on.exit(options(oopts), add = TRUE)
[15:31:05.102]                   }
[15:31:05.102]                   {
[15:31:05.102]                     lapply(seq_along(...future.elements_ii), 
[15:31:05.102]                       FUN = function(jj) {
[15:31:05.102]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:05.102]                         assign(".Random.seed", ...future.seeds_ii[[jj]], 
[15:31:05.102]                           envir = globalenv(), inherits = FALSE)
[15:31:05.102]                         ...future.FUN(...future.X_jj, ...)
[15:31:05.102]                       })
[15:31:05.102]                   }
[15:31:05.102]                 }, args = future.call.arguments)
[15:31:05.102]             }))
[15:31:05.102]             future::FutureResult(value = ...future.value$value, 
[15:31:05.102]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:05.102]                   ...future.rng), globalenv = if (FALSE) 
[15:31:05.102]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:05.102]                     ...future.globalenv.names))
[15:31:05.102]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:05.102]         }, condition = base::local({
[15:31:05.102]             c <- base::c
[15:31:05.102]             inherits <- base::inherits
[15:31:05.102]             invokeRestart <- base::invokeRestart
[15:31:05.102]             length <- base::length
[15:31:05.102]             list <- base::list
[15:31:05.102]             seq.int <- base::seq.int
[15:31:05.102]             signalCondition <- base::signalCondition
[15:31:05.102]             sys.calls <- base::sys.calls
[15:31:05.102]             `[[` <- base::`[[`
[15:31:05.102]             `+` <- base::`+`
[15:31:05.102]             `<<-` <- base::`<<-`
[15:31:05.102]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:05.102]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:05.102]                   3L)]
[15:31:05.102]             }
[15:31:05.102]             function(cond) {
[15:31:05.102]                 is_error <- inherits(cond, "error")
[15:31:05.102]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:05.102]                   NULL)
[15:31:05.102]                 if (is_error) {
[15:31:05.102]                   sessionInformation <- function() {
[15:31:05.102]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:05.102]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:05.102]                       search = base::search(), system = base::Sys.info())
[15:31:05.102]                   }
[15:31:05.102]                   ...future.conditions[[length(...future.conditions) + 
[15:31:05.102]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:05.102]                     cond$call), session = sessionInformation(), 
[15:31:05.102]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:05.102]                   signalCondition(cond)
[15:31:05.102]                 }
[15:31:05.102]                 else if (!ignore && FALSE && inherits(cond, NULL)) {
[15:31:05.102]                   signal <- TRUE && inherits(cond, character(0))
[15:31:05.102]                   ...future.conditions[[length(...future.conditions) + 
[15:31:05.102]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:05.102]                   if (TRUE && !signal) {
[15:31:05.102]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:05.102]                     {
[15:31:05.102]                       inherits <- base::inherits
[15:31:05.102]                       invokeRestart <- base::invokeRestart
[15:31:05.102]                       is.null <- base::is.null
[15:31:05.102]                       muffled <- FALSE
[15:31:05.102]                       if (inherits(cond, "message")) {
[15:31:05.102]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:05.102]                         if (muffled) 
[15:31:05.102]                           invokeRestart("muffleMessage")
[15:31:05.102]                       }
[15:31:05.102]                       else if (inherits(cond, "warning")) {
[15:31:05.102]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:05.102]                         if (muffled) 
[15:31:05.102]                           invokeRestart("muffleWarning")
[15:31:05.102]                       }
[15:31:05.102]                       else if (inherits(cond, "condition")) {
[15:31:05.102]                         if (!is.null(pattern)) {
[15:31:05.102]                           computeRestarts <- base::computeRestarts
[15:31:05.102]                           grepl <- base::grepl
[15:31:05.102]                           restarts <- computeRestarts(cond)
[15:31:05.102]                           for (restart in restarts) {
[15:31:05.102]                             name <- restart$name
[15:31:05.102]                             if (is.null(name)) 
[15:31:05.102]                               next
[15:31:05.102]                             if (!grepl(pattern, name)) 
[15:31:05.102]                               next
[15:31:05.102]                             invokeRestart(restart)
[15:31:05.102]                             muffled <- TRUE
[15:31:05.102]                             break
[15:31:05.102]                           }
[15:31:05.102]                         }
[15:31:05.102]                       }
[15:31:05.102]                       invisible(muffled)
[15:31:05.102]                     }
[15:31:05.102]                     muffleCondition(cond, pattern = "^muffle")
[15:31:05.102]                   }
[15:31:05.102]                 }
[15:31:05.102]                 else {
[15:31:05.102]                   if (FALSE) {
[15:31:05.102]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:05.102]                     {
[15:31:05.102]                       inherits <- base::inherits
[15:31:05.102]                       invokeRestart <- base::invokeRestart
[15:31:05.102]                       is.null <- base::is.null
[15:31:05.102]                       muffled <- FALSE
[15:31:05.102]                       if (inherits(cond, "message")) {
[15:31:05.102]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:05.102]                         if (muffled) 
[15:31:05.102]                           invokeRestart("muffleMessage")
[15:31:05.102]                       }
[15:31:05.102]                       else if (inherits(cond, "warning")) {
[15:31:05.102]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:05.102]                         if (muffled) 
[15:31:05.102]                           invokeRestart("muffleWarning")
[15:31:05.102]                       }
[15:31:05.102]                       else if (inherits(cond, "condition")) {
[15:31:05.102]                         if (!is.null(pattern)) {
[15:31:05.102]                           computeRestarts <- base::computeRestarts
[15:31:05.102]                           grepl <- base::grepl
[15:31:05.102]                           restarts <- computeRestarts(cond)
[15:31:05.102]                           for (restart in restarts) {
[15:31:05.102]                             name <- restart$name
[15:31:05.102]                             if (is.null(name)) 
[15:31:05.102]                               next
[15:31:05.102]                             if (!grepl(pattern, name)) 
[15:31:05.102]                               next
[15:31:05.102]                             invokeRestart(restart)
[15:31:05.102]                             muffled <- TRUE
[15:31:05.102]                             break
[15:31:05.102]                           }
[15:31:05.102]                         }
[15:31:05.102]                       }
[15:31:05.102]                       invisible(muffled)
[15:31:05.102]                     }
[15:31:05.102]                     muffleCondition(cond, pattern = "^muffle")
[15:31:05.102]                   }
[15:31:05.102]                 }
[15:31:05.102]             }
[15:31:05.102]         }))
[15:31:05.102]     }, error = function(ex) {
[15:31:05.102]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:05.102]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:05.102]                 ...future.rng), started = ...future.startTime, 
[15:31:05.102]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:05.102]             version = "1.8"), class = "FutureResult")
[15:31:05.102]     }, finally = {
[15:31:05.102]         if (!identical(...future.workdir, getwd())) 
[15:31:05.102]             setwd(...future.workdir)
[15:31:05.102]         {
[15:31:05.102]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:05.102]                 ...future.oldOptions$nwarnings <- NULL
[15:31:05.102]             }
[15:31:05.102]             base::options(...future.oldOptions)
[15:31:05.102]             if (.Platform$OS.type == "windows") {
[15:31:05.102]                 old_names <- names(...future.oldEnvVars)
[15:31:05.102]                 envs <- base::Sys.getenv()
[15:31:05.102]                 names <- names(envs)
[15:31:05.102]                 common <- intersect(names, old_names)
[15:31:05.102]                 added <- setdiff(names, old_names)
[15:31:05.102]                 removed <- setdiff(old_names, names)
[15:31:05.102]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:05.102]                   envs[common]]
[15:31:05.102]                 NAMES <- toupper(changed)
[15:31:05.102]                 args <- list()
[15:31:05.102]                 for (kk in seq_along(NAMES)) {
[15:31:05.102]                   name <- changed[[kk]]
[15:31:05.102]                   NAME <- NAMES[[kk]]
[15:31:05.102]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:05.102]                     next
[15:31:05.102]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:05.102]                 }
[15:31:05.102]                 NAMES <- toupper(added)
[15:31:05.102]                 for (kk in seq_along(NAMES)) {
[15:31:05.102]                   name <- added[[kk]]
[15:31:05.102]                   NAME <- NAMES[[kk]]
[15:31:05.102]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:05.102]                     next
[15:31:05.102]                   args[[name]] <- ""
[15:31:05.102]                 }
[15:31:05.102]                 NAMES <- toupper(removed)
[15:31:05.102]                 for (kk in seq_along(NAMES)) {
[15:31:05.102]                   name <- removed[[kk]]
[15:31:05.102]                   NAME <- NAMES[[kk]]
[15:31:05.102]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:05.102]                     next
[15:31:05.102]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:05.102]                 }
[15:31:05.102]                 if (length(args) > 0) 
[15:31:05.102]                   base::do.call(base::Sys.setenv, args = args)
[15:31:05.102]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:05.102]             }
[15:31:05.102]             else {
[15:31:05.102]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:05.102]             }
[15:31:05.102]             {
[15:31:05.102]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:05.102]                   0L) {
[15:31:05.102]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:05.102]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:05.102]                   base::options(opts)
[15:31:05.102]                 }
[15:31:05.102]                 {
[15:31:05.102]                   {
[15:31:05.102]                     base::assign(".Random.seed", c(10407L, 356628882L, 
[15:31:05.102]                     1215358059L, 1505531436L, 1161298033L, 1312496802L, 
[15:31:05.102]                     1386288591L), envir = base::globalenv(), 
[15:31:05.102]                       inherits = FALSE)
[15:31:05.102]                     NULL
[15:31:05.102]                   }
[15:31:05.102]                   options(future.plan = NULL)
[15:31:05.102]                   if (is.na(NA_character_)) 
[15:31:05.102]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:05.102]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:05.102]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:05.102]                     .init = FALSE)
[15:31:05.102]                 }
[15:31:05.102]             }
[15:31:05.102]         }
[15:31:05.102]     })
[15:31:05.102]     if (TRUE) {
[15:31:05.102]         base::sink(type = "output", split = FALSE)
[15:31:05.102]         if (TRUE) {
[15:31:05.102]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:05.102]         }
[15:31:05.102]         else {
[15:31:05.102]             ...future.result["stdout"] <- base::list(NULL)
[15:31:05.102]         }
[15:31:05.102]         base::close(...future.stdout)
[15:31:05.102]         ...future.stdout <- NULL
[15:31:05.102]     }
[15:31:05.102]     ...future.result$conditions <- ...future.conditions
[15:31:05.102]     ...future.result$finished <- base::Sys.time()
[15:31:05.102]     ...future.result
[15:31:05.102] }
[15:31:05.106] assign_globals() ...
[15:31:05.107] List of 5
[15:31:05.107]  $ future.call.arguments    : list()
[15:31:05.107]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:05.107]  $ ...future.FUN            :function (x, size, replace = FALSE, prob = NULL)  
[15:31:05.107]  $ ...future.elements_ii    :List of 2
[15:31:05.107]   ..$ : int [1:2] 1 3
[15:31:05.107]   ..$ : int [1:2] 2 4
[15:31:05.107]  $ ...future.seeds_ii       :List of 2
[15:31:05.107]   ..$ : int [1:7] 10407 1242173061 -1150840343 -834448425 701050094 -1369558043 -650964284
[15:31:05.107]   ..$ : int [1:7] 10407 859061261 1088872332 -1371790091 -942478768 -889560561 1393381402
[15:31:05.107]  $ ...future.globals.maxSize: num Inf
[15:31:05.107]  - attr(*, "resolved")= logi FALSE
[15:31:05.107]  - attr(*, "total_size")= num NA
[15:31:05.107]  - attr(*, "where")=List of 5
[15:31:05.107]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:31:05.107]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:31:05.107]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:31:05.107]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:31:05.107]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:31:05.107]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:05.107]  - attr(*, "already-done")= logi TRUE
[15:31:05.118] - copied 'future.call.arguments' to environment
[15:31:05.118] - copied '...future.FUN' to environment
[15:31:05.118] - copied '...future.elements_ii' to environment
[15:31:05.119] - copied '...future.seeds_ii' to environment
[15:31:05.119] - copied '...future.globals.maxSize' to environment
[15:31:05.119] assign_globals() ... done
[15:31:05.120] plan(): Setting new future strategy stack:
[15:31:05.120] List of future strategies:
[15:31:05.120] 1. sequential:
[15:31:05.120]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:05.120]    - tweaked: FALSE
[15:31:05.120]    - call: NULL
[15:31:05.121] plan(): nbrOfWorkers() = 1
[15:31:05.123] plan(): Setting new future strategy stack:
[15:31:05.123] List of future strategies:
[15:31:05.123] 1. sequential:
[15:31:05.123]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:05.123]    - tweaked: FALSE
[15:31:05.123]    - call: plan(strategy)
[15:31:05.124] plan(): nbrOfWorkers() = 1
[15:31:05.125] SequentialFuture started (and completed)
[15:31:05.125] - Launch lazy future ... done
[15:31:05.125] run() for 'SequentialFuture' ... done
[15:31:05.126] Created future:
[15:31:05.126] SequentialFuture:
[15:31:05.126] Label: 'future_apply-1'
[15:31:05.126] Expression:
[15:31:05.126] {
[15:31:05.126]     do.call(function(...) {
[15:31:05.126]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:05.126]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:05.126]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:05.126]             on.exit(options(oopts), add = TRUE)
[15:31:05.126]         }
[15:31:05.126]         {
[15:31:05.126]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:05.126]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:05.126]                 assign(".Random.seed", ...future.seeds_ii[[jj]], 
[15:31:05.126]                   envir = globalenv(), inherits = FALSE)
[15:31:05.126]                 ...future.FUN(...future.X_jj, ...)
[15:31:05.126]             })
[15:31:05.126]         }
[15:31:05.126]     }, args = future.call.arguments)
[15:31:05.126] }
[15:31:05.126] Lazy evaluation: FALSE
[15:31:05.126] Asynchronous evaluation: FALSE
[15:31:05.126] Local evaluation: TRUE
[15:31:05.126] Environment: R_GlobalEnv
[15:31:05.126] Capture standard output: TRUE
[15:31:05.126] Capture condition classes: <none>
[15:31:05.126] Globals: 5 objects totaling 35.77 KiB (DotDotDotList 'future.call.arguments' of 0 bytes, function '...future.FUN' of 35.45 KiB, list '...future.elements_ii' of 112 bytes, list '...future.seeds_ii' of 160 bytes, numeric '...future.globals.maxSize' of 56 bytes)
[15:31:05.126] Packages: <none>
[15:31:05.126] L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[15:31:05.126] Resolved: TRUE
[15:31:05.126] Value: 112 bytes of class 'list'
[15:31:05.126] Early signaling: FALSE
[15:31:05.126] Owner process: 6672a580-6d3c-e82f-380e-108c475ace70
[15:31:05.126] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:05.128] Chunk #1 of 1 ... DONE
[15:31:05.128] Launching 1 futures (chunks) ... DONE
[15:31:05.129] Resolving 1 futures (chunks) ...
[15:31:05.129] resolve() on list ...
[15:31:05.129]  recursive: 0
[15:31:05.130]  length: 1
[15:31:05.130] 
[15:31:05.130] resolved() for 'SequentialFuture' ...
[15:31:05.130] - state: 'finished'
[15:31:05.131] - run: TRUE
[15:31:05.131] - result: 'FutureResult'
[15:31:05.134] resolved() for 'SequentialFuture' ... done
[15:31:05.134] Future #1
[15:31:05.135] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:31:05.135] - nx: 1
[15:31:05.135] - relay: TRUE
[15:31:05.136] - stdout: TRUE
[15:31:05.136] - signal: TRUE
[15:31:05.136] - resignal: FALSE
[15:31:05.137] - force: TRUE
[15:31:05.137] - relayed: [n=1] FALSE
[15:31:05.137] - queued futures: [n=1] FALSE
[15:31:05.137]  - until=1
[15:31:05.138]  - relaying element #1
[15:31:05.138] - relayed: [n=1] TRUE
[15:31:05.138] - queued futures: [n=1] TRUE
[15:31:05.139] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:31:05.139]  length: 0 (resolved future 1)
[15:31:05.139] Relaying remaining futures
[15:31:05.140] signalConditionsASAP(NULL, pos=0) ...
[15:31:05.141] - nx: 1
[15:31:05.141] - relay: TRUE
[15:31:05.141] - stdout: TRUE
[15:31:05.142] - signal: TRUE
[15:31:05.142] - resignal: FALSE
[15:31:05.143] - force: TRUE
[15:31:05.143] - relayed: [n=1] TRUE
[15:31:05.143] - queued futures: [n=1] TRUE
 - flush all
[15:31:05.144] - relayed: [n=1] TRUE
[15:31:05.144] - queued futures: [n=1] TRUE
[15:31:05.144] signalConditionsASAP(NULL, pos=0) ... done
[15:31:05.144] resolve() on list ... DONE
[15:31:05.145]  - Number of value chunks collected: 1
[15:31:05.145] Resolving 1 futures (chunks) ... DONE
[15:31:05.145] Reducing values from 1 chunks ...
[15:31:05.146]  - Number of values collected after concatenation: 2
[15:31:05.146]  - Number of values expected: 2
[15:31:05.146] Reducing values from 1 chunks ... DONE
[15:31:05.147] future_lapply() ... DONE
     [,1] [,2]
[1,]    3    2
[2,]    1    4
[15:31:05.147] plan(): Setting new future strategy stack:
[15:31:05.148] List of future strategies:
[15:31:05.148] 1. sequential:
[15:31:05.148]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:05.148]    - tweaked: FALSE
[15:31:05.148]    - call: plan(sequential)
[15:31:05.149] plan(): nbrOfWorkers() = 1
*** strategy = 'sequential' ... done
*** strategy = 'multisession' ...
[15:31:05.150] plan(): Setting new future strategy stack:
[15:31:05.150] List of future strategies:
[15:31:05.150] 1. multisession:
[15:31:05.150]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[15:31:05.150]    - tweaked: FALSE
[15:31:05.150]    - call: plan(strategy)
[15:31:05.151] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[15:31:05.151] multisession:
[15:31:05.151] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[15:31:05.151] - tweaked: FALSE
[15:31:05.151] - call: plan(strategy)
[15:31:05.159] getGlobalsAndPackages() ...
[15:31:05.160] Not searching for globals
[15:31:05.160] - globals: [0] <none>
[15:31:05.161] getGlobalsAndPackages() ... DONE
[15:31:05.161] [local output] makeClusterPSOCK() ...
[15:31:05.244] [local output] Workers: [n = 2] 'localhost', 'localhost'
[15:31:05.254] [local output] Base port: 35347
[15:31:05.254] [local output] Getting setup options for 2 cluster nodes ...
[15:31:05.255] [local output]  - Node 1 of 2 ...
[15:31:05.256] [local output] localMachine=TRUE => revtunnel=FALSE

[15:31:05.258] Testing if worker's PID can be inferred: '"D:/RCompile/recent/R/bin/x64/Rscript" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpInST4E/worker.rank=1.parallelly.parent=168400.291d050b130e0.pid\")), silent = TRUE)" -e "file.exists(\"D:/temp/RtmpInST4E/worker.rank=1.parallelly.parent=168400.291d050b130e0.pid\")"'
[15:31:05.702] - Possible to infer worker's PID: TRUE
[15:31:05.703] [local output] Rscript port: 35347

[15:31:05.703] [local output]  - Node 2 of 2 ...
[15:31:05.704] [local output] localMachine=TRUE => revtunnel=FALSE

[15:31:05.706] [local output] Rscript port: 35347

[15:31:05.707] [local output] Getting setup options for 2 cluster nodes ... done
[15:31:05.707] [local output]  - Parallel setup requested for some PSOCK nodes
[15:31:05.708] [local output] Setting up PSOCK nodes in parallel
[15:31:05.708] List of 36
[15:31:05.708]  $ worker          : chr "localhost"
[15:31:05.708]   ..- attr(*, "localhost")= logi TRUE
[15:31:05.708]  $ master          : chr "localhost"
[15:31:05.708]  $ port            : int 35347
[15:31:05.708]  $ connectTimeout  : num 120
[15:31:05.708]  $ timeout         : num 120
[15:31:05.708]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[15:31:05.708]  $ homogeneous     : logi TRUE
[15:31:05.708]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=future_apply.R:168400:CRANWIN3:C"| __truncated__
[15:31:05.708]  $ rscript_envs    : NULL
[15:31:05.708]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpIhDozX/RLIBS_2bbc83f2b47c7" "D:/RCompile/recent/R/library"
[15:31:05.708]  $ rscript_startup : NULL
[15:31:05.708]  $ rscript_sh      : chr "cmd"
[15:31:05.708]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[15:31:05.708]  $ methods         : logi TRUE
[15:31:05.708]  $ socketOptions   : chr "no-delay"
[15:31:05.708]  $ useXDR          : logi FALSE
[15:31:05.708]  $ outfile         : chr "/dev/null"
[15:31:05.708]  $ renice          : int NA
[15:31:05.708]  $ rshcmd          : NULL
[15:31:05.708]  $ user            : chr(0) 
[15:31:05.708]  $ revtunnel       : logi FALSE
[15:31:05.708]  $ rshlogfile      : NULL
[15:31:05.708]  $ rshopts         : chr(0) 
[15:31:05.708]  $ rank            : int 1
[15:31:05.708]  $ manual          : logi FALSE
[15:31:05.708]  $ dryrun          : logi FALSE
[15:31:05.708]  $ quiet           : logi FALSE
[15:31:05.708]  $ setup_strategy  : chr "parallel"
[15:31:05.708]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[15:31:05.708]  $ pidfile         : chr "D:/temp/RtmpInST4E/worker.rank=1.parallelly.parent=168400.291d050b130e0.pid"
[15:31:05.708]  $ rshcmd_label    : NULL
[15:31:05.708]  $ rsh_call        : NULL
[15:31:05.708]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[15:31:05.708]  $ localMachine    : logi TRUE
[15:31:05.708]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[15:31:05.708]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[15:31:05.708]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[15:31:05.708]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[15:31:05.708]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[15:31:05.708]         "cmd", "sh"), default_packages = c("datasets", "utils", "grDevices", 
[15:31:05.708]         "graphics", "stats", if (methods) "methods"), methods = TRUE, socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[15:31:05.708]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[15:31:05.708]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[15:31:05.708]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[15:31:05.708]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[15:31:05.708]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[15:31:05.708]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[15:31:05.708]  $ arguments       :List of 28
[15:31:05.708]   ..$ worker          : chr "localhost"
[15:31:05.708]   ..$ master          : NULL
[15:31:05.708]   ..$ port            : int 35347
[15:31:05.708]   ..$ connectTimeout  : num 120
[15:31:05.708]   ..$ timeout         : num 120
[15:31:05.708]   ..$ rscript         : NULL
[15:31:05.708]   ..$ homogeneous     : NULL
[15:31:05.708]   ..$ rscript_args    : NULL
[15:31:05.708]   ..$ rscript_envs    : NULL
[15:31:05.708]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpIhDozX/RLIBS_2bbc83f2b47c7" "D:/RCompile/recent/R/library"
[15:31:05.708]   ..$ rscript_startup : NULL
[15:31:05.708]   ..$ rscript_sh      : chr [1:3] "auto" "cmd" "sh"
[15:31:05.708]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[15:31:05.708]   ..$ methods         : logi TRUE
[15:31:05.708]   ..$ socketOptions   : chr "no-delay"
[15:31:05.708]   ..$ useXDR          : logi FALSE
[15:31:05.708]   ..$ outfile         : chr "/dev/null"
[15:31:05.708]   ..$ renice          : int NA
[15:31:05.708]   ..$ rshcmd          : NULL
[15:31:05.708]   ..$ user            : NULL
[15:31:05.708]   ..$ revtunnel       : logi NA
[15:31:05.708]   ..$ rshlogfile      : NULL
[15:31:05.708]   ..$ rshopts         : NULL
[15:31:05.708]   ..$ rank            : int 1
[15:31:05.708]   ..$ manual          : logi FALSE
[15:31:05.708]   ..$ dryrun          : logi FALSE
[15:31:05.708]   ..$ quiet           : logi FALSE
[15:31:05.708]   ..$ setup_strategy  : chr "parallel"
[15:31:05.708]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[15:31:05.743] [local output] System call to launch all workers:
[15:31:05.743] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=future_apply.R:168400:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpInST4E/worker.rank=1.parallelly.parent=168400.291d050b130e0.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e ".libPaths(c(\"D:/temp/RtmpIhDozX/RLIBS_2bbc83f2b47c7\",\"D:/RCompile/recent/R/library\"))" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=35347 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[15:31:05.743] [local output] Starting PSOCK main server
[15:31:05.753] [local output] Workers launched
[15:31:05.753] [local output] Waiting for workers to connect back
[15:31:05.753]  - [local output] 0 workers out of 2 ready
[15:31:05.992]  - [local output] 0 workers out of 2 ready
[15:31:05.992]  - [local output] 1 workers out of 2 ready
[15:31:05.996]  - [local output] 1 workers out of 2 ready
[15:31:05.997]  - [local output] 2 workers out of 2 ready
[15:31:05.997] [local output] Launching of workers completed
[15:31:05.998] [local output] Collecting session information from workers
[15:31:05.999] [local output]  - Worker #1 of 2
[15:31:06.000] [local output]  - Worker #2 of 2
[15:31:06.001] [local output] makeClusterPSOCK() ... done
[15:31:06.017] Packages needed by the future expression (n = 0): <none>
[15:31:06.017] Packages needed by future strategies (n = 0): <none>
[15:31:06.018] {
[15:31:06.018]     {
[15:31:06.018]         {
[15:31:06.018]             ...future.startTime <- base::Sys.time()
[15:31:06.018]             {
[15:31:06.018]                 {
[15:31:06.018]                   {
[15:31:06.018]                     {
[15:31:06.018]                       base::local({
[15:31:06.018]                         has_future <- base::requireNamespace("future", 
[15:31:06.018]                           quietly = TRUE)
[15:31:06.018]                         if (has_future) {
[15:31:06.018]                           ns <- base::getNamespace("future")
[15:31:06.018]                           version <- ns[[".package"]][["version"]]
[15:31:06.018]                           if (is.null(version)) 
[15:31:06.018]                             version <- utils::packageVersion("future")
[15:31:06.018]                         }
[15:31:06.018]                         else {
[15:31:06.018]                           version <- NULL
[15:31:06.018]                         }
[15:31:06.018]                         if (!has_future || version < "1.8.0") {
[15:31:06.018]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:06.018]                             "", base::R.version$version.string), 
[15:31:06.018]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:06.018]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:06.018]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:06.018]                               "release", "version")], collapse = " "), 
[15:31:06.018]                             hostname = base::Sys.info()[["nodename"]])
[15:31:06.018]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:06.018]                             info)
[15:31:06.018]                           info <- base::paste(info, collapse = "; ")
[15:31:06.018]                           if (!has_future) {
[15:31:06.018]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:06.018]                               info)
[15:31:06.018]                           }
[15:31:06.018]                           else {
[15:31:06.018]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:06.018]                               info, version)
[15:31:06.018]                           }
[15:31:06.018]                           base::stop(msg)
[15:31:06.018]                         }
[15:31:06.018]                       })
[15:31:06.018]                     }
[15:31:06.018]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:06.018]                     base::options(mc.cores = 1L)
[15:31:06.018]                   }
[15:31:06.018]                   ...future.strategy.old <- future::plan("list")
[15:31:06.018]                   options(future.plan = NULL)
[15:31:06.018]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:06.018]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:06.018]                 }
[15:31:06.018]                 ...future.workdir <- getwd()
[15:31:06.018]             }
[15:31:06.018]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:06.018]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:06.018]         }
[15:31:06.018]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:06.018]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:31:06.018]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:06.018]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:06.018]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:06.018]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:06.018]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:06.018]             base::names(...future.oldOptions))
[15:31:06.018]     }
[15:31:06.018]     if (FALSE) {
[15:31:06.018]     }
[15:31:06.018]     else {
[15:31:06.018]         if (TRUE) {
[15:31:06.018]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:06.018]                 open = "w")
[15:31:06.018]         }
[15:31:06.018]         else {
[15:31:06.018]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:06.018]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:06.018]         }
[15:31:06.018]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:06.018]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:06.018]             base::sink(type = "output", split = FALSE)
[15:31:06.018]             base::close(...future.stdout)
[15:31:06.018]         }, add = TRUE)
[15:31:06.018]     }
[15:31:06.018]     ...future.frame <- base::sys.nframe()
[15:31:06.018]     ...future.conditions <- base::list()
[15:31:06.018]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:06.018]     if (FALSE) {
[15:31:06.018]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:06.018]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:06.018]     }
[15:31:06.018]     ...future.result <- base::tryCatch({
[15:31:06.018]         base::withCallingHandlers({
[15:31:06.018]             ...future.value <- base::withVisible(base::local({
[15:31:06.018]                 ...future.makeSendCondition <- base::local({
[15:31:06.018]                   sendCondition <- NULL
[15:31:06.018]                   function(frame = 1L) {
[15:31:06.018]                     if (is.function(sendCondition)) 
[15:31:06.018]                       return(sendCondition)
[15:31:06.018]                     ns <- getNamespace("parallel")
[15:31:06.018]                     if (exists("sendData", mode = "function", 
[15:31:06.018]                       envir = ns)) {
[15:31:06.018]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:06.018]                         envir = ns)
[15:31:06.018]                       envir <- sys.frame(frame)
[15:31:06.018]                       master <- NULL
[15:31:06.018]                       while (!identical(envir, .GlobalEnv) && 
[15:31:06.018]                         !identical(envir, emptyenv())) {
[15:31:06.018]                         if (exists("master", mode = "list", envir = envir, 
[15:31:06.018]                           inherits = FALSE)) {
[15:31:06.018]                           master <- get("master", mode = "list", 
[15:31:06.018]                             envir = envir, inherits = FALSE)
[15:31:06.018]                           if (inherits(master, c("SOCKnode", 
[15:31:06.018]                             "SOCK0node"))) {
[15:31:06.018]                             sendCondition <<- function(cond) {
[15:31:06.018]                               data <- list(type = "VALUE", value = cond, 
[15:31:06.018]                                 success = TRUE)
[15:31:06.018]                               parallel_sendData(master, data)
[15:31:06.018]                             }
[15:31:06.018]                             return(sendCondition)
[15:31:06.018]                           }
[15:31:06.018]                         }
[15:31:06.018]                         frame <- frame + 1L
[15:31:06.018]                         envir <- sys.frame(frame)
[15:31:06.018]                       }
[15:31:06.018]                     }
[15:31:06.018]                     sendCondition <<- function(cond) NULL
[15:31:06.018]                   }
[15:31:06.018]                 })
[15:31:06.018]                 withCallingHandlers({
[15:31:06.018]                   NA
[15:31:06.018]                 }, immediateCondition = function(cond) {
[15:31:06.018]                   sendCondition <- ...future.makeSendCondition()
[15:31:06.018]                   sendCondition(cond)
[15:31:06.018]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:06.018]                   {
[15:31:06.018]                     inherits <- base::inherits
[15:31:06.018]                     invokeRestart <- base::invokeRestart
[15:31:06.018]                     is.null <- base::is.null
[15:31:06.018]                     muffled <- FALSE
[15:31:06.018]                     if (inherits(cond, "message")) {
[15:31:06.018]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:06.018]                       if (muffled) 
[15:31:06.018]                         invokeRestart("muffleMessage")
[15:31:06.018]                     }
[15:31:06.018]                     else if (inherits(cond, "warning")) {
[15:31:06.018]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:06.018]                       if (muffled) 
[15:31:06.018]                         invokeRestart("muffleWarning")
[15:31:06.018]                     }
[15:31:06.018]                     else if (inherits(cond, "condition")) {
[15:31:06.018]                       if (!is.null(pattern)) {
[15:31:06.018]                         computeRestarts <- base::computeRestarts
[15:31:06.018]                         grepl <- base::grepl
[15:31:06.018]                         restarts <- computeRestarts(cond)
[15:31:06.018]                         for (restart in restarts) {
[15:31:06.018]                           name <- restart$name
[15:31:06.018]                           if (is.null(name)) 
[15:31:06.018]                             next
[15:31:06.018]                           if (!grepl(pattern, name)) 
[15:31:06.018]                             next
[15:31:06.018]                           invokeRestart(restart)
[15:31:06.018]                           muffled <- TRUE
[15:31:06.018]                           break
[15:31:06.018]                         }
[15:31:06.018]                       }
[15:31:06.018]                     }
[15:31:06.018]                     invisible(muffled)
[15:31:06.018]                   }
[15:31:06.018]                   muffleCondition(cond)
[15:31:06.018]                 })
[15:31:06.018]             }))
[15:31:06.018]             future::FutureResult(value = ...future.value$value, 
[15:31:06.018]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:06.018]                   ...future.rng), globalenv = if (FALSE) 
[15:31:06.018]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:06.018]                     ...future.globalenv.names))
[15:31:06.018]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:06.018]         }, condition = base::local({
[15:31:06.018]             c <- base::c
[15:31:06.018]             inherits <- base::inherits
[15:31:06.018]             invokeRestart <- base::invokeRestart
[15:31:06.018]             length <- base::length
[15:31:06.018]             list <- base::list
[15:31:06.018]             seq.int <- base::seq.int
[15:31:06.018]             signalCondition <- base::signalCondition
[15:31:06.018]             sys.calls <- base::sys.calls
[15:31:06.018]             `[[` <- base::`[[`
[15:31:06.018]             `+` <- base::`+`
[15:31:06.018]             `<<-` <- base::`<<-`
[15:31:06.018]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:06.018]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:06.018]                   3L)]
[15:31:06.018]             }
[15:31:06.018]             function(cond) {
[15:31:06.018]                 is_error <- inherits(cond, "error")
[15:31:06.018]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:06.018]                   NULL)
[15:31:06.018]                 if (is_error) {
[15:31:06.018]                   sessionInformation <- function() {
[15:31:06.018]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:06.018]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:06.018]                       search = base::search(), system = base::Sys.info())
[15:31:06.018]                   }
[15:31:06.018]                   ...future.conditions[[length(...future.conditions) + 
[15:31:06.018]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:06.018]                     cond$call), session = sessionInformation(), 
[15:31:06.018]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:06.018]                   signalCondition(cond)
[15:31:06.018]                 }
[15:31:06.018]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:06.018]                 "immediateCondition"))) {
[15:31:06.018]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:06.018]                   ...future.conditions[[length(...future.conditions) + 
[15:31:06.018]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:06.018]                   if (TRUE && !signal) {
[15:31:06.018]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:06.018]                     {
[15:31:06.018]                       inherits <- base::inherits
[15:31:06.018]                       invokeRestart <- base::invokeRestart
[15:31:06.018]                       is.null <- base::is.null
[15:31:06.018]                       muffled <- FALSE
[15:31:06.018]                       if (inherits(cond, "message")) {
[15:31:06.018]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:06.018]                         if (muffled) 
[15:31:06.018]                           invokeRestart("muffleMessage")
[15:31:06.018]                       }
[15:31:06.018]                       else if (inherits(cond, "warning")) {
[15:31:06.018]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:06.018]                         if (muffled) 
[15:31:06.018]                           invokeRestart("muffleWarning")
[15:31:06.018]                       }
[15:31:06.018]                       else if (inherits(cond, "condition")) {
[15:31:06.018]                         if (!is.null(pattern)) {
[15:31:06.018]                           computeRestarts <- base::computeRestarts
[15:31:06.018]                           grepl <- base::grepl
[15:31:06.018]                           restarts <- computeRestarts(cond)
[15:31:06.018]                           for (restart in restarts) {
[15:31:06.018]                             name <- restart$name
[15:31:06.018]                             if (is.null(name)) 
[15:31:06.018]                               next
[15:31:06.018]                             if (!grepl(pattern, name)) 
[15:31:06.018]                               next
[15:31:06.018]                             invokeRestart(restart)
[15:31:06.018]                             muffled <- TRUE
[15:31:06.018]                             break
[15:31:06.018]                           }
[15:31:06.018]                         }
[15:31:06.018]                       }
[15:31:06.018]                       invisible(muffled)
[15:31:06.018]                     }
[15:31:06.018]                     muffleCondition(cond, pattern = "^muffle")
[15:31:06.018]                   }
[15:31:06.018]                 }
[15:31:06.018]                 else {
[15:31:06.018]                   if (TRUE) {
[15:31:06.018]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:06.018]                     {
[15:31:06.018]                       inherits <- base::inherits
[15:31:06.018]                       invokeRestart <- base::invokeRestart
[15:31:06.018]                       is.null <- base::is.null
[15:31:06.018]                       muffled <- FALSE
[15:31:06.018]                       if (inherits(cond, "message")) {
[15:31:06.018]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:06.018]                         if (muffled) 
[15:31:06.018]                           invokeRestart("muffleMessage")
[15:31:06.018]                       }
[15:31:06.018]                       else if (inherits(cond, "warning")) {
[15:31:06.018]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:06.018]                         if (muffled) 
[15:31:06.018]                           invokeRestart("muffleWarning")
[15:31:06.018]                       }
[15:31:06.018]                       else if (inherits(cond, "condition")) {
[15:31:06.018]                         if (!is.null(pattern)) {
[15:31:06.018]                           computeRestarts <- base::computeRestarts
[15:31:06.018]                           grepl <- base::grepl
[15:31:06.018]                           restarts <- computeRestarts(cond)
[15:31:06.018]                           for (restart in restarts) {
[15:31:06.018]                             name <- restart$name
[15:31:06.018]                             if (is.null(name)) 
[15:31:06.018]                               next
[15:31:06.018]                             if (!grepl(pattern, name)) 
[15:31:06.018]                               next
[15:31:06.018]                             invokeRestart(restart)
[15:31:06.018]                             muffled <- TRUE
[15:31:06.018]                             break
[15:31:06.018]                           }
[15:31:06.018]                         }
[15:31:06.018]                       }
[15:31:06.018]                       invisible(muffled)
[15:31:06.018]                     }
[15:31:06.018]                     muffleCondition(cond, pattern = "^muffle")
[15:31:06.018]                   }
[15:31:06.018]                 }
[15:31:06.018]             }
[15:31:06.018]         }))
[15:31:06.018]     }, error = function(ex) {
[15:31:06.018]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:06.018]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:06.018]                 ...future.rng), started = ...future.startTime, 
[15:31:06.018]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:06.018]             version = "1.8"), class = "FutureResult")
[15:31:06.018]     }, finally = {
[15:31:06.018]         if (!identical(...future.workdir, getwd())) 
[15:31:06.018]             setwd(...future.workdir)
[15:31:06.018]         {
[15:31:06.018]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:06.018]                 ...future.oldOptions$nwarnings <- NULL
[15:31:06.018]             }
[15:31:06.018]             base::options(...future.oldOptions)
[15:31:06.018]             if (.Platform$OS.type == "windows") {
[15:31:06.018]                 old_names <- names(...future.oldEnvVars)
[15:31:06.018]                 envs <- base::Sys.getenv()
[15:31:06.018]                 names <- names(envs)
[15:31:06.018]                 common <- intersect(names, old_names)
[15:31:06.018]                 added <- setdiff(names, old_names)
[15:31:06.018]                 removed <- setdiff(old_names, names)
[15:31:06.018]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:06.018]                   envs[common]]
[15:31:06.018]                 NAMES <- toupper(changed)
[15:31:06.018]                 args <- list()
[15:31:06.018]                 for (kk in seq_along(NAMES)) {
[15:31:06.018]                   name <- changed[[kk]]
[15:31:06.018]                   NAME <- NAMES[[kk]]
[15:31:06.018]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:06.018]                     next
[15:31:06.018]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:06.018]                 }
[15:31:06.018]                 NAMES <- toupper(added)
[15:31:06.018]                 for (kk in seq_along(NAMES)) {
[15:31:06.018]                   name <- added[[kk]]
[15:31:06.018]                   NAME <- NAMES[[kk]]
[15:31:06.018]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:06.018]                     next
[15:31:06.018]                   args[[name]] <- ""
[15:31:06.018]                 }
[15:31:06.018]                 NAMES <- toupper(removed)
[15:31:06.018]                 for (kk in seq_along(NAMES)) {
[15:31:06.018]                   name <- removed[[kk]]
[15:31:06.018]                   NAME <- NAMES[[kk]]
[15:31:06.018]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:06.018]                     next
[15:31:06.018]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:06.018]                 }
[15:31:06.018]                 if (length(args) > 0) 
[15:31:06.018]                   base::do.call(base::Sys.setenv, args = args)
[15:31:06.018]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:06.018]             }
[15:31:06.018]             else {
[15:31:06.018]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:06.018]             }
[15:31:06.018]             {
[15:31:06.018]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:06.018]                   0L) {
[15:31:06.018]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:06.018]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:06.018]                   base::options(opts)
[15:31:06.018]                 }
[15:31:06.018]                 {
[15:31:06.018]                   {
[15:31:06.018]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:06.018]                     NULL
[15:31:06.018]                   }
[15:31:06.018]                   options(future.plan = NULL)
[15:31:06.018]                   if (is.na(NA_character_)) 
[15:31:06.018]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:06.018]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:06.018]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:06.018]                     .init = FALSE)
[15:31:06.018]                 }
[15:31:06.018]             }
[15:31:06.018]         }
[15:31:06.018]     })
[15:31:06.018]     if (TRUE) {
[15:31:06.018]         base::sink(type = "output", split = FALSE)
[15:31:06.018]         if (TRUE) {
[15:31:06.018]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:06.018]         }
[15:31:06.018]         else {
[15:31:06.018]             ...future.result["stdout"] <- base::list(NULL)
[15:31:06.018]         }
[15:31:06.018]         base::close(...future.stdout)
[15:31:06.018]         ...future.stdout <- NULL
[15:31:06.018]     }
[15:31:06.018]     ...future.result$conditions <- ...future.conditions
[15:31:06.018]     ...future.result$finished <- base::Sys.time()
[15:31:06.018]     ...future.result
[15:31:06.018] }
[15:31:06.154] MultisessionFuture started
[15:31:06.154] result() for ClusterFuture ...
[15:31:06.155] receiveMessageFromWorker() for ClusterFuture ...
[15:31:06.156] - Validating connection of MultisessionFuture
[15:31:06.234] - received message: FutureResult
[15:31:06.235] - Received FutureResult
[15:31:06.241] - Erased future from FutureRegistry
[15:31:06.242] result() for ClusterFuture ...
[15:31:06.242] - result already collected: FutureResult
[15:31:06.243] result() for ClusterFuture ... done
[15:31:06.243] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:06.243] result() for ClusterFuture ... done
[15:31:06.244] result() for ClusterFuture ...
[15:31:06.244] - result already collected: FutureResult
[15:31:06.244] result() for ClusterFuture ... done
[15:31:06.244] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[15:31:06.249] plan(): nbrOfWorkers() = 2
- From example(apply) ...
[15:31:06.250] getGlobalsAndPackagesXApply() ...
[15:31:06.250]  - future.globals: TRUE
[15:31:06.251] getGlobalsAndPackages() ...
[15:31:06.251] Searching for globals...
[15:31:06.347] - globals found: [59] 'FUN', 'if', '==', 'c', 'list.names', '{', '<-', '[', 'as.list', 'substitute', '-', '&&', 'length', 'is.list', '!', 'is.null', 'names', 'return', 'seq_along', 'vapply', 'switch', '+', 'is.symbol', 'as.character', 'deparse', '[<-', 'missing', 'match', 'match.arg', '!=', 'warning', 'list', '[[', 'paste', 'stop', 'integer', 'for', 'is.factor', 'anyNA', 'options', 'on.exit', 'factor', '(', '||', 'levels', 'as.integer', 'which', 'is.na', 'is.na<-', '>', 'prod', '$', '.Machine', '*', 'names<-', 'array', 'tabulate', 'class', 'class<-'
[15:31:06.348] Searching for globals ... DONE
[15:31:06.348] Resolving globals: FALSE
[15:31:06.350] The total size of the 1 globals is 345.92 KiB (354224 bytes)
[15:31:06.351] The total size of the 1 globals exported for future expression ('FUN(X = structure(c(1, 2, 3, 4, 1, 6, 7, 8), dim = c(2L, 4L)))') is 345.92 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (345.92 KiB of class 'function')
[15:31:06.351] - globals: [1] 'FUN'
[15:31:06.351] 
[15:31:06.351] getGlobalsAndPackages() ... DONE
[15:31:06.351]  - globals found/used: [n=1] 'FUN'
[15:31:06.351]  - needed namespaces: [n=0] 
[15:31:06.352] Finding globals ... DONE
[15:31:06.352]  - use_args: TRUE
[15:31:06.352]  - Getting '...' globals ...
[15:31:06.352] resolve() on list ...
[15:31:06.353]  recursive: 0
[15:31:06.353]  length: 1
[15:31:06.353]  elements: '...'
[15:31:06.353]  length: 0 (resolved future 1)
[15:31:06.353] resolve() on list ... DONE
[15:31:06.353]    - '...' content: [n=0] 
[15:31:06.354] List of 1
[15:31:06.354]  $ ...: list()
[15:31:06.354]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:06.354]  - attr(*, "where")=List of 1
[15:31:06.354]   ..$ ...:<environment: 0x000001bcbdc75e68> 
[15:31:06.354]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:06.354]  - attr(*, "resolved")= logi TRUE
[15:31:06.354]  - attr(*, "total_size")= num NA
[15:31:06.357]  - Getting '...' globals ... DONE
[15:31:06.357] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:06.358] List of 2
[15:31:06.358]  $ ...future.FUN:function (..., exclude = if (useNA == "no") c(NA, NaN), useNA = c("no", 
[15:31:06.358]     "ifany", "always"), dnn = list.names(...), deparse.level = 1)  
[15:31:06.358]  $ ...          : list()
[15:31:06.358]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:06.358]  - attr(*, "where")=List of 2
[15:31:06.358]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:06.358]   ..$ ...          :<environment: 0x000001bcbdc75e68> 
[15:31:06.358]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:06.358]  - attr(*, "resolved")= logi FALSE
[15:31:06.358]  - attr(*, "total_size")= num 354224
[15:31:06.362] Packages to be attached in all futures: [n=0] 
[15:31:06.362] getGlobalsAndPackagesXApply() ... DONE
[15:31:06.366] future_lapply() ...
[15:31:06.434] Number of chunks: 2
[15:31:06.434] getGlobalsAndPackagesXApply() ...
[15:31:06.434]  - future.globals: <name-value list> with names 'list()'
[15:31:06.435]  - use_args: TRUE
[15:31:06.435] Globals to be used in all futures (chunks): [n=2] '...', '...future.FUN'
[15:31:06.435] List of 2
[15:31:06.435]  $ ...          : list()
[15:31:06.435]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:06.435]  $ ...future.FUN:function (..., exclude = if (useNA == "no") c(NA, NaN), useNA = c("no", 
[15:31:06.435]     "ifany", "always"), dnn = list.names(...), deparse.level = 1)  
[15:31:06.435]  - attr(*, "where")=List of 2
[15:31:06.435]   ..$ ...          :<environment: 0x000001bcbdc75e68> 
[15:31:06.435]   ..$ ...future.FUN:<environment: namespace:base> 
[15:31:06.435]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:06.435]  - attr(*, "resolved")= logi FALSE
[15:31:06.435]  - attr(*, "total_size")= num NA
[15:31:06.442] Packages to be attached in all futures: [n=0] 
[15:31:06.442] getGlobalsAndPackagesXApply() ... DONE
[15:31:06.442] Number of futures (= number of chunks): 2
[15:31:06.443] Launching 2 futures (chunks) ...
[15:31:06.443] Chunk #1 of 2 ...
[15:31:06.443]  - Adjusted option 'future.globals.maxSize': Inf -> 2 * Inf = Inf (bytes)
[15:31:06.443]  - seeds: <none>
[15:31:06.443]  - All globals exported: [n=5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:06.444] getGlobalsAndPackages() ...
[15:31:06.444] - globals passed as-is: [5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:06.444] Resolving globals: FALSE
[15:31:06.444] Tweak future expression to call with '...' arguments ...
[15:31:06.445] {
[15:31:06.445]     do.call(function(...) {
[15:31:06.445]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:06.445]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:06.445]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:06.445]             on.exit(options(oopts), add = TRUE)
[15:31:06.445]         }
[15:31:06.445]         {
[15:31:06.445]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:06.445]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:06.445]                 ...future.FUN(...future.X_jj, ...)
[15:31:06.445]             })
[15:31:06.445]         }
[15:31:06.445]     }, args = future.call.arguments)
[15:31:06.445] }
[15:31:06.445] Tweak future expression to call with '...' arguments ... DONE
[15:31:06.446] - globals: [5] 'future.call.arguments', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:06.446] 
[15:31:06.446] getGlobalsAndPackages() ... DONE
[15:31:06.447] run() for 'Future' ...
[15:31:06.447] - state: 'created'
[15:31:06.447] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:06.465] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:06.465] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:31:06.466]   - Field: 'node'
[15:31:06.466]   - Field: 'label'
[15:31:06.466]   - Field: 'local'
[15:31:06.467]   - Field: 'owner'
[15:31:06.467]   - Field: 'envir'
[15:31:06.467]   - Field: 'workers'
[15:31:06.467]   - Field: 'packages'
[15:31:06.468]   - Field: 'gc'
[15:31:06.468]   - Field: 'conditions'
[15:31:06.468]   - Field: 'persistent'
[15:31:06.469]   - Field: 'expr'
[15:31:06.469]   - Field: 'uuid'
[15:31:06.469]   - Field: 'seed'
[15:31:06.470]   - Field: 'version'
[15:31:06.470]   - Field: 'result'
[15:31:06.470]   - Field: 'asynchronous'
[15:31:06.470]   - Field: 'calls'
[15:31:06.471]   - Field: 'globals'
[15:31:06.471]   - Field: 'stdout'
[15:31:06.471]   - Field: 'earlySignal'
[15:31:06.472]   - Field: 'lazy'
[15:31:06.472]   - Field: 'state'
[15:31:06.472] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:31:06.473] - Launch lazy future ...
[15:31:06.473] Packages needed by the future expression (n = 0): <none>
[15:31:06.474] Packages needed by future strategies (n = 0): <none>
[15:31:06.475] {
[15:31:06.475]     {
[15:31:06.475]         {
[15:31:06.475]             ...future.startTime <- base::Sys.time()
[15:31:06.475]             {
[15:31:06.475]                 {
[15:31:06.475]                   {
[15:31:06.475]                     {
[15:31:06.475]                       base::local({
[15:31:06.475]                         has_future <- base::requireNamespace("future", 
[15:31:06.475]                           quietly = TRUE)
[15:31:06.475]                         if (has_future) {
[15:31:06.475]                           ns <- base::getNamespace("future")
[15:31:06.475]                           version <- ns[[".package"]][["version"]]
[15:31:06.475]                           if (is.null(version)) 
[15:31:06.475]                             version <- utils::packageVersion("future")
[15:31:06.475]                         }
[15:31:06.475]                         else {
[15:31:06.475]                           version <- NULL
[15:31:06.475]                         }
[15:31:06.475]                         if (!has_future || version < "1.8.0") {
[15:31:06.475]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:06.475]                             "", base::R.version$version.string), 
[15:31:06.475]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:06.475]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:06.475]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:06.475]                               "release", "version")], collapse = " "), 
[15:31:06.475]                             hostname = base::Sys.info()[["nodename"]])
[15:31:06.475]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:06.475]                             info)
[15:31:06.475]                           info <- base::paste(info, collapse = "; ")
[15:31:06.475]                           if (!has_future) {
[15:31:06.475]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:06.475]                               info)
[15:31:06.475]                           }
[15:31:06.475]                           else {
[15:31:06.475]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:06.475]                               info, version)
[15:31:06.475]                           }
[15:31:06.475]                           base::stop(msg)
[15:31:06.475]                         }
[15:31:06.475]                       })
[15:31:06.475]                     }
[15:31:06.475]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:06.475]                     base::options(mc.cores = 1L)
[15:31:06.475]                   }
[15:31:06.475]                   ...future.strategy.old <- future::plan("list")
[15:31:06.475]                   options(future.plan = NULL)
[15:31:06.475]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:06.475]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:06.475]                 }
[15:31:06.475]                 ...future.workdir <- getwd()
[15:31:06.475]             }
[15:31:06.475]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:06.475]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:06.475]         }
[15:31:06.475]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:06.475]             future.globals.maxSize = Inf, future.globals.method = NULL, 
[15:31:06.475]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:06.475]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:06.475]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:06.475]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:06.475]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:06.475]             base::names(...future.oldOptions))
[15:31:06.475]     }
[15:31:06.475]     if (FALSE) {
[15:31:06.475]     }
[15:31:06.475]     else {
[15:31:06.475]         if (TRUE) {
[15:31:06.475]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:06.475]                 open = "w")
[15:31:06.475]         }
[15:31:06.475]         else {
[15:31:06.475]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:06.475]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:06.475]         }
[15:31:06.475]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:06.475]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:06.475]             base::sink(type = "output", split = FALSE)
[15:31:06.475]             base::close(...future.stdout)
[15:31:06.475]         }, add = TRUE)
[15:31:06.475]     }
[15:31:06.475]     ...future.frame <- base::sys.nframe()
[15:31:06.475]     ...future.conditions <- base::list()
[15:31:06.475]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:06.475]     if (FALSE) {
[15:31:06.475]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:06.475]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:06.475]     }
[15:31:06.475]     ...future.result <- base::tryCatch({
[15:31:06.475]         base::withCallingHandlers({
[15:31:06.475]             ...future.value <- base::withVisible(base::local({
[15:31:06.475]                 ...future.makeSendCondition <- base::local({
[15:31:06.475]                   sendCondition <- NULL
[15:31:06.475]                   function(frame = 1L) {
[15:31:06.475]                     if (is.function(sendCondition)) 
[15:31:06.475]                       return(sendCondition)
[15:31:06.475]                     ns <- getNamespace("parallel")
[15:31:06.475]                     if (exists("sendData", mode = "function", 
[15:31:06.475]                       envir = ns)) {
[15:31:06.475]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:06.475]                         envir = ns)
[15:31:06.475]                       envir <- sys.frame(frame)
[15:31:06.475]                       master <- NULL
[15:31:06.475]                       while (!identical(envir, .GlobalEnv) && 
[15:31:06.475]                         !identical(envir, emptyenv())) {
[15:31:06.475]                         if (exists("master", mode = "list", envir = envir, 
[15:31:06.475]                           inherits = FALSE)) {
[15:31:06.475]                           master <- get("master", mode = "list", 
[15:31:06.475]                             envir = envir, inherits = FALSE)
[15:31:06.475]                           if (inherits(master, c("SOCKnode", 
[15:31:06.475]                             "SOCK0node"))) {
[15:31:06.475]                             sendCondition <<- function(cond) {
[15:31:06.475]                               data <- list(type = "VALUE", value = cond, 
[15:31:06.475]                                 success = TRUE)
[15:31:06.475]                               parallel_sendData(master, data)
[15:31:06.475]                             }
[15:31:06.475]                             return(sendCondition)
[15:31:06.475]                           }
[15:31:06.475]                         }
[15:31:06.475]                         frame <- frame + 1L
[15:31:06.475]                         envir <- sys.frame(frame)
[15:31:06.475]                       }
[15:31:06.475]                     }
[15:31:06.475]                     sendCondition <<- function(cond) NULL
[15:31:06.475]                   }
[15:31:06.475]                 })
[15:31:06.475]                 withCallingHandlers({
[15:31:06.475]                   {
[15:31:06.475]                     do.call(function(...) {
[15:31:06.475]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:06.475]                       if (!identical(...future.globals.maxSize.org, 
[15:31:06.475]                         ...future.globals.maxSize)) {
[15:31:06.475]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:06.475]                         on.exit(options(oopts), add = TRUE)
[15:31:06.475]                       }
[15:31:06.475]                       {
[15:31:06.475]                         lapply(seq_along(...future.elements_ii), 
[15:31:06.475]                           FUN = function(jj) {
[15:31:06.475]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:06.475]                             ...future.FUN(...future.X_jj, ...)
[15:31:06.475]                           })
[15:31:06.475]                       }
[15:31:06.475]                     }, args = future.call.arguments)
[15:31:06.475]                   }
[15:31:06.475]                 }, immediateCondition = function(cond) {
[15:31:06.475]                   sendCondition <- ...future.makeSendCondition()
[15:31:06.475]                   sendCondition(cond)
[15:31:06.475]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:06.475]                   {
[15:31:06.475]                     inherits <- base::inherits
[15:31:06.475]                     invokeRestart <- base::invokeRestart
[15:31:06.475]                     is.null <- base::is.null
[15:31:06.475]                     muffled <- FALSE
[15:31:06.475]                     if (inherits(cond, "message")) {
[15:31:06.475]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:06.475]                       if (muffled) 
[15:31:06.475]                         invokeRestart("muffleMessage")
[15:31:06.475]                     }
[15:31:06.475]                     else if (inherits(cond, "warning")) {
[15:31:06.475]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:06.475]                       if (muffled) 
[15:31:06.475]                         invokeRestart("muffleWarning")
[15:31:06.475]                     }
[15:31:06.475]                     else if (inherits(cond, "condition")) {
[15:31:06.475]                       if (!is.null(pattern)) {
[15:31:06.475]                         computeRestarts <- base::computeRestarts
[15:31:06.475]                         grepl <- base::grepl
[15:31:06.475]                         restarts <- computeRestarts(cond)
[15:31:06.475]                         for (restart in restarts) {
[15:31:06.475]                           name <- restart$name
[15:31:06.475]                           if (is.null(name)) 
[15:31:06.475]                             next
[15:31:06.475]                           if (!grepl(pattern, name)) 
[15:31:06.475]                             next
[15:31:06.475]                           invokeRestart(restart)
[15:31:06.475]                           muffled <- TRUE
[15:31:06.475]                           break
[15:31:06.475]                         }
[15:31:06.475]                       }
[15:31:06.475]                     }
[15:31:06.475]                     invisible(muffled)
[15:31:06.475]                   }
[15:31:06.475]                   muffleCondition(cond)
[15:31:06.475]                 })
[15:31:06.475]             }))
[15:31:06.475]             future::FutureResult(value = ...future.value$value, 
[15:31:06.475]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:06.475]                   ...future.rng), globalenv = if (FALSE) 
[15:31:06.475]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:06.475]                     ...future.globalenv.names))
[15:31:06.475]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:06.475]         }, condition = base::local({
[15:31:06.475]             c <- base::c
[15:31:06.475]             inherits <- base::inherits
[15:31:06.475]             invokeRestart <- base::invokeRestart
[15:31:06.475]             length <- base::length
[15:31:06.475]             list <- base::list
[15:31:06.475]             seq.int <- base::seq.int
[15:31:06.475]             signalCondition <- base::signalCondition
[15:31:06.475]             sys.calls <- base::sys.calls
[15:31:06.475]             `[[` <- base::`[[`
[15:31:06.475]             `+` <- base::`+`
[15:31:06.475]             `<<-` <- base::`<<-`
[15:31:06.475]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:06.475]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:06.475]                   3L)]
[15:31:06.475]             }
[15:31:06.475]             function(cond) {
[15:31:06.475]                 is_error <- inherits(cond, "error")
[15:31:06.475]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:06.475]                   NULL)
[15:31:06.475]                 if (is_error) {
[15:31:06.475]                   sessionInformation <- function() {
[15:31:06.475]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:06.475]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:06.475]                       search = base::search(), system = base::Sys.info())
[15:31:06.475]                   }
[15:31:06.475]                   ...future.conditions[[length(...future.conditions) + 
[15:31:06.475]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:06.475]                     cond$call), session = sessionInformation(), 
[15:31:06.475]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:06.475]                   signalCondition(cond)
[15:31:06.475]                 }
[15:31:06.475]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:06.475]                 "immediateCondition"))) {
[15:31:06.475]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:06.475]                   ...future.conditions[[length(...future.conditions) + 
[15:31:06.475]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:06.475]                   if (TRUE && !signal) {
[15:31:06.475]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:06.475]                     {
[15:31:06.475]                       inherits <- base::inherits
[15:31:06.475]                       invokeRestart <- base::invokeRestart
[15:31:06.475]                       is.null <- base::is.null
[15:31:06.475]                       muffled <- FALSE
[15:31:06.475]                       if (inherits(cond, "message")) {
[15:31:06.475]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:06.475]                         if (muffled) 
[15:31:06.475]                           invokeRestart("muffleMessage")
[15:31:06.475]                       }
[15:31:06.475]                       else if (inherits(cond, "warning")) {
[15:31:06.475]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:06.475]                         if (muffled) 
[15:31:06.475]                           invokeRestart("muffleWarning")
[15:31:06.475]                       }
[15:31:06.475]                       else if (inherits(cond, "condition")) {
[15:31:06.475]                         if (!is.null(pattern)) {
[15:31:06.475]                           computeRestarts <- base::computeRestarts
[15:31:06.475]                           grepl <- base::grepl
[15:31:06.475]                           restarts <- computeRestarts(cond)
[15:31:06.475]                           for (restart in restarts) {
[15:31:06.475]                             name <- restart$name
[15:31:06.475]                             if (is.null(name)) 
[15:31:06.475]                               next
[15:31:06.475]                             if (!grepl(pattern, name)) 
[15:31:06.475]                               next
[15:31:06.475]                             invokeRestart(restart)
[15:31:06.475]                             muffled <- TRUE
[15:31:06.475]                             break
[15:31:06.475]                           }
[15:31:06.475]                         }
[15:31:06.475]                       }
[15:31:06.475]                       invisible(muffled)
[15:31:06.475]                     }
[15:31:06.475]                     muffleCondition(cond, pattern = "^muffle")
[15:31:06.475]                   }
[15:31:06.475]                 }
[15:31:06.475]                 else {
[15:31:06.475]                   if (TRUE) {
[15:31:06.475]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:06.475]                     {
[15:31:06.475]                       inherits <- base::inherits
[15:31:06.475]                       invokeRestart <- base::invokeRestart
[15:31:06.475]                       is.null <- base::is.null
[15:31:06.475]                       muffled <- FALSE
[15:31:06.475]                       if (inherits(cond, "message")) {
[15:31:06.475]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:06.475]                         if (muffled) 
[15:31:06.475]                           invokeRestart("muffleMessage")
[15:31:06.475]                       }
[15:31:06.475]                       else if (inherits(cond, "warning")) {
[15:31:06.475]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:06.475]                         if (muffled) 
[15:31:06.475]                           invokeRestart("muffleWarning")
[15:31:06.475]                       }
[15:31:06.475]                       else if (inherits(cond, "condition")) {
[15:31:06.475]                         if (!is.null(pattern)) {
[15:31:06.475]                           computeRestarts <- base::computeRestarts
[15:31:06.475]                           grepl <- base::grepl
[15:31:06.475]                           restarts <- computeRestarts(cond)
[15:31:06.475]                           for (restart in restarts) {
[15:31:06.475]                             name <- restart$name
[15:31:06.475]                             if (is.null(name)) 
[15:31:06.475]                               next
[15:31:06.475]                             if (!grepl(pattern, name)) 
[15:31:06.475]                               next
[15:31:06.475]                             invokeRestart(restart)
[15:31:06.475]                             muffled <- TRUE
[15:31:06.475]                             break
[15:31:06.475]                           }
[15:31:06.475]                         }
[15:31:06.475]                       }
[15:31:06.475]                       invisible(muffled)
[15:31:06.475]                     }
[15:31:06.475]                     muffleCondition(cond, pattern = "^muffle")
[15:31:06.475]                   }
[15:31:06.475]                 }
[15:31:06.475]             }
[15:31:06.475]         }))
[15:31:06.475]     }, error = function(ex) {
[15:31:06.475]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:06.475]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:06.475]                 ...future.rng), started = ...future.startTime, 
[15:31:06.475]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:06.475]             version = "1.8"), class = "FutureResult")
[15:31:06.475]     }, finally = {
[15:31:06.475]         if (!identical(...future.workdir, getwd())) 
[15:31:06.475]             setwd(...future.workdir)
[15:31:06.475]         {
[15:31:06.475]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:06.475]                 ...future.oldOptions$nwarnings <- NULL
[15:31:06.475]             }
[15:31:06.475]             base::options(...future.oldOptions)
[15:31:06.475]             if (.Platform$OS.type == "windows") {
[15:31:06.475]                 old_names <- names(...future.oldEnvVars)
[15:31:06.475]                 envs <- base::Sys.getenv()
[15:31:06.475]                 names <- names(envs)
[15:31:06.475]                 common <- intersect(names, old_names)
[15:31:06.475]                 added <- setdiff(names, old_names)
[15:31:06.475]                 removed <- setdiff(old_names, names)
[15:31:06.475]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:06.475]                   envs[common]]
[15:31:06.475]                 NAMES <- toupper(changed)
[15:31:06.475]                 args <- list()
[15:31:06.475]                 for (kk in seq_along(NAMES)) {
[15:31:06.475]                   name <- changed[[kk]]
[15:31:06.475]                   NAME <- NAMES[[kk]]
[15:31:06.475]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:06.475]                     next
[15:31:06.475]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:06.475]                 }
[15:31:06.475]                 NAMES <- toupper(added)
[15:31:06.475]                 for (kk in seq_along(NAMES)) {
[15:31:06.475]                   name <- added[[kk]]
[15:31:06.475]                   NAME <- NAMES[[kk]]
[15:31:06.475]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:06.475]                     next
[15:31:06.475]                   args[[name]] <- ""
[15:31:06.475]                 }
[15:31:06.475]                 NAMES <- toupper(removed)
[15:31:06.475]                 for (kk in seq_along(NAMES)) {
[15:31:06.475]                   name <- removed[[kk]]
[15:31:06.475]                   NAME <- NAMES[[kk]]
[15:31:06.475]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:06.475]                     next
[15:31:06.475]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:06.475]                 }
[15:31:06.475]                 if (length(args) > 0) 
[15:31:06.475]                   base::do.call(base::Sys.setenv, args = args)
[15:31:06.475]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:06.475]             }
[15:31:06.475]             else {
[15:31:06.475]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:06.475]             }
[15:31:06.475]             {
[15:31:06.475]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:06.475]                   0L) {
[15:31:06.475]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:06.475]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:06.475]                   base::options(opts)
[15:31:06.475]                 }
[15:31:06.475]                 {
[15:31:06.475]                   {
[15:31:06.475]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:06.475]                     NULL
[15:31:06.475]                   }
[15:31:06.475]                   options(future.plan = NULL)
[15:31:06.475]                   if (is.na(NA_character_)) 
[15:31:06.475]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:06.475]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:06.475]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:06.475]                     .init = FALSE)
[15:31:06.475]                 }
[15:31:06.475]             }
[15:31:06.475]         }
[15:31:06.475]     })
[15:31:06.475]     if (TRUE) {
[15:31:06.475]         base::sink(type = "output", split = FALSE)
[15:31:06.475]         if (TRUE) {
[15:31:06.475]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:06.475]         }
[15:31:06.475]         else {
[15:31:06.475]             ...future.result["stdout"] <- base::list(NULL)
[15:31:06.475]         }
[15:31:06.475]         base::close(...future.stdout)
[15:31:06.475]         ...future.stdout <- NULL
[15:31:06.475]     }
[15:31:06.475]     ...future.result$conditions <- ...future.conditions
[15:31:06.475]     ...future.result$finished <- base::Sys.time()
[15:31:06.475]     ...future.result
[15:31:06.475] }
[15:31:06.484] Exporting 5 global objects (346.05 KiB) to cluster node #1 ...
[15:31:06.484] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:31:06.485] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:31:06.485] Exporting '...future.FUN' (345.92 KiB) to cluster node #1 ...
[15:31:06.486] Exporting '...future.FUN' (345.92 KiB) to cluster node #1 ... DONE
[15:31:06.486] Exporting '...future.elements_ii' (80 bytes) to cluster node #1 ...
[15:31:06.487] Exporting '...future.elements_ii' (80 bytes) to cluster node #1 ... DONE
[15:31:06.487] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:31:06.487] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:31:06.488] Exporting '...future.globals.maxSize' (56 bytes) to cluster node #1 ...
[15:31:06.488] Exporting '...future.globals.maxSize' (56 bytes) to cluster node #1 ... DONE
[15:31:06.489] Exporting 5 global objects (346.05 KiB) to cluster node #1 ... DONE
[15:31:06.490] MultisessionFuture started
[15:31:06.490] - Launch lazy future ... done
[15:31:06.490] run() for 'MultisessionFuture' ... done
[15:31:06.491] Created future:
[15:31:06.516] receiveMessageFromWorker() for ClusterFuture ...
[15:31:06.517] - Validating connection of MultisessionFuture
[15:31:06.517] - received message: FutureResult
[15:31:06.518] - Received FutureResult
[15:31:06.518] - Erased future from FutureRegistry
[15:31:06.518] result() for ClusterFuture ...
[15:31:06.519] - result already collected: FutureResult
[15:31:06.519] result() for ClusterFuture ... done
[15:31:06.519] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:06.491] MultisessionFuture:
[15:31:06.491] Label: 'future_apply-1'
[15:31:06.491] Expression:
[15:31:06.491] {
[15:31:06.491]     do.call(function(...) {
[15:31:06.491]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:06.491]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:06.491]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:06.491]             on.exit(options(oopts), add = TRUE)
[15:31:06.491]         }
[15:31:06.491]         {
[15:31:06.491]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:06.491]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:06.491]                 ...future.FUN(...future.X_jj, ...)
[15:31:06.491]             })
[15:31:06.491]         }
[15:31:06.491]     }, args = future.call.arguments)
[15:31:06.491] }
[15:31:06.491] Lazy evaluation: FALSE
[15:31:06.491] Asynchronous evaluation: TRUE
[15:31:06.491] Local evaluation: TRUE
[15:31:06.491] Environment: R_GlobalEnv
[15:31:06.491] Capture standard output: TRUE
[15:31:06.491] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:06.491] Globals: 5 objects totaling 346.05 KiB (DotDotDotList 'future.call.arguments' of 0 bytes, function '...future.FUN' of 345.92 KiB, list '...future.elements_ii' of 80 bytes, NULL '...future.seeds_ii' of 0 bytes, numeric '...future.globals.maxSize' of 56 bytes)
[15:31:06.491] Packages: <none>
[15:31:06.491] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:06.491] Resolved: TRUE
[15:31:06.491] Value: <not collected>
[15:31:06.491] Conditions captured: <none>
[15:31:06.491] Early signaling: FALSE
[15:31:06.491] Owner process: 6672a580-6d3c-e82f-380e-108c475ace70
[15:31:06.491] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:06.520] Chunk #1 of 2 ... DONE
[15:31:06.520] Chunk #2 of 2 ...
[15:31:06.521]  - Adjusted option 'future.globals.maxSize': Inf -> 2 * Inf = Inf (bytes)
[15:31:06.521]  - seeds: <none>
[15:31:06.521]  - All globals exported: [n=5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:06.522] getGlobalsAndPackages() ...
[15:31:06.522] - globals passed as-is: [5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:06.522] Resolving globals: FALSE
[15:31:06.523] Tweak future expression to call with '...' arguments ...
[15:31:06.523] {
[15:31:06.523]     do.call(function(...) {
[15:31:06.523]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:06.523]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:06.523]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:06.523]             on.exit(options(oopts), add = TRUE)
[15:31:06.523]         }
[15:31:06.523]         {
[15:31:06.523]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:06.523]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:06.523]                 ...future.FUN(...future.X_jj, ...)
[15:31:06.523]             })
[15:31:06.523]         }
[15:31:06.523]     }, args = future.call.arguments)
[15:31:06.523] }
[15:31:06.524] Tweak future expression to call with '...' arguments ... DONE
[15:31:06.525] - globals: [5] 'future.call.arguments', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:06.526] 
[15:31:06.526] getGlobalsAndPackages() ... DONE
[15:31:06.527] run() for 'Future' ...
[15:31:06.527] - state: 'created'
[15:31:06.527] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:06.545] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:06.548] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:31:06.549]   - Field: 'node'
[15:31:06.549]   - Field: 'label'
[15:31:06.549]   - Field: 'local'
[15:31:06.550]   - Field: 'owner'
[15:31:06.550]   - Field: 'envir'
[15:31:06.551]   - Field: 'workers'
[15:31:06.551]   - Field: 'packages'
[15:31:06.551]   - Field: 'gc'
[15:31:06.552]   - Field: 'conditions'
[15:31:06.552]   - Field: 'persistent'
[15:31:06.552]   - Field: 'expr'
[15:31:06.553]   - Field: 'uuid'
[15:31:06.553]   - Field: 'seed'
[15:31:06.553]   - Field: 'version'
[15:31:06.553]   - Field: 'result'
[15:31:06.554]   - Field: 'asynchronous'
[15:31:06.554]   - Field: 'calls'
[15:31:06.554]   - Field: 'globals'
[15:31:06.555]   - Field: 'stdout'
[15:31:06.555]   - Field: 'earlySignal'
[15:31:06.555]   - Field: 'lazy'
[15:31:06.555]   - Field: 'state'
[15:31:06.556] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:31:06.556] - Launch lazy future ...
[15:31:06.557] Packages needed by the future expression (n = 0): <none>
[15:31:06.557] Packages needed by future strategies (n = 0): <none>
[15:31:06.558] {
[15:31:06.558]     {
[15:31:06.558]         {
[15:31:06.558]             ...future.startTime <- base::Sys.time()
[15:31:06.558]             {
[15:31:06.558]                 {
[15:31:06.558]                   {
[15:31:06.558]                     {
[15:31:06.558]                       base::local({
[15:31:06.558]                         has_future <- base::requireNamespace("future", 
[15:31:06.558]                           quietly = TRUE)
[15:31:06.558]                         if (has_future) {
[15:31:06.558]                           ns <- base::getNamespace("future")
[15:31:06.558]                           version <- ns[[".package"]][["version"]]
[15:31:06.558]                           if (is.null(version)) 
[15:31:06.558]                             version <- utils::packageVersion("future")
[15:31:06.558]                         }
[15:31:06.558]                         else {
[15:31:06.558]                           version <- NULL
[15:31:06.558]                         }
[15:31:06.558]                         if (!has_future || version < "1.8.0") {
[15:31:06.558]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:06.558]                             "", base::R.version$version.string), 
[15:31:06.558]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:06.558]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:06.558]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:06.558]                               "release", "version")], collapse = " "), 
[15:31:06.558]                             hostname = base::Sys.info()[["nodename"]])
[15:31:06.558]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:06.558]                             info)
[15:31:06.558]                           info <- base::paste(info, collapse = "; ")
[15:31:06.558]                           if (!has_future) {
[15:31:06.558]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:06.558]                               info)
[15:31:06.558]                           }
[15:31:06.558]                           else {
[15:31:06.558]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:06.558]                               info, version)
[15:31:06.558]                           }
[15:31:06.558]                           base::stop(msg)
[15:31:06.558]                         }
[15:31:06.558]                       })
[15:31:06.558]                     }
[15:31:06.558]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:06.558]                     base::options(mc.cores = 1L)
[15:31:06.558]                   }
[15:31:06.558]                   ...future.strategy.old <- future::plan("list")
[15:31:06.558]                   options(future.plan = NULL)
[15:31:06.558]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:06.558]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:06.558]                 }
[15:31:06.558]                 ...future.workdir <- getwd()
[15:31:06.558]             }
[15:31:06.558]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:06.558]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:06.558]         }
[15:31:06.558]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:06.558]             future.globals.maxSize = Inf, future.globals.method = NULL, 
[15:31:06.558]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:06.558]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:06.558]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:06.558]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:06.558]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:06.558]             base::names(...future.oldOptions))
[15:31:06.558]     }
[15:31:06.558]     if (FALSE) {
[15:31:06.558]     }
[15:31:06.558]     else {
[15:31:06.558]         if (TRUE) {
[15:31:06.558]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:06.558]                 open = "w")
[15:31:06.558]         }
[15:31:06.558]         else {
[15:31:06.558]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:06.558]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:06.558]         }
[15:31:06.558]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:06.558]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:06.558]             base::sink(type = "output", split = FALSE)
[15:31:06.558]             base::close(...future.stdout)
[15:31:06.558]         }, add = TRUE)
[15:31:06.558]     }
[15:31:06.558]     ...future.frame <- base::sys.nframe()
[15:31:06.558]     ...future.conditions <- base::list()
[15:31:06.558]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:06.558]     if (FALSE) {
[15:31:06.558]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:06.558]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:06.558]     }
[15:31:06.558]     ...future.result <- base::tryCatch({
[15:31:06.558]         base::withCallingHandlers({
[15:31:06.558]             ...future.value <- base::withVisible(base::local({
[15:31:06.558]                 ...future.makeSendCondition <- base::local({
[15:31:06.558]                   sendCondition <- NULL
[15:31:06.558]                   function(frame = 1L) {
[15:31:06.558]                     if (is.function(sendCondition)) 
[15:31:06.558]                       return(sendCondition)
[15:31:06.558]                     ns <- getNamespace("parallel")
[15:31:06.558]                     if (exists("sendData", mode = "function", 
[15:31:06.558]                       envir = ns)) {
[15:31:06.558]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:06.558]                         envir = ns)
[15:31:06.558]                       envir <- sys.frame(frame)
[15:31:06.558]                       master <- NULL
[15:31:06.558]                       while (!identical(envir, .GlobalEnv) && 
[15:31:06.558]                         !identical(envir, emptyenv())) {
[15:31:06.558]                         if (exists("master", mode = "list", envir = envir, 
[15:31:06.558]                           inherits = FALSE)) {
[15:31:06.558]                           master <- get("master", mode = "list", 
[15:31:06.558]                             envir = envir, inherits = FALSE)
[15:31:06.558]                           if (inherits(master, c("SOCKnode", 
[15:31:06.558]                             "SOCK0node"))) {
[15:31:06.558]                             sendCondition <<- function(cond) {
[15:31:06.558]                               data <- list(type = "VALUE", value = cond, 
[15:31:06.558]                                 success = TRUE)
[15:31:06.558]                               parallel_sendData(master, data)
[15:31:06.558]                             }
[15:31:06.558]                             return(sendCondition)
[15:31:06.558]                           }
[15:31:06.558]                         }
[15:31:06.558]                         frame <- frame + 1L
[15:31:06.558]                         envir <- sys.frame(frame)
[15:31:06.558]                       }
[15:31:06.558]                     }
[15:31:06.558]                     sendCondition <<- function(cond) NULL
[15:31:06.558]                   }
[15:31:06.558]                 })
[15:31:06.558]                 withCallingHandlers({
[15:31:06.558]                   {
[15:31:06.558]                     do.call(function(...) {
[15:31:06.558]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:06.558]                       if (!identical(...future.globals.maxSize.org, 
[15:31:06.558]                         ...future.globals.maxSize)) {
[15:31:06.558]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:06.558]                         on.exit(options(oopts), add = TRUE)
[15:31:06.558]                       }
[15:31:06.558]                       {
[15:31:06.558]                         lapply(seq_along(...future.elements_ii), 
[15:31:06.558]                           FUN = function(jj) {
[15:31:06.558]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:06.558]                             ...future.FUN(...future.X_jj, ...)
[15:31:06.558]                           })
[15:31:06.558]                       }
[15:31:06.558]                     }, args = future.call.arguments)
[15:31:06.558]                   }
[15:31:06.558]                 }, immediateCondition = function(cond) {
[15:31:06.558]                   sendCondition <- ...future.makeSendCondition()
[15:31:06.558]                   sendCondition(cond)
[15:31:06.558]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:06.558]                   {
[15:31:06.558]                     inherits <- base::inherits
[15:31:06.558]                     invokeRestart <- base::invokeRestart
[15:31:06.558]                     is.null <- base::is.null
[15:31:06.558]                     muffled <- FALSE
[15:31:06.558]                     if (inherits(cond, "message")) {
[15:31:06.558]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:06.558]                       if (muffled) 
[15:31:06.558]                         invokeRestart("muffleMessage")
[15:31:06.558]                     }
[15:31:06.558]                     else if (inherits(cond, "warning")) {
[15:31:06.558]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:06.558]                       if (muffled) 
[15:31:06.558]                         invokeRestart("muffleWarning")
[15:31:06.558]                     }
[15:31:06.558]                     else if (inherits(cond, "condition")) {
[15:31:06.558]                       if (!is.null(pattern)) {
[15:31:06.558]                         computeRestarts <- base::computeRestarts
[15:31:06.558]                         grepl <- base::grepl
[15:31:06.558]                         restarts <- computeRestarts(cond)
[15:31:06.558]                         for (restart in restarts) {
[15:31:06.558]                           name <- restart$name
[15:31:06.558]                           if (is.null(name)) 
[15:31:06.558]                             next
[15:31:06.558]                           if (!grepl(pattern, name)) 
[15:31:06.558]                             next
[15:31:06.558]                           invokeRestart(restart)
[15:31:06.558]                           muffled <- TRUE
[15:31:06.558]                           break
[15:31:06.558]                         }
[15:31:06.558]                       }
[15:31:06.558]                     }
[15:31:06.558]                     invisible(muffled)
[15:31:06.558]                   }
[15:31:06.558]                   muffleCondition(cond)
[15:31:06.558]                 })
[15:31:06.558]             }))
[15:31:06.558]             future::FutureResult(value = ...future.value$value, 
[15:31:06.558]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:06.558]                   ...future.rng), globalenv = if (FALSE) 
[15:31:06.558]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:06.558]                     ...future.globalenv.names))
[15:31:06.558]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:06.558]         }, condition = base::local({
[15:31:06.558]             c <- base::c
[15:31:06.558]             inherits <- base::inherits
[15:31:06.558]             invokeRestart <- base::invokeRestart
[15:31:06.558]             length <- base::length
[15:31:06.558]             list <- base::list
[15:31:06.558]             seq.int <- base::seq.int
[15:31:06.558]             signalCondition <- base::signalCondition
[15:31:06.558]             sys.calls <- base::sys.calls
[15:31:06.558]             `[[` <- base::`[[`
[15:31:06.558]             `+` <- base::`+`
[15:31:06.558]             `<<-` <- base::`<<-`
[15:31:06.558]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:06.558]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:06.558]                   3L)]
[15:31:06.558]             }
[15:31:06.558]             function(cond) {
[15:31:06.558]                 is_error <- inherits(cond, "error")
[15:31:06.558]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:06.558]                   NULL)
[15:31:06.558]                 if (is_error) {
[15:31:06.558]                   sessionInformation <- function() {
[15:31:06.558]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:06.558]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:06.558]                       search = base::search(), system = base::Sys.info())
[15:31:06.558]                   }
[15:31:06.558]                   ...future.conditions[[length(...future.conditions) + 
[15:31:06.558]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:06.558]                     cond$call), session = sessionInformation(), 
[15:31:06.558]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:06.558]                   signalCondition(cond)
[15:31:06.558]                 }
[15:31:06.558]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:06.558]                 "immediateCondition"))) {
[15:31:06.558]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:06.558]                   ...future.conditions[[length(...future.conditions) + 
[15:31:06.558]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:06.558]                   if (TRUE && !signal) {
[15:31:06.558]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:06.558]                     {
[15:31:06.558]                       inherits <- base::inherits
[15:31:06.558]                       invokeRestart <- base::invokeRestart
[15:31:06.558]                       is.null <- base::is.null
[15:31:06.558]                       muffled <- FALSE
[15:31:06.558]                       if (inherits(cond, "message")) {
[15:31:06.558]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:06.558]                         if (muffled) 
[15:31:06.558]                           invokeRestart("muffleMessage")
[15:31:06.558]                       }
[15:31:06.558]                       else if (inherits(cond, "warning")) {
[15:31:06.558]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:06.558]                         if (muffled) 
[15:31:06.558]                           invokeRestart("muffleWarning")
[15:31:06.558]                       }
[15:31:06.558]                       else if (inherits(cond, "condition")) {
[15:31:06.558]                         if (!is.null(pattern)) {
[15:31:06.558]                           computeRestarts <- base::computeRestarts
[15:31:06.558]                           grepl <- base::grepl
[15:31:06.558]                           restarts <- computeRestarts(cond)
[15:31:06.558]                           for (restart in restarts) {
[15:31:06.558]                             name <- restart$name
[15:31:06.558]                             if (is.null(name)) 
[15:31:06.558]                               next
[15:31:06.558]                             if (!grepl(pattern, name)) 
[15:31:06.558]                               next
[15:31:06.558]                             invokeRestart(restart)
[15:31:06.558]                             muffled <- TRUE
[15:31:06.558]                             break
[15:31:06.558]                           }
[15:31:06.558]                         }
[15:31:06.558]                       }
[15:31:06.558]                       invisible(muffled)
[15:31:06.558]                     }
[15:31:06.558]                     muffleCondition(cond, pattern = "^muffle")
[15:31:06.558]                   }
[15:31:06.558]                 }
[15:31:06.558]                 else {
[15:31:06.558]                   if (TRUE) {
[15:31:06.558]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:06.558]                     {
[15:31:06.558]                       inherits <- base::inherits
[15:31:06.558]                       invokeRestart <- base::invokeRestart
[15:31:06.558]                       is.null <- base::is.null
[15:31:06.558]                       muffled <- FALSE
[15:31:06.558]                       if (inherits(cond, "message")) {
[15:31:06.558]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:06.558]                         if (muffled) 
[15:31:06.558]                           invokeRestart("muffleMessage")
[15:31:06.558]                       }
[15:31:06.558]                       else if (inherits(cond, "warning")) {
[15:31:06.558]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:06.558]                         if (muffled) 
[15:31:06.558]                           invokeRestart("muffleWarning")
[15:31:06.558]                       }
[15:31:06.558]                       else if (inherits(cond, "condition")) {
[15:31:06.558]                         if (!is.null(pattern)) {
[15:31:06.558]                           computeRestarts <- base::computeRestarts
[15:31:06.558]                           grepl <- base::grepl
[15:31:06.558]                           restarts <- computeRestarts(cond)
[15:31:06.558]                           for (restart in restarts) {
[15:31:06.558]                             name <- restart$name
[15:31:06.558]                             if (is.null(name)) 
[15:31:06.558]                               next
[15:31:06.558]                             if (!grepl(pattern, name)) 
[15:31:06.558]                               next
[15:31:06.558]                             invokeRestart(restart)
[15:31:06.558]                             muffled <- TRUE
[15:31:06.558]                             break
[15:31:06.558]                           }
[15:31:06.558]                         }
[15:31:06.558]                       }
[15:31:06.558]                       invisible(muffled)
[15:31:06.558]                     }
[15:31:06.558]                     muffleCondition(cond, pattern = "^muffle")
[15:31:06.558]                   }
[15:31:06.558]                 }
[15:31:06.558]             }
[15:31:06.558]         }))
[15:31:06.558]     }, error = function(ex) {
[15:31:06.558]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:06.558]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:06.558]                 ...future.rng), started = ...future.startTime, 
[15:31:06.558]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:06.558]             version = "1.8"), class = "FutureResult")
[15:31:06.558]     }, finally = {
[15:31:06.558]         if (!identical(...future.workdir, getwd())) 
[15:31:06.558]             setwd(...future.workdir)
[15:31:06.558]         {
[15:31:06.558]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:06.558]                 ...future.oldOptions$nwarnings <- NULL
[15:31:06.558]             }
[15:31:06.558]             base::options(...future.oldOptions)
[15:31:06.558]             if (.Platform$OS.type == "windows") {
[15:31:06.558]                 old_names <- names(...future.oldEnvVars)
[15:31:06.558]                 envs <- base::Sys.getenv()
[15:31:06.558]                 names <- names(envs)
[15:31:06.558]                 common <- intersect(names, old_names)
[15:31:06.558]                 added <- setdiff(names, old_names)
[15:31:06.558]                 removed <- setdiff(old_names, names)
[15:31:06.558]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:06.558]                   envs[common]]
[15:31:06.558]                 NAMES <- toupper(changed)
[15:31:06.558]                 args <- list()
[15:31:06.558]                 for (kk in seq_along(NAMES)) {
[15:31:06.558]                   name <- changed[[kk]]
[15:31:06.558]                   NAME <- NAMES[[kk]]
[15:31:06.558]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:06.558]                     next
[15:31:06.558]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:06.558]                 }
[15:31:06.558]                 NAMES <- toupper(added)
[15:31:06.558]                 for (kk in seq_along(NAMES)) {
[15:31:06.558]                   name <- added[[kk]]
[15:31:06.558]                   NAME <- NAMES[[kk]]
[15:31:06.558]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:06.558]                     next
[15:31:06.558]                   args[[name]] <- ""
[15:31:06.558]                 }
[15:31:06.558]                 NAMES <- toupper(removed)
[15:31:06.558]                 for (kk in seq_along(NAMES)) {
[15:31:06.558]                   name <- removed[[kk]]
[15:31:06.558]                   NAME <- NAMES[[kk]]
[15:31:06.558]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:06.558]                     next
[15:31:06.558]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:06.558]                 }
[15:31:06.558]                 if (length(args) > 0) 
[15:31:06.558]                   base::do.call(base::Sys.setenv, args = args)
[15:31:06.558]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:06.558]             }
[15:31:06.558]             else {
[15:31:06.558]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:06.558]             }
[15:31:06.558]             {
[15:31:06.558]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:06.558]                   0L) {
[15:31:06.558]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:06.558]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:06.558]                   base::options(opts)
[15:31:06.558]                 }
[15:31:06.558]                 {
[15:31:06.558]                   {
[15:31:06.558]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:06.558]                     NULL
[15:31:06.558]                   }
[15:31:06.558]                   options(future.plan = NULL)
[15:31:06.558]                   if (is.na(NA_character_)) 
[15:31:06.558]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:06.558]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:06.558]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:06.558]                     .init = FALSE)
[15:31:06.558]                 }
[15:31:06.558]             }
[15:31:06.558]         }
[15:31:06.558]     })
[15:31:06.558]     if (TRUE) {
[15:31:06.558]         base::sink(type = "output", split = FALSE)
[15:31:06.558]         if (TRUE) {
[15:31:06.558]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:06.558]         }
[15:31:06.558]         else {
[15:31:06.558]             ...future.result["stdout"] <- base::list(NULL)
[15:31:06.558]         }
[15:31:06.558]         base::close(...future.stdout)
[15:31:06.558]         ...future.stdout <- NULL
[15:31:06.558]     }
[15:31:06.558]     ...future.result$conditions <- ...future.conditions
[15:31:06.558]     ...future.result$finished <- base::Sys.time()
[15:31:06.558]     ...future.result
[15:31:06.558] }
[15:31:06.565] Exporting 5 global objects (346.05 KiB) to cluster node #1 ...
[15:31:06.565] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:31:06.566] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:31:06.566] Exporting '...future.FUN' (345.92 KiB) to cluster node #1 ...
[15:31:06.568] Exporting '...future.FUN' (345.92 KiB) to cluster node #1 ... DONE
[15:31:06.568] Exporting '...future.elements_ii' (80 bytes) to cluster node #1 ...
[15:31:06.569] Exporting '...future.elements_ii' (80 bytes) to cluster node #1 ... DONE
[15:31:06.569] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:31:06.570] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:31:06.570] Exporting '...future.globals.maxSize' (56 bytes) to cluster node #1 ...
[15:31:06.571] Exporting '...future.globals.maxSize' (56 bytes) to cluster node #1 ... DONE
[15:31:06.571] Exporting 5 global objects (346.05 KiB) to cluster node #1 ... DONE
[15:31:06.572] MultisessionFuture started
[15:31:06.572] - Launch lazy future ... done
[15:31:06.572] run() for 'MultisessionFuture' ... done
[15:31:06.572] Created future:
[15:31:06.593] receiveMessageFromWorker() for ClusterFuture ...
[15:31:06.593] - Validating connection of MultisessionFuture
[15:31:06.594] - received message: FutureResult
[15:31:06.594] - Received FutureResult
[15:31:06.594] - Erased future from FutureRegistry
[15:31:06.595] result() for ClusterFuture ...
[15:31:06.595] - result already collected: FutureResult
[15:31:06.595] result() for ClusterFuture ... done
[15:31:06.595] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:06.572] MultisessionFuture:
[15:31:06.572] Label: 'future_apply-2'
[15:31:06.572] Expression:
[15:31:06.572] {
[15:31:06.572]     do.call(function(...) {
[15:31:06.572]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:06.572]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:06.572]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:06.572]             on.exit(options(oopts), add = TRUE)
[15:31:06.572]         }
[15:31:06.572]         {
[15:31:06.572]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:06.572]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:06.572]                 ...future.FUN(...future.X_jj, ...)
[15:31:06.572]             })
[15:31:06.572]         }
[15:31:06.572]     }, args = future.call.arguments)
[15:31:06.572] }
[15:31:06.572] Lazy evaluation: FALSE
[15:31:06.572] Asynchronous evaluation: TRUE
[15:31:06.572] Local evaluation: TRUE
[15:31:06.572] Environment: R_GlobalEnv
[15:31:06.572] Capture standard output: TRUE
[15:31:06.572] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:06.572] Globals: 5 objects totaling 346.05 KiB (DotDotDotList 'future.call.arguments' of 0 bytes, function '...future.FUN' of 345.92 KiB, list '...future.elements_ii' of 80 bytes, NULL '...future.seeds_ii' of 0 bytes, numeric '...future.globals.maxSize' of 56 bytes)
[15:31:06.572] Packages: <none>
[15:31:06.572] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:06.572] Resolved: TRUE
[15:31:06.572] Value: <not collected>
[15:31:06.572] Conditions captured: <none>
[15:31:06.572] Early signaling: FALSE
[15:31:06.572] Owner process: 6672a580-6d3c-e82f-380e-108c475ace70
[15:31:06.572] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:06.596] Chunk #2 of 2 ... DONE
[15:31:06.596] Launching 2 futures (chunks) ... DONE
[15:31:06.596] Resolving 2 futures (chunks) ...
[15:31:06.596] resolve() on list ...
[15:31:06.597]  recursive: 0
[15:31:06.597]  length: 2
[15:31:06.597] 
[15:31:06.597] Future #1
[15:31:06.597] result() for ClusterFuture ...
[15:31:06.598] - result already collected: FutureResult
[15:31:06.598] result() for ClusterFuture ... done
[15:31:06.598] result() for ClusterFuture ...
[15:31:06.598] - result already collected: FutureResult
[15:31:06.598] result() for ClusterFuture ... done
[15:31:06.599] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:31:06.599] - nx: 2
[15:31:06.599] - relay: TRUE
[15:31:06.599] - stdout: TRUE
[15:31:06.599] - signal: TRUE
[15:31:06.600] - resignal: FALSE
[15:31:06.600] - force: TRUE
[15:31:06.600] - relayed: [n=2] FALSE, FALSE
[15:31:06.600] - queued futures: [n=2] FALSE, FALSE
[15:31:06.600]  - until=1
[15:31:06.600]  - relaying element #1
[15:31:06.601] result() for ClusterFuture ...
[15:31:06.601] - result already collected: FutureResult
[15:31:06.601] result() for ClusterFuture ... done
[15:31:06.601] result() for ClusterFuture ...
[15:31:06.601] - result already collected: FutureResult
[15:31:06.602] result() for ClusterFuture ... done
[15:31:06.602] result() for ClusterFuture ...
[15:31:06.602] - result already collected: FutureResult
[15:31:06.602] result() for ClusterFuture ... done
[15:31:06.602] result() for ClusterFuture ...
[15:31:06.603] - result already collected: FutureResult
[15:31:06.603] result() for ClusterFuture ... done
[15:31:06.603] - relayed: [n=2] TRUE, FALSE
[15:31:06.603] - queued futures: [n=2] TRUE, FALSE
[15:31:06.603] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:31:06.604]  length: 1 (resolved future 1)
[15:31:06.604] Future #2
[15:31:06.604] result() for ClusterFuture ...
[15:31:06.604] - result already collected: FutureResult
[15:31:06.604] result() for ClusterFuture ... done
[15:31:06.605] result() for ClusterFuture ...
[15:31:06.605] - result already collected: FutureResult
[15:31:06.605] result() for ClusterFuture ... done
[15:31:06.605] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:31:06.605] - nx: 2
[15:31:06.606] - relay: TRUE
[15:31:06.606] - stdout: TRUE
[15:31:06.606] - signal: TRUE
[15:31:06.607] - resignal: FALSE
[15:31:06.607] - force: TRUE
[15:31:06.607] - relayed: [n=2] TRUE, FALSE
[15:31:06.607] - queued futures: [n=2] TRUE, FALSE
[15:31:06.608]  - until=2
[15:31:06.608]  - relaying element #2
[15:31:06.609] result() for ClusterFuture ...
[15:31:06.609] - result already collected: FutureResult
[15:31:06.609] result() for ClusterFuture ... done
[15:31:06.609] result() for ClusterFuture ...
[15:31:06.610] - result already collected: FutureResult
[15:31:06.610] result() for ClusterFuture ... done
[15:31:06.610] result() for ClusterFuture ...
[15:31:06.610] - result already collected: FutureResult
[15:31:06.610] result() for ClusterFuture ... done
[15:31:06.611] result() for ClusterFuture ...
[15:31:06.611] - result already collected: FutureResult
[15:31:06.611] result() for ClusterFuture ... done
[15:31:06.611] - relayed: [n=2] TRUE, TRUE
[15:31:06.611] - queued futures: [n=2] TRUE, TRUE
[15:31:06.612] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:31:06.612]  length: 0 (resolved future 2)
[15:31:06.612] Relaying remaining futures
[15:31:06.612] signalConditionsASAP(NULL, pos=0) ...
[15:31:06.613] - nx: 2
[15:31:06.613] - relay: TRUE
[15:31:06.613] - stdout: TRUE
[15:31:06.613] - signal: TRUE
[15:31:06.614] - resignal: FALSE
[15:31:06.614] - force: TRUE
[15:31:06.614] - relayed: [n=2] TRUE, TRUE
[15:31:06.614] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:31:06.615] - relayed: [n=2] TRUE, TRUE
[15:31:06.615] - queued futures: [n=2] TRUE, TRUE
[15:31:06.615] signalConditionsASAP(NULL, pos=0) ... done
[15:31:06.615] resolve() on list ... DONE
[15:31:06.615] result() for ClusterFuture ...
[15:31:06.615] - result already collected: FutureResult
[15:31:06.616] result() for ClusterFuture ... done
[15:31:06.616] result() for ClusterFuture ...
[15:31:06.616] - result already collected: FutureResult
[15:31:06.616] result() for ClusterFuture ... done
[15:31:06.616] result() for ClusterFuture ...
[15:31:06.616] - result already collected: FutureResult
[15:31:06.617] result() for ClusterFuture ... done
[15:31:06.617] result() for ClusterFuture ...
[15:31:06.617] - result already collected: FutureResult
[15:31:06.617] result() for ClusterFuture ... done
[15:31:06.618]  - Number of value chunks collected: 2
[15:31:06.618] Resolving 2 futures (chunks) ... DONE
[15:31:06.618] Reducing values from 2 chunks ...
[15:31:06.619]  - Number of values collected after concatenation: 2
[15:31:06.619]  - Number of values expected: 2
[15:31:06.619] Reducing values from 2 chunks ... DONE
[15:31:06.619] future_lapply() ... DONE
[[1]]
...future.X_jj
1 3 7 
2 1 1 

[[2]]
...future.X_jj
2 4 6 8 
1 1 1 1 

[15:31:06.620] getGlobalsAndPackagesXApply() ...
[15:31:06.621]  - future.globals: TRUE
[15:31:06.621] getGlobalsAndPackages() ...
[15:31:06.621] Searching for globals...
[15:31:06.701] - globals found: [59] 'FUN', 'if', '==', 'c', 'list.names', '{', '<-', '[', 'as.list', 'substitute', '-', '&&', 'length', 'is.list', '!', 'is.null', 'names', 'return', 'seq_along', 'vapply', 'switch', '+', 'is.symbol', 'as.character', 'deparse', '[<-', 'missing', 'match', 'match.arg', '!=', 'warning', 'list', '[[', 'paste', 'stop', 'integer', 'for', 'is.factor', 'anyNA', 'options', 'on.exit', 'factor', '(', '||', 'levels', 'as.integer', 'which', 'is.na', 'is.na<-', '>', 'prod', '$', '.Machine', '*', 'names<-', 'array', 'tabulate', 'class', 'class<-'
[15:31:06.702] Searching for globals ... DONE
[15:31:06.702] Resolving globals: FALSE
[15:31:06.706] The total size of the 1 globals is 345.92 KiB (354224 bytes)
[15:31:06.707] The total size of the 1 globals exported for future expression ('FUN(X = structure(c(1, 2, 3, 4, 1, 6, 7, 8), dim = c(2L, 4L)))') is 345.92 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (345.92 KiB of class 'function')
[15:31:06.707] - globals: [1] 'FUN'
[15:31:06.707] 
[15:31:06.707] getGlobalsAndPackages() ... DONE
[15:31:06.708]  - globals found/used: [n=1] 'FUN'
[15:31:06.708]  - needed namespaces: [n=0] 
[15:31:06.708] Finding globals ... DONE
[15:31:06.709]  - use_args: TRUE
[15:31:06.709]  - Getting '...' globals ...
[15:31:06.710] resolve() on list ...
[15:31:06.710]  recursive: 0
[15:31:06.710]  length: 1
[15:31:06.710]  elements: '...'
[15:31:06.711]  length: 0 (resolved future 1)
[15:31:06.711] resolve() on list ... DONE
[15:31:06.711]    - '...' content: [n=0] 
[15:31:06.712] List of 1
[15:31:06.712]  $ ...: list()
[15:31:06.712]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:06.712]  - attr(*, "where")=List of 1
[15:31:06.712]   ..$ ...:<environment: 0x000001bcb7f058e8> 
[15:31:06.712]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:06.712]  - attr(*, "resolved")= logi TRUE
[15:31:06.712]  - attr(*, "total_size")= num NA
[15:31:06.716]  - Getting '...' globals ... DONE
[15:31:06.716] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:06.717] List of 2
[15:31:06.717]  $ ...future.FUN:function (..., exclude = if (useNA == "no") c(NA, NaN), useNA = c("no", 
[15:31:06.717]     "ifany", "always"), dnn = list.names(...), deparse.level = 1)  
[15:31:06.717]  $ ...          : list()
[15:31:06.717]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:06.717]  - attr(*, "where")=List of 2
[15:31:06.717]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:06.717]   ..$ ...          :<environment: 0x000001bcb7f058e8> 
[15:31:06.717]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:06.717]  - attr(*, "resolved")= logi FALSE
[15:31:06.717]  - attr(*, "total_size")= num 354224
[15:31:06.721] Packages to be attached in all futures: [n=0] 
[15:31:06.722] getGlobalsAndPackagesXApply() ... DONE
[15:31:06.725] future_lapply() ...
[15:31:06.796] Number of chunks: 2
[15:31:06.797] getGlobalsAndPackagesXApply() ...
[15:31:06.797]  - future.globals: <name-value list> with names 'list()'
[15:31:06.797]  - use_args: TRUE
[15:31:06.797] Globals to be used in all futures (chunks): [n=2] '...', '...future.FUN'
[15:31:06.798] List of 2
[15:31:06.798]  $ ...          : list()
[15:31:06.798]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:06.798]  $ ...future.FUN:function (..., exclude = if (useNA == "no") c(NA, NaN), useNA = c("no", 
[15:31:06.798]     "ifany", "always"), dnn = list.names(...), deparse.level = 1)  
[15:31:06.798]  - attr(*, "where")=List of 2
[15:31:06.798]   ..$ ...          :<environment: 0x000001bcb7f058e8> 
[15:31:06.798]   ..$ ...future.FUN:<environment: namespace:base> 
[15:31:06.798]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:06.798]  - attr(*, "resolved")= logi FALSE
[15:31:06.798]  - attr(*, "total_size")= num NA
[15:31:06.803] Packages to be attached in all futures: [n=0] 
[15:31:06.803] getGlobalsAndPackagesXApply() ... DONE
[15:31:06.803] Number of futures (= number of chunks): 2
[15:31:06.803] Launching 2 futures (chunks) ...
[15:31:06.804] Chunk #1 of 2 ...
[15:31:06.804]  - Adjusted option 'future.globals.maxSize': Inf -> 2 * Inf = Inf (bytes)
[15:31:06.804]  - seeds: <none>
[15:31:06.804]  - All globals exported: [n=5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:06.805] getGlobalsAndPackages() ...
[15:31:06.805] - globals passed as-is: [5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:06.805] Resolving globals: FALSE
[15:31:06.805] Tweak future expression to call with '...' arguments ...
[15:31:06.806] {
[15:31:06.806]     do.call(function(...) {
[15:31:06.806]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:06.806]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:06.806]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:06.806]             on.exit(options(oopts), add = TRUE)
[15:31:06.806]         }
[15:31:06.806]         {
[15:31:06.806]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:06.806]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:06.806]                 ...future.FUN(...future.X_jj, ...)
[15:31:06.806]             })
[15:31:06.806]         }
[15:31:06.806]     }, args = future.call.arguments)
[15:31:06.806] }
[15:31:06.806] Tweak future expression to call with '...' arguments ... DONE
[15:31:06.807] - globals: [5] 'future.call.arguments', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:06.807] 
[15:31:06.807] getGlobalsAndPackages() ... DONE
[15:31:06.808] run() for 'Future' ...
[15:31:06.808] - state: 'created'
[15:31:06.808] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:06.824] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:06.825] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:31:06.825]   - Field: 'node'
[15:31:06.825]   - Field: 'label'
[15:31:06.825]   - Field: 'local'
[15:31:06.825]   - Field: 'owner'
[15:31:06.826]   - Field: 'envir'
[15:31:06.826]   - Field: 'workers'
[15:31:06.826]   - Field: 'packages'
[15:31:06.826]   - Field: 'gc'
[15:31:06.826]   - Field: 'conditions'
[15:31:06.827]   - Field: 'persistent'
[15:31:06.827]   - Field: 'expr'
[15:31:06.827]   - Field: 'uuid'
[15:31:06.827]   - Field: 'seed'
[15:31:06.828]   - Field: 'version'
[15:31:06.828]   - Field: 'result'
[15:31:06.828]   - Field: 'asynchronous'
[15:31:06.828]   - Field: 'calls'
[15:31:06.828]   - Field: 'globals'
[15:31:06.829]   - Field: 'stdout'
[15:31:06.829]   - Field: 'earlySignal'
[15:31:06.829]   - Field: 'lazy'
[15:31:06.829]   - Field: 'state'
[15:31:06.829] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:31:06.830] - Launch lazy future ...
[15:31:06.830] Packages needed by the future expression (n = 0): <none>
[15:31:06.830] Packages needed by future strategies (n = 0): <none>
[15:31:06.831] {
[15:31:06.831]     {
[15:31:06.831]         {
[15:31:06.831]             ...future.startTime <- base::Sys.time()
[15:31:06.831]             {
[15:31:06.831]                 {
[15:31:06.831]                   {
[15:31:06.831]                     {
[15:31:06.831]                       base::local({
[15:31:06.831]                         has_future <- base::requireNamespace("future", 
[15:31:06.831]                           quietly = TRUE)
[15:31:06.831]                         if (has_future) {
[15:31:06.831]                           ns <- base::getNamespace("future")
[15:31:06.831]                           version <- ns[[".package"]][["version"]]
[15:31:06.831]                           if (is.null(version)) 
[15:31:06.831]                             version <- utils::packageVersion("future")
[15:31:06.831]                         }
[15:31:06.831]                         else {
[15:31:06.831]                           version <- NULL
[15:31:06.831]                         }
[15:31:06.831]                         if (!has_future || version < "1.8.0") {
[15:31:06.831]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:06.831]                             "", base::R.version$version.string), 
[15:31:06.831]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:06.831]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:06.831]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:06.831]                               "release", "version")], collapse = " "), 
[15:31:06.831]                             hostname = base::Sys.info()[["nodename"]])
[15:31:06.831]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:06.831]                             info)
[15:31:06.831]                           info <- base::paste(info, collapse = "; ")
[15:31:06.831]                           if (!has_future) {
[15:31:06.831]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:06.831]                               info)
[15:31:06.831]                           }
[15:31:06.831]                           else {
[15:31:06.831]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:06.831]                               info, version)
[15:31:06.831]                           }
[15:31:06.831]                           base::stop(msg)
[15:31:06.831]                         }
[15:31:06.831]                       })
[15:31:06.831]                     }
[15:31:06.831]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:06.831]                     base::options(mc.cores = 1L)
[15:31:06.831]                   }
[15:31:06.831]                   ...future.strategy.old <- future::plan("list")
[15:31:06.831]                   options(future.plan = NULL)
[15:31:06.831]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:06.831]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:06.831]                 }
[15:31:06.831]                 ...future.workdir <- getwd()
[15:31:06.831]             }
[15:31:06.831]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:06.831]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:06.831]         }
[15:31:06.831]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:06.831]             future.globals.maxSize = Inf, future.globals.method = NULL, 
[15:31:06.831]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:06.831]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:06.831]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:06.831]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:06.831]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:06.831]             base::names(...future.oldOptions))
[15:31:06.831]     }
[15:31:06.831]     if (FALSE) {
[15:31:06.831]     }
[15:31:06.831]     else {
[15:31:06.831]         if (TRUE) {
[15:31:06.831]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:06.831]                 open = "w")
[15:31:06.831]         }
[15:31:06.831]         else {
[15:31:06.831]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:06.831]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:06.831]         }
[15:31:06.831]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:06.831]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:06.831]             base::sink(type = "output", split = FALSE)
[15:31:06.831]             base::close(...future.stdout)
[15:31:06.831]         }, add = TRUE)
[15:31:06.831]     }
[15:31:06.831]     ...future.frame <- base::sys.nframe()
[15:31:06.831]     ...future.conditions <- base::list()
[15:31:06.831]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:06.831]     if (FALSE) {
[15:31:06.831]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:06.831]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:06.831]     }
[15:31:06.831]     ...future.result <- base::tryCatch({
[15:31:06.831]         base::withCallingHandlers({
[15:31:06.831]             ...future.value <- base::withVisible(base::local({
[15:31:06.831]                 ...future.makeSendCondition <- base::local({
[15:31:06.831]                   sendCondition <- NULL
[15:31:06.831]                   function(frame = 1L) {
[15:31:06.831]                     if (is.function(sendCondition)) 
[15:31:06.831]                       return(sendCondition)
[15:31:06.831]                     ns <- getNamespace("parallel")
[15:31:06.831]                     if (exists("sendData", mode = "function", 
[15:31:06.831]                       envir = ns)) {
[15:31:06.831]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:06.831]                         envir = ns)
[15:31:06.831]                       envir <- sys.frame(frame)
[15:31:06.831]                       master <- NULL
[15:31:06.831]                       while (!identical(envir, .GlobalEnv) && 
[15:31:06.831]                         !identical(envir, emptyenv())) {
[15:31:06.831]                         if (exists("master", mode = "list", envir = envir, 
[15:31:06.831]                           inherits = FALSE)) {
[15:31:06.831]                           master <- get("master", mode = "list", 
[15:31:06.831]                             envir = envir, inherits = FALSE)
[15:31:06.831]                           if (inherits(master, c("SOCKnode", 
[15:31:06.831]                             "SOCK0node"))) {
[15:31:06.831]                             sendCondition <<- function(cond) {
[15:31:06.831]                               data <- list(type = "VALUE", value = cond, 
[15:31:06.831]                                 success = TRUE)
[15:31:06.831]                               parallel_sendData(master, data)
[15:31:06.831]                             }
[15:31:06.831]                             return(sendCondition)
[15:31:06.831]                           }
[15:31:06.831]                         }
[15:31:06.831]                         frame <- frame + 1L
[15:31:06.831]                         envir <- sys.frame(frame)
[15:31:06.831]                       }
[15:31:06.831]                     }
[15:31:06.831]                     sendCondition <<- function(cond) NULL
[15:31:06.831]                   }
[15:31:06.831]                 })
[15:31:06.831]                 withCallingHandlers({
[15:31:06.831]                   {
[15:31:06.831]                     do.call(function(...) {
[15:31:06.831]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:06.831]                       if (!identical(...future.globals.maxSize.org, 
[15:31:06.831]                         ...future.globals.maxSize)) {
[15:31:06.831]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:06.831]                         on.exit(options(oopts), add = TRUE)
[15:31:06.831]                       }
[15:31:06.831]                       {
[15:31:06.831]                         lapply(seq_along(...future.elements_ii), 
[15:31:06.831]                           FUN = function(jj) {
[15:31:06.831]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:06.831]                             ...future.FUN(...future.X_jj, ...)
[15:31:06.831]                           })
[15:31:06.831]                       }
[15:31:06.831]                     }, args = future.call.arguments)
[15:31:06.831]                   }
[15:31:06.831]                 }, immediateCondition = function(cond) {
[15:31:06.831]                   sendCondition <- ...future.makeSendCondition()
[15:31:06.831]                   sendCondition(cond)
[15:31:06.831]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:06.831]                   {
[15:31:06.831]                     inherits <- base::inherits
[15:31:06.831]                     invokeRestart <- base::invokeRestart
[15:31:06.831]                     is.null <- base::is.null
[15:31:06.831]                     muffled <- FALSE
[15:31:06.831]                     if (inherits(cond, "message")) {
[15:31:06.831]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:06.831]                       if (muffled) 
[15:31:06.831]                         invokeRestart("muffleMessage")
[15:31:06.831]                     }
[15:31:06.831]                     else if (inherits(cond, "warning")) {
[15:31:06.831]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:06.831]                       if (muffled) 
[15:31:06.831]                         invokeRestart("muffleWarning")
[15:31:06.831]                     }
[15:31:06.831]                     else if (inherits(cond, "condition")) {
[15:31:06.831]                       if (!is.null(pattern)) {
[15:31:06.831]                         computeRestarts <- base::computeRestarts
[15:31:06.831]                         grepl <- base::grepl
[15:31:06.831]                         restarts <- computeRestarts(cond)
[15:31:06.831]                         for (restart in restarts) {
[15:31:06.831]                           name <- restart$name
[15:31:06.831]                           if (is.null(name)) 
[15:31:06.831]                             next
[15:31:06.831]                           if (!grepl(pattern, name)) 
[15:31:06.831]                             next
[15:31:06.831]                           invokeRestart(restart)
[15:31:06.831]                           muffled <- TRUE
[15:31:06.831]                           break
[15:31:06.831]                         }
[15:31:06.831]                       }
[15:31:06.831]                     }
[15:31:06.831]                     invisible(muffled)
[15:31:06.831]                   }
[15:31:06.831]                   muffleCondition(cond)
[15:31:06.831]                 })
[15:31:06.831]             }))
[15:31:06.831]             future::FutureResult(value = ...future.value$value, 
[15:31:06.831]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:06.831]                   ...future.rng), globalenv = if (FALSE) 
[15:31:06.831]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:06.831]                     ...future.globalenv.names))
[15:31:06.831]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:06.831]         }, condition = base::local({
[15:31:06.831]             c <- base::c
[15:31:06.831]             inherits <- base::inherits
[15:31:06.831]             invokeRestart <- base::invokeRestart
[15:31:06.831]             length <- base::length
[15:31:06.831]             list <- base::list
[15:31:06.831]             seq.int <- base::seq.int
[15:31:06.831]             signalCondition <- base::signalCondition
[15:31:06.831]             sys.calls <- base::sys.calls
[15:31:06.831]             `[[` <- base::`[[`
[15:31:06.831]             `+` <- base::`+`
[15:31:06.831]             `<<-` <- base::`<<-`
[15:31:06.831]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:06.831]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:06.831]                   3L)]
[15:31:06.831]             }
[15:31:06.831]             function(cond) {
[15:31:06.831]                 is_error <- inherits(cond, "error")
[15:31:06.831]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:06.831]                   NULL)
[15:31:06.831]                 if (is_error) {
[15:31:06.831]                   sessionInformation <- function() {
[15:31:06.831]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:06.831]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:06.831]                       search = base::search(), system = base::Sys.info())
[15:31:06.831]                   }
[15:31:06.831]                   ...future.conditions[[length(...future.conditions) + 
[15:31:06.831]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:06.831]                     cond$call), session = sessionInformation(), 
[15:31:06.831]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:06.831]                   signalCondition(cond)
[15:31:06.831]                 }
[15:31:06.831]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:06.831]                 "immediateCondition"))) {
[15:31:06.831]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:06.831]                   ...future.conditions[[length(...future.conditions) + 
[15:31:06.831]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:06.831]                   if (TRUE && !signal) {
[15:31:06.831]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:06.831]                     {
[15:31:06.831]                       inherits <- base::inherits
[15:31:06.831]                       invokeRestart <- base::invokeRestart
[15:31:06.831]                       is.null <- base::is.null
[15:31:06.831]                       muffled <- FALSE
[15:31:06.831]                       if (inherits(cond, "message")) {
[15:31:06.831]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:06.831]                         if (muffled) 
[15:31:06.831]                           invokeRestart("muffleMessage")
[15:31:06.831]                       }
[15:31:06.831]                       else if (inherits(cond, "warning")) {
[15:31:06.831]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:06.831]                         if (muffled) 
[15:31:06.831]                           invokeRestart("muffleWarning")
[15:31:06.831]                       }
[15:31:06.831]                       else if (inherits(cond, "condition")) {
[15:31:06.831]                         if (!is.null(pattern)) {
[15:31:06.831]                           computeRestarts <- base::computeRestarts
[15:31:06.831]                           grepl <- base::grepl
[15:31:06.831]                           restarts <- computeRestarts(cond)
[15:31:06.831]                           for (restart in restarts) {
[15:31:06.831]                             name <- restart$name
[15:31:06.831]                             if (is.null(name)) 
[15:31:06.831]                               next
[15:31:06.831]                             if (!grepl(pattern, name)) 
[15:31:06.831]                               next
[15:31:06.831]                             invokeRestart(restart)
[15:31:06.831]                             muffled <- TRUE
[15:31:06.831]                             break
[15:31:06.831]                           }
[15:31:06.831]                         }
[15:31:06.831]                       }
[15:31:06.831]                       invisible(muffled)
[15:31:06.831]                     }
[15:31:06.831]                     muffleCondition(cond, pattern = "^muffle")
[15:31:06.831]                   }
[15:31:06.831]                 }
[15:31:06.831]                 else {
[15:31:06.831]                   if (TRUE) {
[15:31:06.831]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:06.831]                     {
[15:31:06.831]                       inherits <- base::inherits
[15:31:06.831]                       invokeRestart <- base::invokeRestart
[15:31:06.831]                       is.null <- base::is.null
[15:31:06.831]                       muffled <- FALSE
[15:31:06.831]                       if (inherits(cond, "message")) {
[15:31:06.831]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:06.831]                         if (muffled) 
[15:31:06.831]                           invokeRestart("muffleMessage")
[15:31:06.831]                       }
[15:31:06.831]                       else if (inherits(cond, "warning")) {
[15:31:06.831]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:06.831]                         if (muffled) 
[15:31:06.831]                           invokeRestart("muffleWarning")
[15:31:06.831]                       }
[15:31:06.831]                       else if (inherits(cond, "condition")) {
[15:31:06.831]                         if (!is.null(pattern)) {
[15:31:06.831]                           computeRestarts <- base::computeRestarts
[15:31:06.831]                           grepl <- base::grepl
[15:31:06.831]                           restarts <- computeRestarts(cond)
[15:31:06.831]                           for (restart in restarts) {
[15:31:06.831]                             name <- restart$name
[15:31:06.831]                             if (is.null(name)) 
[15:31:06.831]                               next
[15:31:06.831]                             if (!grepl(pattern, name)) 
[15:31:06.831]                               next
[15:31:06.831]                             invokeRestart(restart)
[15:31:06.831]                             muffled <- TRUE
[15:31:06.831]                             break
[15:31:06.831]                           }
[15:31:06.831]                         }
[15:31:06.831]                       }
[15:31:06.831]                       invisible(muffled)
[15:31:06.831]                     }
[15:31:06.831]                     muffleCondition(cond, pattern = "^muffle")
[15:31:06.831]                   }
[15:31:06.831]                 }
[15:31:06.831]             }
[15:31:06.831]         }))
[15:31:06.831]     }, error = function(ex) {
[15:31:06.831]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:06.831]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:06.831]                 ...future.rng), started = ...future.startTime, 
[15:31:06.831]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:06.831]             version = "1.8"), class = "FutureResult")
[15:31:06.831]     }, finally = {
[15:31:06.831]         if (!identical(...future.workdir, getwd())) 
[15:31:06.831]             setwd(...future.workdir)
[15:31:06.831]         {
[15:31:06.831]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:06.831]                 ...future.oldOptions$nwarnings <- NULL
[15:31:06.831]             }
[15:31:06.831]             base::options(...future.oldOptions)
[15:31:06.831]             if (.Platform$OS.type == "windows") {
[15:31:06.831]                 old_names <- names(...future.oldEnvVars)
[15:31:06.831]                 envs <- base::Sys.getenv()
[15:31:06.831]                 names <- names(envs)
[15:31:06.831]                 common <- intersect(names, old_names)
[15:31:06.831]                 added <- setdiff(names, old_names)
[15:31:06.831]                 removed <- setdiff(old_names, names)
[15:31:06.831]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:06.831]                   envs[common]]
[15:31:06.831]                 NAMES <- toupper(changed)
[15:31:06.831]                 args <- list()
[15:31:06.831]                 for (kk in seq_along(NAMES)) {
[15:31:06.831]                   name <- changed[[kk]]
[15:31:06.831]                   NAME <- NAMES[[kk]]
[15:31:06.831]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:06.831]                     next
[15:31:06.831]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:06.831]                 }
[15:31:06.831]                 NAMES <- toupper(added)
[15:31:06.831]                 for (kk in seq_along(NAMES)) {
[15:31:06.831]                   name <- added[[kk]]
[15:31:06.831]                   NAME <- NAMES[[kk]]
[15:31:06.831]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:06.831]                     next
[15:31:06.831]                   args[[name]] <- ""
[15:31:06.831]                 }
[15:31:06.831]                 NAMES <- toupper(removed)
[15:31:06.831]                 for (kk in seq_along(NAMES)) {
[15:31:06.831]                   name <- removed[[kk]]
[15:31:06.831]                   NAME <- NAMES[[kk]]
[15:31:06.831]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:06.831]                     next
[15:31:06.831]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:06.831]                 }
[15:31:06.831]                 if (length(args) > 0) 
[15:31:06.831]                   base::do.call(base::Sys.setenv, args = args)
[15:31:06.831]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:06.831]             }
[15:31:06.831]             else {
[15:31:06.831]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:06.831]             }
[15:31:06.831]             {
[15:31:06.831]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:06.831]                   0L) {
[15:31:06.831]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:06.831]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:06.831]                   base::options(opts)
[15:31:06.831]                 }
[15:31:06.831]                 {
[15:31:06.831]                   {
[15:31:06.831]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:06.831]                     NULL
[15:31:06.831]                   }
[15:31:06.831]                   options(future.plan = NULL)
[15:31:06.831]                   if (is.na(NA_character_)) 
[15:31:06.831]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:06.831]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:06.831]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:06.831]                     .init = FALSE)
[15:31:06.831]                 }
[15:31:06.831]             }
[15:31:06.831]         }
[15:31:06.831]     })
[15:31:06.831]     if (TRUE) {
[15:31:06.831]         base::sink(type = "output", split = FALSE)
[15:31:06.831]         if (TRUE) {
[15:31:06.831]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:06.831]         }
[15:31:06.831]         else {
[15:31:06.831]             ...future.result["stdout"] <- base::list(NULL)
[15:31:06.831]         }
[15:31:06.831]         base::close(...future.stdout)
[15:31:06.831]         ...future.stdout <- NULL
[15:31:06.831]     }
[15:31:06.831]     ...future.result$conditions <- ...future.conditions
[15:31:06.831]     ...future.result$finished <- base::Sys.time()
[15:31:06.831]     ...future.result
[15:31:06.831] }
[15:31:06.837] Exporting 5 global objects (346.05 KiB) to cluster node #1 ...
[15:31:06.837] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:31:06.838] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:31:06.838] Exporting '...future.FUN' (345.92 KiB) to cluster node #1 ...
[15:31:06.839] Exporting '...future.FUN' (345.92 KiB) to cluster node #1 ... DONE
[15:31:06.839] Exporting '...future.elements_ii' (80 bytes) to cluster node #1 ...
[15:31:06.840] Exporting '...future.elements_ii' (80 bytes) to cluster node #1 ... DONE
[15:31:06.840] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:31:06.841] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:31:06.841] Exporting '...future.globals.maxSize' (56 bytes) to cluster node #1 ...
[15:31:06.842] Exporting '...future.globals.maxSize' (56 bytes) to cluster node #1 ... DONE
[15:31:06.842] Exporting 5 global objects (346.05 KiB) to cluster node #1 ... DONE
[15:31:06.843] MultisessionFuture started
[15:31:06.844] - Launch lazy future ... done
[15:31:06.844] run() for 'MultisessionFuture' ... done
[15:31:06.844] Created future:
[15:31:06.865] receiveMessageFromWorker() for ClusterFuture ...
[15:31:06.865] - Validating connection of MultisessionFuture
[15:31:06.866] - received message: FutureResult
[15:31:06.866] - Received FutureResult
[15:31:06.866] - Erased future from FutureRegistry
[15:31:06.866] result() for ClusterFuture ...
[15:31:06.866] - result already collected: FutureResult
[15:31:06.867] result() for ClusterFuture ... done
[15:31:06.867] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:06.845] MultisessionFuture:
[15:31:06.845] Label: 'future_apply-1'
[15:31:06.845] Expression:
[15:31:06.845] {
[15:31:06.845]     do.call(function(...) {
[15:31:06.845]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:06.845]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:06.845]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:06.845]             on.exit(options(oopts), add = TRUE)
[15:31:06.845]         }
[15:31:06.845]         {
[15:31:06.845]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:06.845]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:06.845]                 ...future.FUN(...future.X_jj, ...)
[15:31:06.845]             })
[15:31:06.845]         }
[15:31:06.845]     }, args = future.call.arguments)
[15:31:06.845] }
[15:31:06.845] Lazy evaluation: FALSE
[15:31:06.845] Asynchronous evaluation: TRUE
[15:31:06.845] Local evaluation: TRUE
[15:31:06.845] Environment: R_GlobalEnv
[15:31:06.845] Capture standard output: TRUE
[15:31:06.845] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:06.845] Globals: 5 objects totaling 346.05 KiB (DotDotDotList 'future.call.arguments' of 0 bytes, function '...future.FUN' of 345.92 KiB, list '...future.elements_ii' of 80 bytes, NULL '...future.seeds_ii' of 0 bytes, numeric '...future.globals.maxSize' of 56 bytes)
[15:31:06.845] Packages: <none>
[15:31:06.845] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:06.845] Resolved: TRUE
[15:31:06.845] Value: <not collected>
[15:31:06.845] Conditions captured: <none>
[15:31:06.845] Early signaling: FALSE
[15:31:06.845] Owner process: 6672a580-6d3c-e82f-380e-108c475ace70
[15:31:06.845] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:06.867] Chunk #1 of 2 ... DONE
[15:31:06.868] Chunk #2 of 2 ...
[15:31:06.868]  - Adjusted option 'future.globals.maxSize': Inf -> 2 * Inf = Inf (bytes)
[15:31:06.868]  - seeds: <none>
[15:31:06.868]  - All globals exported: [n=5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:06.868] getGlobalsAndPackages() ...
[15:31:06.869] - globals passed as-is: [5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:06.869] Resolving globals: FALSE
[15:31:06.869] Tweak future expression to call with '...' arguments ...
[15:31:06.869] {
[15:31:06.869]     do.call(function(...) {
[15:31:06.869]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:06.869]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:06.869]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:06.869]             on.exit(options(oopts), add = TRUE)
[15:31:06.869]         }
[15:31:06.869]         {
[15:31:06.869]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:06.869]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:06.869]                 ...future.FUN(...future.X_jj, ...)
[15:31:06.869]             })
[15:31:06.869]         }
[15:31:06.869]     }, args = future.call.arguments)
[15:31:06.869] }
[15:31:06.870] Tweak future expression to call with '...' arguments ... DONE
[15:31:06.870] - globals: [5] 'future.call.arguments', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:06.871] 
[15:31:06.871] getGlobalsAndPackages() ... DONE
[15:31:06.871] run() for 'Future' ...
[15:31:06.871] - state: 'created'
[15:31:06.872] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:06.890] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:06.890] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:31:06.890]   - Field: 'node'
[15:31:06.891]   - Field: 'label'
[15:31:06.891]   - Field: 'local'
[15:31:06.891]   - Field: 'owner'
[15:31:06.892]   - Field: 'envir'
[15:31:06.892]   - Field: 'workers'
[15:31:06.892]   - Field: 'packages'
[15:31:06.893]   - Field: 'gc'
[15:31:06.893]   - Field: 'conditions'
[15:31:06.893]   - Field: 'persistent'
[15:31:06.894]   - Field: 'expr'
[15:31:06.894]   - Field: 'uuid'
[15:31:06.894]   - Field: 'seed'
[15:31:06.895]   - Field: 'version'
[15:31:06.895]   - Field: 'result'
[15:31:06.895]   - Field: 'asynchronous'
[15:31:06.896]   - Field: 'calls'
[15:31:06.896]   - Field: 'globals'
[15:31:06.896]   - Field: 'stdout'
[15:31:06.897]   - Field: 'earlySignal'
[15:31:06.897]   - Field: 'lazy'
[15:31:06.897]   - Field: 'state'
[15:31:06.898] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:31:06.898] - Launch lazy future ...
[15:31:06.899] Packages needed by the future expression (n = 0): <none>
[15:31:06.899] Packages needed by future strategies (n = 0): <none>
[15:31:06.900] {
[15:31:06.900]     {
[15:31:06.900]         {
[15:31:06.900]             ...future.startTime <- base::Sys.time()
[15:31:06.900]             {
[15:31:06.900]                 {
[15:31:06.900]                   {
[15:31:06.900]                     {
[15:31:06.900]                       base::local({
[15:31:06.900]                         has_future <- base::requireNamespace("future", 
[15:31:06.900]                           quietly = TRUE)
[15:31:06.900]                         if (has_future) {
[15:31:06.900]                           ns <- base::getNamespace("future")
[15:31:06.900]                           version <- ns[[".package"]][["version"]]
[15:31:06.900]                           if (is.null(version)) 
[15:31:06.900]                             version <- utils::packageVersion("future")
[15:31:06.900]                         }
[15:31:06.900]                         else {
[15:31:06.900]                           version <- NULL
[15:31:06.900]                         }
[15:31:06.900]                         if (!has_future || version < "1.8.0") {
[15:31:06.900]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:06.900]                             "", base::R.version$version.string), 
[15:31:06.900]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:06.900]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:06.900]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:06.900]                               "release", "version")], collapse = " "), 
[15:31:06.900]                             hostname = base::Sys.info()[["nodename"]])
[15:31:06.900]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:06.900]                             info)
[15:31:06.900]                           info <- base::paste(info, collapse = "; ")
[15:31:06.900]                           if (!has_future) {
[15:31:06.900]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:06.900]                               info)
[15:31:06.900]                           }
[15:31:06.900]                           else {
[15:31:06.900]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:06.900]                               info, version)
[15:31:06.900]                           }
[15:31:06.900]                           base::stop(msg)
[15:31:06.900]                         }
[15:31:06.900]                       })
[15:31:06.900]                     }
[15:31:06.900]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:06.900]                     base::options(mc.cores = 1L)
[15:31:06.900]                   }
[15:31:06.900]                   ...future.strategy.old <- future::plan("list")
[15:31:06.900]                   options(future.plan = NULL)
[15:31:06.900]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:06.900]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:06.900]                 }
[15:31:06.900]                 ...future.workdir <- getwd()
[15:31:06.900]             }
[15:31:06.900]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:06.900]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:06.900]         }
[15:31:06.900]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:06.900]             future.globals.maxSize = Inf, future.globals.method = NULL, 
[15:31:06.900]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:06.900]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:06.900]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:06.900]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:06.900]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:06.900]             base::names(...future.oldOptions))
[15:31:06.900]     }
[15:31:06.900]     if (FALSE) {
[15:31:06.900]     }
[15:31:06.900]     else {
[15:31:06.900]         if (TRUE) {
[15:31:06.900]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:06.900]                 open = "w")
[15:31:06.900]         }
[15:31:06.900]         else {
[15:31:06.900]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:06.900]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:06.900]         }
[15:31:06.900]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:06.900]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:06.900]             base::sink(type = "output", split = FALSE)
[15:31:06.900]             base::close(...future.stdout)
[15:31:06.900]         }, add = TRUE)
[15:31:06.900]     }
[15:31:06.900]     ...future.frame <- base::sys.nframe()
[15:31:06.900]     ...future.conditions <- base::list()
[15:31:06.900]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:06.900]     if (FALSE) {
[15:31:06.900]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:06.900]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:06.900]     }
[15:31:06.900]     ...future.result <- base::tryCatch({
[15:31:06.900]         base::withCallingHandlers({
[15:31:06.900]             ...future.value <- base::withVisible(base::local({
[15:31:06.900]                 ...future.makeSendCondition <- base::local({
[15:31:06.900]                   sendCondition <- NULL
[15:31:06.900]                   function(frame = 1L) {
[15:31:06.900]                     if (is.function(sendCondition)) 
[15:31:06.900]                       return(sendCondition)
[15:31:06.900]                     ns <- getNamespace("parallel")
[15:31:06.900]                     if (exists("sendData", mode = "function", 
[15:31:06.900]                       envir = ns)) {
[15:31:06.900]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:06.900]                         envir = ns)
[15:31:06.900]                       envir <- sys.frame(frame)
[15:31:06.900]                       master <- NULL
[15:31:06.900]                       while (!identical(envir, .GlobalEnv) && 
[15:31:06.900]                         !identical(envir, emptyenv())) {
[15:31:06.900]                         if (exists("master", mode = "list", envir = envir, 
[15:31:06.900]                           inherits = FALSE)) {
[15:31:06.900]                           master <- get("master", mode = "list", 
[15:31:06.900]                             envir = envir, inherits = FALSE)
[15:31:06.900]                           if (inherits(master, c("SOCKnode", 
[15:31:06.900]                             "SOCK0node"))) {
[15:31:06.900]                             sendCondition <<- function(cond) {
[15:31:06.900]                               data <- list(type = "VALUE", value = cond, 
[15:31:06.900]                                 success = TRUE)
[15:31:06.900]                               parallel_sendData(master, data)
[15:31:06.900]                             }
[15:31:06.900]                             return(sendCondition)
[15:31:06.900]                           }
[15:31:06.900]                         }
[15:31:06.900]                         frame <- frame + 1L
[15:31:06.900]                         envir <- sys.frame(frame)
[15:31:06.900]                       }
[15:31:06.900]                     }
[15:31:06.900]                     sendCondition <<- function(cond) NULL
[15:31:06.900]                   }
[15:31:06.900]                 })
[15:31:06.900]                 withCallingHandlers({
[15:31:06.900]                   {
[15:31:06.900]                     do.call(function(...) {
[15:31:06.900]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:06.900]                       if (!identical(...future.globals.maxSize.org, 
[15:31:06.900]                         ...future.globals.maxSize)) {
[15:31:06.900]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:06.900]                         on.exit(options(oopts), add = TRUE)
[15:31:06.900]                       }
[15:31:06.900]                       {
[15:31:06.900]                         lapply(seq_along(...future.elements_ii), 
[15:31:06.900]                           FUN = function(jj) {
[15:31:06.900]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:06.900]                             ...future.FUN(...future.X_jj, ...)
[15:31:06.900]                           })
[15:31:06.900]                       }
[15:31:06.900]                     }, args = future.call.arguments)
[15:31:06.900]                   }
[15:31:06.900]                 }, immediateCondition = function(cond) {
[15:31:06.900]                   sendCondition <- ...future.makeSendCondition()
[15:31:06.900]                   sendCondition(cond)
[15:31:06.900]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:06.900]                   {
[15:31:06.900]                     inherits <- base::inherits
[15:31:06.900]                     invokeRestart <- base::invokeRestart
[15:31:06.900]                     is.null <- base::is.null
[15:31:06.900]                     muffled <- FALSE
[15:31:06.900]                     if (inherits(cond, "message")) {
[15:31:06.900]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:06.900]                       if (muffled) 
[15:31:06.900]                         invokeRestart("muffleMessage")
[15:31:06.900]                     }
[15:31:06.900]                     else if (inherits(cond, "warning")) {
[15:31:06.900]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:06.900]                       if (muffled) 
[15:31:06.900]                         invokeRestart("muffleWarning")
[15:31:06.900]                     }
[15:31:06.900]                     else if (inherits(cond, "condition")) {
[15:31:06.900]                       if (!is.null(pattern)) {
[15:31:06.900]                         computeRestarts <- base::computeRestarts
[15:31:06.900]                         grepl <- base::grepl
[15:31:06.900]                         restarts <- computeRestarts(cond)
[15:31:06.900]                         for (restart in restarts) {
[15:31:06.900]                           name <- restart$name
[15:31:06.900]                           if (is.null(name)) 
[15:31:06.900]                             next
[15:31:06.900]                           if (!grepl(pattern, name)) 
[15:31:06.900]                             next
[15:31:06.900]                           invokeRestart(restart)
[15:31:06.900]                           muffled <- TRUE
[15:31:06.900]                           break
[15:31:06.900]                         }
[15:31:06.900]                       }
[15:31:06.900]                     }
[15:31:06.900]                     invisible(muffled)
[15:31:06.900]                   }
[15:31:06.900]                   muffleCondition(cond)
[15:31:06.900]                 })
[15:31:06.900]             }))
[15:31:06.900]             future::FutureResult(value = ...future.value$value, 
[15:31:06.900]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:06.900]                   ...future.rng), globalenv = if (FALSE) 
[15:31:06.900]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:06.900]                     ...future.globalenv.names))
[15:31:06.900]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:06.900]         }, condition = base::local({
[15:31:06.900]             c <- base::c
[15:31:06.900]             inherits <- base::inherits
[15:31:06.900]             invokeRestart <- base::invokeRestart
[15:31:06.900]             length <- base::length
[15:31:06.900]             list <- base::list
[15:31:06.900]             seq.int <- base::seq.int
[15:31:06.900]             signalCondition <- base::signalCondition
[15:31:06.900]             sys.calls <- base::sys.calls
[15:31:06.900]             `[[` <- base::`[[`
[15:31:06.900]             `+` <- base::`+`
[15:31:06.900]             `<<-` <- base::`<<-`
[15:31:06.900]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:06.900]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:06.900]                   3L)]
[15:31:06.900]             }
[15:31:06.900]             function(cond) {
[15:31:06.900]                 is_error <- inherits(cond, "error")
[15:31:06.900]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:06.900]                   NULL)
[15:31:06.900]                 if (is_error) {
[15:31:06.900]                   sessionInformation <- function() {
[15:31:06.900]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:06.900]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:06.900]                       search = base::search(), system = base::Sys.info())
[15:31:06.900]                   }
[15:31:06.900]                   ...future.conditions[[length(...future.conditions) + 
[15:31:06.900]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:06.900]                     cond$call), session = sessionInformation(), 
[15:31:06.900]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:06.900]                   signalCondition(cond)
[15:31:06.900]                 }
[15:31:06.900]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:06.900]                 "immediateCondition"))) {
[15:31:06.900]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:06.900]                   ...future.conditions[[length(...future.conditions) + 
[15:31:06.900]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:06.900]                   if (TRUE && !signal) {
[15:31:06.900]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:06.900]                     {
[15:31:06.900]                       inherits <- base::inherits
[15:31:06.900]                       invokeRestart <- base::invokeRestart
[15:31:06.900]                       is.null <- base::is.null
[15:31:06.900]                       muffled <- FALSE
[15:31:06.900]                       if (inherits(cond, "message")) {
[15:31:06.900]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:06.900]                         if (muffled) 
[15:31:06.900]                           invokeRestart("muffleMessage")
[15:31:06.900]                       }
[15:31:06.900]                       else if (inherits(cond, "warning")) {
[15:31:06.900]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:06.900]                         if (muffled) 
[15:31:06.900]                           invokeRestart("muffleWarning")
[15:31:06.900]                       }
[15:31:06.900]                       else if (inherits(cond, "condition")) {
[15:31:06.900]                         if (!is.null(pattern)) {
[15:31:06.900]                           computeRestarts <- base::computeRestarts
[15:31:06.900]                           grepl <- base::grepl
[15:31:06.900]                           restarts <- computeRestarts(cond)
[15:31:06.900]                           for (restart in restarts) {
[15:31:06.900]                             name <- restart$name
[15:31:06.900]                             if (is.null(name)) 
[15:31:06.900]                               next
[15:31:06.900]                             if (!grepl(pattern, name)) 
[15:31:06.900]                               next
[15:31:06.900]                             invokeRestart(restart)
[15:31:06.900]                             muffled <- TRUE
[15:31:06.900]                             break
[15:31:06.900]                           }
[15:31:06.900]                         }
[15:31:06.900]                       }
[15:31:06.900]                       invisible(muffled)
[15:31:06.900]                     }
[15:31:06.900]                     muffleCondition(cond, pattern = "^muffle")
[15:31:06.900]                   }
[15:31:06.900]                 }
[15:31:06.900]                 else {
[15:31:06.900]                   if (TRUE) {
[15:31:06.900]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:06.900]                     {
[15:31:06.900]                       inherits <- base::inherits
[15:31:06.900]                       invokeRestart <- base::invokeRestart
[15:31:06.900]                       is.null <- base::is.null
[15:31:06.900]                       muffled <- FALSE
[15:31:06.900]                       if (inherits(cond, "message")) {
[15:31:06.900]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:06.900]                         if (muffled) 
[15:31:06.900]                           invokeRestart("muffleMessage")
[15:31:06.900]                       }
[15:31:06.900]                       else if (inherits(cond, "warning")) {
[15:31:06.900]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:06.900]                         if (muffled) 
[15:31:06.900]                           invokeRestart("muffleWarning")
[15:31:06.900]                       }
[15:31:06.900]                       else if (inherits(cond, "condition")) {
[15:31:06.900]                         if (!is.null(pattern)) {
[15:31:06.900]                           computeRestarts <- base::computeRestarts
[15:31:06.900]                           grepl <- base::grepl
[15:31:06.900]                           restarts <- computeRestarts(cond)
[15:31:06.900]                           for (restart in restarts) {
[15:31:06.900]                             name <- restart$name
[15:31:06.900]                             if (is.null(name)) 
[15:31:06.900]                               next
[15:31:06.900]                             if (!grepl(pattern, name)) 
[15:31:06.900]                               next
[15:31:06.900]                             invokeRestart(restart)
[15:31:06.900]                             muffled <- TRUE
[15:31:06.900]                             break
[15:31:06.900]                           }
[15:31:06.900]                         }
[15:31:06.900]                       }
[15:31:06.900]                       invisible(muffled)
[15:31:06.900]                     }
[15:31:06.900]                     muffleCondition(cond, pattern = "^muffle")
[15:31:06.900]                   }
[15:31:06.900]                 }
[15:31:06.900]             }
[15:31:06.900]         }))
[15:31:06.900]     }, error = function(ex) {
[15:31:06.900]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:06.900]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:06.900]                 ...future.rng), started = ...future.startTime, 
[15:31:06.900]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:06.900]             version = "1.8"), class = "FutureResult")
[15:31:06.900]     }, finally = {
[15:31:06.900]         if (!identical(...future.workdir, getwd())) 
[15:31:06.900]             setwd(...future.workdir)
[15:31:06.900]         {
[15:31:06.900]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:06.900]                 ...future.oldOptions$nwarnings <- NULL
[15:31:06.900]             }
[15:31:06.900]             base::options(...future.oldOptions)
[15:31:06.900]             if (.Platform$OS.type == "windows") {
[15:31:06.900]                 old_names <- names(...future.oldEnvVars)
[15:31:06.900]                 envs <- base::Sys.getenv()
[15:31:06.900]                 names <- names(envs)
[15:31:06.900]                 common <- intersect(names, old_names)
[15:31:06.900]                 added <- setdiff(names, old_names)
[15:31:06.900]                 removed <- setdiff(old_names, names)
[15:31:06.900]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:06.900]                   envs[common]]
[15:31:06.900]                 NAMES <- toupper(changed)
[15:31:06.900]                 args <- list()
[15:31:06.900]                 for (kk in seq_along(NAMES)) {
[15:31:06.900]                   name <- changed[[kk]]
[15:31:06.900]                   NAME <- NAMES[[kk]]
[15:31:06.900]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:06.900]                     next
[15:31:06.900]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:06.900]                 }
[15:31:06.900]                 NAMES <- toupper(added)
[15:31:06.900]                 for (kk in seq_along(NAMES)) {
[15:31:06.900]                   name <- added[[kk]]
[15:31:06.900]                   NAME <- NAMES[[kk]]
[15:31:06.900]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:06.900]                     next
[15:31:06.900]                   args[[name]] <- ""
[15:31:06.900]                 }
[15:31:06.900]                 NAMES <- toupper(removed)
[15:31:06.900]                 for (kk in seq_along(NAMES)) {
[15:31:06.900]                   name <- removed[[kk]]
[15:31:06.900]                   NAME <- NAMES[[kk]]
[15:31:06.900]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:06.900]                     next
[15:31:06.900]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:06.900]                 }
[15:31:06.900]                 if (length(args) > 0) 
[15:31:06.900]                   base::do.call(base::Sys.setenv, args = args)
[15:31:06.900]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:06.900]             }
[15:31:06.900]             else {
[15:31:06.900]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:06.900]             }
[15:31:06.900]             {
[15:31:06.900]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:06.900]                   0L) {
[15:31:06.900]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:06.900]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:06.900]                   base::options(opts)
[15:31:06.900]                 }
[15:31:06.900]                 {
[15:31:06.900]                   {
[15:31:06.900]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:06.900]                     NULL
[15:31:06.900]                   }
[15:31:06.900]                   options(future.plan = NULL)
[15:31:06.900]                   if (is.na(NA_character_)) 
[15:31:06.900]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:06.900]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:06.900]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:06.900]                     .init = FALSE)
[15:31:06.900]                 }
[15:31:06.900]             }
[15:31:06.900]         }
[15:31:06.900]     })
[15:31:06.900]     if (TRUE) {
[15:31:06.900]         base::sink(type = "output", split = FALSE)
[15:31:06.900]         if (TRUE) {
[15:31:06.900]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:06.900]         }
[15:31:06.900]         else {
[15:31:06.900]             ...future.result["stdout"] <- base::list(NULL)
[15:31:06.900]         }
[15:31:06.900]         base::close(...future.stdout)
[15:31:06.900]         ...future.stdout <- NULL
[15:31:06.900]     }
[15:31:06.900]     ...future.result$conditions <- ...future.conditions
[15:31:06.900]     ...future.result$finished <- base::Sys.time()
[15:31:06.900]     ...future.result
[15:31:06.900] }
[15:31:06.910] Exporting 5 global objects (346.05 KiB) to cluster node #1 ...
[15:31:06.911] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:31:06.911] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:31:06.912] Exporting '...future.FUN' (345.92 KiB) to cluster node #1 ...
[15:31:06.913] Exporting '...future.FUN' (345.92 KiB) to cluster node #1 ... DONE
[15:31:06.914] Exporting '...future.elements_ii' (80 bytes) to cluster node #1 ...
[15:31:06.914] Exporting '...future.elements_ii' (80 bytes) to cluster node #1 ... DONE
[15:31:06.915] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:31:06.915] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:31:06.916] Exporting '...future.globals.maxSize' (56 bytes) to cluster node #1 ...
[15:31:06.916] Exporting '...future.globals.maxSize' (56 bytes) to cluster node #1 ... DONE
[15:31:06.917] Exporting 5 global objects (346.05 KiB) to cluster node #1 ... DONE
[15:31:06.918] MultisessionFuture started
[15:31:06.918] - Launch lazy future ... done
[15:31:06.918] run() for 'MultisessionFuture' ... done
[15:31:06.919] Created future:
[15:31:06.948] receiveMessageFromWorker() for ClusterFuture ...
[15:31:06.948] - Validating connection of MultisessionFuture
[15:31:06.949] - received message: FutureResult
[15:31:06.949] - Received FutureResult
[15:31:06.949] - Erased future from FutureRegistry
[15:31:06.950] result() for ClusterFuture ...
[15:31:06.950] - result already collected: FutureResult
[15:31:06.950] result() for ClusterFuture ... done
[15:31:06.951] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:06.919] MultisessionFuture:
[15:31:06.919] Label: 'future_apply-2'
[15:31:06.919] Expression:
[15:31:06.919] {
[15:31:06.919]     do.call(function(...) {
[15:31:06.919]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:06.919]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:06.919]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:06.919]             on.exit(options(oopts), add = TRUE)
[15:31:06.919]         }
[15:31:06.919]         {
[15:31:06.919]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:06.919]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:06.919]                 ...future.FUN(...future.X_jj, ...)
[15:31:06.919]             })
[15:31:06.919]         }
[15:31:06.919]     }, args = future.call.arguments)
[15:31:06.919] }
[15:31:06.919] Lazy evaluation: FALSE
[15:31:06.919] Asynchronous evaluation: TRUE
[15:31:06.919] Local evaluation: TRUE
[15:31:06.919] Environment: R_GlobalEnv
[15:31:06.919] Capture standard output: TRUE
[15:31:06.919] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:06.919] Globals: 5 objects totaling 346.05 KiB (DotDotDotList 'future.call.arguments' of 0 bytes, function '...future.FUN' of 345.92 KiB, list '...future.elements_ii' of 80 bytes, NULL '...future.seeds_ii' of 0 bytes, numeric '...future.globals.maxSize' of 56 bytes)
[15:31:06.919] Packages: <none>
[15:31:06.919] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:06.919] Resolved: TRUE
[15:31:06.919] Value: <not collected>
[15:31:06.919] Conditions captured: <none>
[15:31:06.919] Early signaling: FALSE
[15:31:06.919] Owner process: 6672a580-6d3c-e82f-380e-108c475ace70
[15:31:06.919] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:06.951] Chunk #2 of 2 ... DONE
[15:31:06.952] Launching 2 futures (chunks) ... DONE
[15:31:06.952] Resolving 2 futures (chunks) ...
[15:31:06.952] resolve() on list ...
[15:31:06.952]  recursive: 0
[15:31:06.953]  length: 2
[15:31:06.953] 
[15:31:06.953] Future #1
[15:31:06.954] result() for ClusterFuture ...
[15:31:06.954] - result already collected: FutureResult
[15:31:06.954] result() for ClusterFuture ... done
[15:31:06.954] result() for ClusterFuture ...
[15:31:06.955] - result already collected: FutureResult
[15:31:06.955] result() for ClusterFuture ... done
[15:31:06.955] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:31:06.955] - nx: 2
[15:31:06.956] - relay: TRUE
[15:31:06.956] - stdout: TRUE
[15:31:06.956] - signal: TRUE
[15:31:06.956] - resignal: FALSE
[15:31:06.957] - force: TRUE
[15:31:06.957] - relayed: [n=2] FALSE, FALSE
[15:31:06.957] - queued futures: [n=2] FALSE, FALSE
[15:31:06.958]  - until=1
[15:31:06.958]  - relaying element #1
[15:31:06.958] result() for ClusterFuture ...
[15:31:06.958] - result already collected: FutureResult
[15:31:06.959] result() for ClusterFuture ... done
[15:31:06.959] result() for ClusterFuture ...
[15:31:06.959] - result already collected: FutureResult
[15:31:06.959] result() for ClusterFuture ... done
[15:31:06.960] result() for ClusterFuture ...
[15:31:06.960] - result already collected: FutureResult
[15:31:06.960] result() for ClusterFuture ... done
[15:31:06.961] result() for ClusterFuture ...
[15:31:06.961] - result already collected: FutureResult
[15:31:06.961] result() for ClusterFuture ... done
[15:31:06.961] - relayed: [n=2] TRUE, FALSE
[15:31:06.962] - queued futures: [n=2] TRUE, FALSE
[15:31:06.962] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:31:06.962]  length: 1 (resolved future 1)
[15:31:06.962] Future #2
[15:31:06.963] result() for ClusterFuture ...
[15:31:06.963] - result already collected: FutureResult
[15:31:06.963] result() for ClusterFuture ... done
[15:31:06.964] result() for ClusterFuture ...
[15:31:06.964] - result already collected: FutureResult
[15:31:06.964] result() for ClusterFuture ... done
[15:31:06.964] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:31:06.965] - nx: 2
[15:31:06.965] - relay: TRUE
[15:31:06.965] - stdout: TRUE
[15:31:06.965] - signal: TRUE
[15:31:06.966] - resignal: FALSE
[15:31:06.966] - force: TRUE
[15:31:06.966] - relayed: [n=2] TRUE, FALSE
[15:31:06.966] - queued futures: [n=2] TRUE, FALSE
[15:31:06.967]  - until=2
[15:31:06.967]  - relaying element #2
[15:31:06.968] result() for ClusterFuture ...
[15:31:06.968] - result already collected: FutureResult
[15:31:06.968] result() for ClusterFuture ... done
[15:31:06.969] result() for ClusterFuture ...
[15:31:06.969] - result already collected: FutureResult
[15:31:06.969] result() for ClusterFuture ... done
[15:31:06.970] result() for ClusterFuture ...
[15:31:06.970] - result already collected: FutureResult
[15:31:06.970] result() for ClusterFuture ... done
[15:31:06.971] result() for ClusterFuture ...
[15:31:06.971] - result already collected: FutureResult
[15:31:06.971] result() for ClusterFuture ... done
[15:31:06.975] - relayed: [n=2] TRUE, TRUE
[15:31:06.975] - queued futures: [n=2] TRUE, TRUE
[15:31:06.975] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:31:06.976]  length: 0 (resolved future 2)
[15:31:06.976] Relaying remaining futures
[15:31:06.976] signalConditionsASAP(NULL, pos=0) ...
[15:31:06.977] - nx: 2
[15:31:06.977] - relay: TRUE
[15:31:06.977] - stdout: TRUE
[15:31:06.977] - signal: TRUE
[15:31:06.978] - resignal: FALSE
[15:31:06.978] - force: TRUE
[15:31:06.978] - relayed: [n=2] TRUE, TRUE
[15:31:06.978] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:31:06.979] - relayed: [n=2] TRUE, TRUE
[15:31:06.979] - queued futures: [n=2] TRUE, TRUE
[15:31:06.980] signalConditionsASAP(NULL, pos=0) ... done
[15:31:06.980] resolve() on list ... DONE
[15:31:06.980] result() for ClusterFuture ...
[15:31:06.980] - result already collected: FutureResult
[15:31:06.981] result() for ClusterFuture ... done
[15:31:06.981] result() for ClusterFuture ...
[15:31:06.981] - result already collected: FutureResult
[15:31:06.982] result() for ClusterFuture ... done
[15:31:06.982] result() for ClusterFuture ...
[15:31:06.982] - result already collected: FutureResult
[15:31:06.982] result() for ClusterFuture ... done
[15:31:06.983] result() for ClusterFuture ...
[15:31:06.983] - result already collected: FutureResult
[15:31:06.983] result() for ClusterFuture ... done
[15:31:06.984]  - Number of value chunks collected: 2
[15:31:06.984] Resolving 2 futures (chunks) ... DONE
[15:31:06.984] Reducing values from 2 chunks ...
[15:31:06.985]  - Number of values collected after concatenation: 2
[15:31:06.985]  - Number of values expected: 2
[15:31:06.985] Reducing values from 2 chunks ... DONE
[15:31:06.986] future_lapply() ... DONE
[[1]]
...future.X_jj
1 3 7 
2 1 1 

[[2]]
...future.X_jj
2 4 6 8 
1 1 1 1 

[15:31:06.987] getGlobalsAndPackagesXApply() ...
[15:31:06.988]  - future.globals: TRUE
[15:31:06.988] getGlobalsAndPackages() ...
[15:31:06.988] Searching for globals...
[15:31:06.991] - globals found: [2] 'FUN', 'UseMethod'
[15:31:06.991] Searching for globals ... DONE
[15:31:06.991] Resolving globals: FALSE
[15:31:06.992] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:31:06.993] The total size of the 1 globals exported for future expression ('FUN(X = structure(c(1, 2, 3, 4, 1, 6, 7, 8), dim = c(2L, 4L)))') is 1.22 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.22 KiB of class 'function')
[15:31:06.993] - globals: [1] 'FUN'
[15:31:06.994] - packages: [1] 'stats'
[15:31:06.994] getGlobalsAndPackages() ... DONE
[15:31:06.994]  - globals found/used: [n=1] 'FUN'
[15:31:06.995]  - needed namespaces: [n=1] 'stats'
[15:31:06.995] Finding globals ... DONE
[15:31:06.995]  - use_args: TRUE
[15:31:06.995]  - Getting '...' globals ...
[15:31:06.996] resolve() on list ...
[15:31:06.997]  recursive: 0
[15:31:06.997]  length: 1
[15:31:06.997]  elements: '...'
[15:31:06.998]  length: 0 (resolved future 1)
[15:31:06.998] resolve() on list ... DONE
[15:31:06.998]    - '...' content: [n=0] 
[15:31:06.998] List of 1
[15:31:06.998]  $ ...: list()
[15:31:06.998]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:06.998]  - attr(*, "where")=List of 1
[15:31:06.998]   ..$ ...:<environment: 0x000001bcbb90faa8> 
[15:31:06.998]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:06.998]  - attr(*, "resolved")= logi TRUE
[15:31:06.998]  - attr(*, "total_size")= num NA
[15:31:07.004]  - Getting '...' globals ... DONE
[15:31:07.004] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:07.005] List of 2
[15:31:07.005]  $ ...future.FUN:function (x, ...)  
[15:31:07.005]  $ ...          : list()
[15:31:07.005]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:07.005]  - attr(*, "where")=List of 2
[15:31:07.005]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:07.005]   ..$ ...          :<environment: 0x000001bcbb90faa8> 
[15:31:07.005]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:07.005]  - attr(*, "resolved")= logi FALSE
[15:31:07.005]  - attr(*, "total_size")= num 1248
[15:31:07.010] Packages to be attached in all futures: [n=1] 'stats'
[15:31:07.011] getGlobalsAndPackagesXApply() ... DONE
[15:31:07.015] future_lapply() ...
[15:31:07.020] Number of chunks: 2
[15:31:07.020] getGlobalsAndPackagesXApply() ...
[15:31:07.021]  - future.globals: <name-value list> with names 'list()'
[15:31:07.021]  - use_args: TRUE
[15:31:07.021] Globals to be used in all futures (chunks): [n=2] '...', '...future.FUN'
[15:31:07.022] List of 2
[15:31:07.022]  $ ...          : list()
[15:31:07.022]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:07.022]  $ ...future.FUN:function (x, ...)  
[15:31:07.022]  - attr(*, "where")=List of 2
[15:31:07.022]   ..$ ...          :<environment: 0x000001bcbb90faa8> 
[15:31:07.022]   ..$ ...future.FUN:<environment: namespace:stats> 
[15:31:07.022]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:07.022]  - attr(*, "resolved")= logi FALSE
[15:31:07.022]  - attr(*, "total_size")= num NA
[15:31:07.028] Packages to be attached in all futures: [n=1] 'stats'
[15:31:07.028] getGlobalsAndPackagesXApply() ... DONE
[15:31:07.029] Number of futures (= number of chunks): 2
[15:31:07.029] Launching 2 futures (chunks) ...
[15:31:07.029] Chunk #1 of 2 ...
[15:31:07.030]  - Adjusted option 'future.globals.maxSize': Inf -> 2 * Inf = Inf (bytes)
[15:31:07.030]  - seeds: <none>
[15:31:07.031]  - All globals exported: [n=5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:07.031] getGlobalsAndPackages() ...
[15:31:07.031] - globals passed as-is: [5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:07.032] Resolving globals: FALSE
[15:31:07.032] Tweak future expression to call with '...' arguments ...
[15:31:07.032] {
[15:31:07.032]     do.call(function(...) {
[15:31:07.032]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:07.032]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:07.032]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:07.032]             on.exit(options(oopts), add = TRUE)
[15:31:07.032]         }
[15:31:07.032]         {
[15:31:07.032]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:07.032]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:07.032]                 ...future.FUN(...future.X_jj, ...)
[15:31:07.032]             })
[15:31:07.032]         }
[15:31:07.032]     }, args = future.call.arguments)
[15:31:07.032] }
[15:31:07.033] Tweak future expression to call with '...' arguments ... DONE
[15:31:07.034] - globals: [5] 'future.call.arguments', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:07.034] - packages: [1] 'stats'
[15:31:07.035] getGlobalsAndPackages() ... DONE
[15:31:07.035] run() for 'Future' ...
[15:31:07.036] - state: 'created'
[15:31:07.036] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:07.055] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:07.056] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:31:07.056]   - Field: 'node'
[15:31:07.056]   - Field: 'label'
[15:31:07.057]   - Field: 'local'
[15:31:07.057]   - Field: 'owner'
[15:31:07.057]   - Field: 'envir'
[15:31:07.058]   - Field: 'workers'
[15:31:07.058]   - Field: 'packages'
[15:31:07.058]   - Field: 'gc'
[15:31:07.059]   - Field: 'conditions'
[15:31:07.059]   - Field: 'persistent'
[15:31:07.059]   - Field: 'expr'
[15:31:07.060]   - Field: 'uuid'
[15:31:07.060]   - Field: 'seed'
[15:31:07.061]   - Field: 'version'
[15:31:07.061]   - Field: 'result'
[15:31:07.061]   - Field: 'asynchronous'
[15:31:07.062]   - Field: 'calls'
[15:31:07.062]   - Field: 'globals'
[15:31:07.062]   - Field: 'stdout'
[15:31:07.063]   - Field: 'earlySignal'
[15:31:07.063]   - Field: 'lazy'
[15:31:07.063]   - Field: 'state'
[15:31:07.064] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:31:07.064] - Launch lazy future ...
[15:31:07.065] Packages needed by the future expression (n = 1): 'stats'
[15:31:07.065] Packages needed by future strategies (n = 0): <none>
[15:31:07.066] {
[15:31:07.066]     {
[15:31:07.066]         {
[15:31:07.066]             ...future.startTime <- base::Sys.time()
[15:31:07.066]             {
[15:31:07.066]                 {
[15:31:07.066]                   {
[15:31:07.066]                     {
[15:31:07.066]                       {
[15:31:07.066]                         base::local({
[15:31:07.066]                           has_future <- base::requireNamespace("future", 
[15:31:07.066]                             quietly = TRUE)
[15:31:07.066]                           if (has_future) {
[15:31:07.066]                             ns <- base::getNamespace("future")
[15:31:07.066]                             version <- ns[[".package"]][["version"]]
[15:31:07.066]                             if (is.null(version)) 
[15:31:07.066]                               version <- utils::packageVersion("future")
[15:31:07.066]                           }
[15:31:07.066]                           else {
[15:31:07.066]                             version <- NULL
[15:31:07.066]                           }
[15:31:07.066]                           if (!has_future || version < "1.8.0") {
[15:31:07.066]                             info <- base::c(r_version = base::gsub("R version ", 
[15:31:07.066]                               "", base::R.version$version.string), 
[15:31:07.066]                               platform = base::sprintf("%s (%s-bit)", 
[15:31:07.066]                                 base::R.version$platform, 8 * 
[15:31:07.066]                                   base::.Machine$sizeof.pointer), 
[15:31:07.066]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:07.066]                                 "release", "version")], collapse = " "), 
[15:31:07.066]                               hostname = base::Sys.info()[["nodename"]])
[15:31:07.066]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:31:07.066]                               info)
[15:31:07.066]                             info <- base::paste(info, collapse = "; ")
[15:31:07.066]                             if (!has_future) {
[15:31:07.066]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:07.066]                                 info)
[15:31:07.066]                             }
[15:31:07.066]                             else {
[15:31:07.066]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:07.066]                                 info, version)
[15:31:07.066]                             }
[15:31:07.066]                             base::stop(msg)
[15:31:07.066]                           }
[15:31:07.066]                         })
[15:31:07.066]                       }
[15:31:07.066]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:07.066]                       base::options(mc.cores = 1L)
[15:31:07.066]                     }
[15:31:07.066]                     base::local({
[15:31:07.066]                       for (pkg in "stats") {
[15:31:07.066]                         base::loadNamespace(pkg)
[15:31:07.066]                         base::library(pkg, character.only = TRUE)
[15:31:07.066]                       }
[15:31:07.066]                     })
[15:31:07.066]                   }
[15:31:07.066]                   ...future.strategy.old <- future::plan("list")
[15:31:07.066]                   options(future.plan = NULL)
[15:31:07.066]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:07.066]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:07.066]                 }
[15:31:07.066]                 ...future.workdir <- getwd()
[15:31:07.066]             }
[15:31:07.066]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:07.066]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:07.066]         }
[15:31:07.066]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:07.066]             future.globals.maxSize = Inf, future.globals.method = NULL, 
[15:31:07.066]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:07.066]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:07.066]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:07.066]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:07.066]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:07.066]             base::names(...future.oldOptions))
[15:31:07.066]     }
[15:31:07.066]     if (FALSE) {
[15:31:07.066]     }
[15:31:07.066]     else {
[15:31:07.066]         if (TRUE) {
[15:31:07.066]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:07.066]                 open = "w")
[15:31:07.066]         }
[15:31:07.066]         else {
[15:31:07.066]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:07.066]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:07.066]         }
[15:31:07.066]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:07.066]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:07.066]             base::sink(type = "output", split = FALSE)
[15:31:07.066]             base::close(...future.stdout)
[15:31:07.066]         }, add = TRUE)
[15:31:07.066]     }
[15:31:07.066]     ...future.frame <- base::sys.nframe()
[15:31:07.066]     ...future.conditions <- base::list()
[15:31:07.066]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:07.066]     if (FALSE) {
[15:31:07.066]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:07.066]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:07.066]     }
[15:31:07.066]     ...future.result <- base::tryCatch({
[15:31:07.066]         base::withCallingHandlers({
[15:31:07.066]             ...future.value <- base::withVisible(base::local({
[15:31:07.066]                 ...future.makeSendCondition <- base::local({
[15:31:07.066]                   sendCondition <- NULL
[15:31:07.066]                   function(frame = 1L) {
[15:31:07.066]                     if (is.function(sendCondition)) 
[15:31:07.066]                       return(sendCondition)
[15:31:07.066]                     ns <- getNamespace("parallel")
[15:31:07.066]                     if (exists("sendData", mode = "function", 
[15:31:07.066]                       envir = ns)) {
[15:31:07.066]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:07.066]                         envir = ns)
[15:31:07.066]                       envir <- sys.frame(frame)
[15:31:07.066]                       master <- NULL
[15:31:07.066]                       while (!identical(envir, .GlobalEnv) && 
[15:31:07.066]                         !identical(envir, emptyenv())) {
[15:31:07.066]                         if (exists("master", mode = "list", envir = envir, 
[15:31:07.066]                           inherits = FALSE)) {
[15:31:07.066]                           master <- get("master", mode = "list", 
[15:31:07.066]                             envir = envir, inherits = FALSE)
[15:31:07.066]                           if (inherits(master, c("SOCKnode", 
[15:31:07.066]                             "SOCK0node"))) {
[15:31:07.066]                             sendCondition <<- function(cond) {
[15:31:07.066]                               data <- list(type = "VALUE", value = cond, 
[15:31:07.066]                                 success = TRUE)
[15:31:07.066]                               parallel_sendData(master, data)
[15:31:07.066]                             }
[15:31:07.066]                             return(sendCondition)
[15:31:07.066]                           }
[15:31:07.066]                         }
[15:31:07.066]                         frame <- frame + 1L
[15:31:07.066]                         envir <- sys.frame(frame)
[15:31:07.066]                       }
[15:31:07.066]                     }
[15:31:07.066]                     sendCondition <<- function(cond) NULL
[15:31:07.066]                   }
[15:31:07.066]                 })
[15:31:07.066]                 withCallingHandlers({
[15:31:07.066]                   {
[15:31:07.066]                     do.call(function(...) {
[15:31:07.066]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:07.066]                       if (!identical(...future.globals.maxSize.org, 
[15:31:07.066]                         ...future.globals.maxSize)) {
[15:31:07.066]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:07.066]                         on.exit(options(oopts), add = TRUE)
[15:31:07.066]                       }
[15:31:07.066]                       {
[15:31:07.066]                         lapply(seq_along(...future.elements_ii), 
[15:31:07.066]                           FUN = function(jj) {
[15:31:07.066]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:07.066]                             ...future.FUN(...future.X_jj, ...)
[15:31:07.066]                           })
[15:31:07.066]                       }
[15:31:07.066]                     }, args = future.call.arguments)
[15:31:07.066]                   }
[15:31:07.066]                 }, immediateCondition = function(cond) {
[15:31:07.066]                   sendCondition <- ...future.makeSendCondition()
[15:31:07.066]                   sendCondition(cond)
[15:31:07.066]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:07.066]                   {
[15:31:07.066]                     inherits <- base::inherits
[15:31:07.066]                     invokeRestart <- base::invokeRestart
[15:31:07.066]                     is.null <- base::is.null
[15:31:07.066]                     muffled <- FALSE
[15:31:07.066]                     if (inherits(cond, "message")) {
[15:31:07.066]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:07.066]                       if (muffled) 
[15:31:07.066]                         invokeRestart("muffleMessage")
[15:31:07.066]                     }
[15:31:07.066]                     else if (inherits(cond, "warning")) {
[15:31:07.066]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:07.066]                       if (muffled) 
[15:31:07.066]                         invokeRestart("muffleWarning")
[15:31:07.066]                     }
[15:31:07.066]                     else if (inherits(cond, "condition")) {
[15:31:07.066]                       if (!is.null(pattern)) {
[15:31:07.066]                         computeRestarts <- base::computeRestarts
[15:31:07.066]                         grepl <- base::grepl
[15:31:07.066]                         restarts <- computeRestarts(cond)
[15:31:07.066]                         for (restart in restarts) {
[15:31:07.066]                           name <- restart$name
[15:31:07.066]                           if (is.null(name)) 
[15:31:07.066]                             next
[15:31:07.066]                           if (!grepl(pattern, name)) 
[15:31:07.066]                             next
[15:31:07.066]                           invokeRestart(restart)
[15:31:07.066]                           muffled <- TRUE
[15:31:07.066]                           break
[15:31:07.066]                         }
[15:31:07.066]                       }
[15:31:07.066]                     }
[15:31:07.066]                     invisible(muffled)
[15:31:07.066]                   }
[15:31:07.066]                   muffleCondition(cond)
[15:31:07.066]                 })
[15:31:07.066]             }))
[15:31:07.066]             future::FutureResult(value = ...future.value$value, 
[15:31:07.066]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:07.066]                   ...future.rng), globalenv = if (FALSE) 
[15:31:07.066]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:07.066]                     ...future.globalenv.names))
[15:31:07.066]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:07.066]         }, condition = base::local({
[15:31:07.066]             c <- base::c
[15:31:07.066]             inherits <- base::inherits
[15:31:07.066]             invokeRestart <- base::invokeRestart
[15:31:07.066]             length <- base::length
[15:31:07.066]             list <- base::list
[15:31:07.066]             seq.int <- base::seq.int
[15:31:07.066]             signalCondition <- base::signalCondition
[15:31:07.066]             sys.calls <- base::sys.calls
[15:31:07.066]             `[[` <- base::`[[`
[15:31:07.066]             `+` <- base::`+`
[15:31:07.066]             `<<-` <- base::`<<-`
[15:31:07.066]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:07.066]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:07.066]                   3L)]
[15:31:07.066]             }
[15:31:07.066]             function(cond) {
[15:31:07.066]                 is_error <- inherits(cond, "error")
[15:31:07.066]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:07.066]                   NULL)
[15:31:07.066]                 if (is_error) {
[15:31:07.066]                   sessionInformation <- function() {
[15:31:07.066]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:07.066]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:07.066]                       search = base::search(), system = base::Sys.info())
[15:31:07.066]                   }
[15:31:07.066]                   ...future.conditions[[length(...future.conditions) + 
[15:31:07.066]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:07.066]                     cond$call), session = sessionInformation(), 
[15:31:07.066]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:07.066]                   signalCondition(cond)
[15:31:07.066]                 }
[15:31:07.066]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:07.066]                 "immediateCondition"))) {
[15:31:07.066]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:07.066]                   ...future.conditions[[length(...future.conditions) + 
[15:31:07.066]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:07.066]                   if (TRUE && !signal) {
[15:31:07.066]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:07.066]                     {
[15:31:07.066]                       inherits <- base::inherits
[15:31:07.066]                       invokeRestart <- base::invokeRestart
[15:31:07.066]                       is.null <- base::is.null
[15:31:07.066]                       muffled <- FALSE
[15:31:07.066]                       if (inherits(cond, "message")) {
[15:31:07.066]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:07.066]                         if (muffled) 
[15:31:07.066]                           invokeRestart("muffleMessage")
[15:31:07.066]                       }
[15:31:07.066]                       else if (inherits(cond, "warning")) {
[15:31:07.066]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:07.066]                         if (muffled) 
[15:31:07.066]                           invokeRestart("muffleWarning")
[15:31:07.066]                       }
[15:31:07.066]                       else if (inherits(cond, "condition")) {
[15:31:07.066]                         if (!is.null(pattern)) {
[15:31:07.066]                           computeRestarts <- base::computeRestarts
[15:31:07.066]                           grepl <- base::grepl
[15:31:07.066]                           restarts <- computeRestarts(cond)
[15:31:07.066]                           for (restart in restarts) {
[15:31:07.066]                             name <- restart$name
[15:31:07.066]                             if (is.null(name)) 
[15:31:07.066]                               next
[15:31:07.066]                             if (!grepl(pattern, name)) 
[15:31:07.066]                               next
[15:31:07.066]                             invokeRestart(restart)
[15:31:07.066]                             muffled <- TRUE
[15:31:07.066]                             break
[15:31:07.066]                           }
[15:31:07.066]                         }
[15:31:07.066]                       }
[15:31:07.066]                       invisible(muffled)
[15:31:07.066]                     }
[15:31:07.066]                     muffleCondition(cond, pattern = "^muffle")
[15:31:07.066]                   }
[15:31:07.066]                 }
[15:31:07.066]                 else {
[15:31:07.066]                   if (TRUE) {
[15:31:07.066]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:07.066]                     {
[15:31:07.066]                       inherits <- base::inherits
[15:31:07.066]                       invokeRestart <- base::invokeRestart
[15:31:07.066]                       is.null <- base::is.null
[15:31:07.066]                       muffled <- FALSE
[15:31:07.066]                       if (inherits(cond, "message")) {
[15:31:07.066]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:07.066]                         if (muffled) 
[15:31:07.066]                           invokeRestart("muffleMessage")
[15:31:07.066]                       }
[15:31:07.066]                       else if (inherits(cond, "warning")) {
[15:31:07.066]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:07.066]                         if (muffled) 
[15:31:07.066]                           invokeRestart("muffleWarning")
[15:31:07.066]                       }
[15:31:07.066]                       else if (inherits(cond, "condition")) {
[15:31:07.066]                         if (!is.null(pattern)) {
[15:31:07.066]                           computeRestarts <- base::computeRestarts
[15:31:07.066]                           grepl <- base::grepl
[15:31:07.066]                           restarts <- computeRestarts(cond)
[15:31:07.066]                           for (restart in restarts) {
[15:31:07.066]                             name <- restart$name
[15:31:07.066]                             if (is.null(name)) 
[15:31:07.066]                               next
[15:31:07.066]                             if (!grepl(pattern, name)) 
[15:31:07.066]                               next
[15:31:07.066]                             invokeRestart(restart)
[15:31:07.066]                             muffled <- TRUE
[15:31:07.066]                             break
[15:31:07.066]                           }
[15:31:07.066]                         }
[15:31:07.066]                       }
[15:31:07.066]                       invisible(muffled)
[15:31:07.066]                     }
[15:31:07.066]                     muffleCondition(cond, pattern = "^muffle")
[15:31:07.066]                   }
[15:31:07.066]                 }
[15:31:07.066]             }
[15:31:07.066]         }))
[15:31:07.066]     }, error = function(ex) {
[15:31:07.066]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:07.066]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:07.066]                 ...future.rng), started = ...future.startTime, 
[15:31:07.066]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:07.066]             version = "1.8"), class = "FutureResult")
[15:31:07.066]     }, finally = {
[15:31:07.066]         if (!identical(...future.workdir, getwd())) 
[15:31:07.066]             setwd(...future.workdir)
[15:31:07.066]         {
[15:31:07.066]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:07.066]                 ...future.oldOptions$nwarnings <- NULL
[15:31:07.066]             }
[15:31:07.066]             base::options(...future.oldOptions)
[15:31:07.066]             if (.Platform$OS.type == "windows") {
[15:31:07.066]                 old_names <- names(...future.oldEnvVars)
[15:31:07.066]                 envs <- base::Sys.getenv()
[15:31:07.066]                 names <- names(envs)
[15:31:07.066]                 common <- intersect(names, old_names)
[15:31:07.066]                 added <- setdiff(names, old_names)
[15:31:07.066]                 removed <- setdiff(old_names, names)
[15:31:07.066]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:07.066]                   envs[common]]
[15:31:07.066]                 NAMES <- toupper(changed)
[15:31:07.066]                 args <- list()
[15:31:07.066]                 for (kk in seq_along(NAMES)) {
[15:31:07.066]                   name <- changed[[kk]]
[15:31:07.066]                   NAME <- NAMES[[kk]]
[15:31:07.066]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:07.066]                     next
[15:31:07.066]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:07.066]                 }
[15:31:07.066]                 NAMES <- toupper(added)
[15:31:07.066]                 for (kk in seq_along(NAMES)) {
[15:31:07.066]                   name <- added[[kk]]
[15:31:07.066]                   NAME <- NAMES[[kk]]
[15:31:07.066]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:07.066]                     next
[15:31:07.066]                   args[[name]] <- ""
[15:31:07.066]                 }
[15:31:07.066]                 NAMES <- toupper(removed)
[15:31:07.066]                 for (kk in seq_along(NAMES)) {
[15:31:07.066]                   name <- removed[[kk]]
[15:31:07.066]                   NAME <- NAMES[[kk]]
[15:31:07.066]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:07.066]                     next
[15:31:07.066]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:07.066]                 }
[15:31:07.066]                 if (length(args) > 0) 
[15:31:07.066]                   base::do.call(base::Sys.setenv, args = args)
[15:31:07.066]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:07.066]             }
[15:31:07.066]             else {
[15:31:07.066]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:07.066]             }
[15:31:07.066]             {
[15:31:07.066]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:07.066]                   0L) {
[15:31:07.066]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:07.066]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:07.066]                   base::options(opts)
[15:31:07.066]                 }
[15:31:07.066]                 {
[15:31:07.066]                   {
[15:31:07.066]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:07.066]                     NULL
[15:31:07.066]                   }
[15:31:07.066]                   options(future.plan = NULL)
[15:31:07.066]                   if (is.na(NA_character_)) 
[15:31:07.066]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:07.066]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:07.066]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:07.066]                     .init = FALSE)
[15:31:07.066]                 }
[15:31:07.066]             }
[15:31:07.066]         }
[15:31:07.066]     })
[15:31:07.066]     if (TRUE) {
[15:31:07.066]         base::sink(type = "output", split = FALSE)
[15:31:07.066]         if (TRUE) {
[15:31:07.066]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:07.066]         }
[15:31:07.066]         else {
[15:31:07.066]             ...future.result["stdout"] <- base::list(NULL)
[15:31:07.066]         }
[15:31:07.066]         base::close(...future.stdout)
[15:31:07.066]         ...future.stdout <- NULL
[15:31:07.066]     }
[15:31:07.066]     ...future.result$conditions <- ...future.conditions
[15:31:07.066]     ...future.result$finished <- base::Sys.time()
[15:31:07.066]     ...future.result
[15:31:07.066] }
[15:31:07.077] Exporting 5 global objects (1.35 KiB) to cluster node #1 ...
[15:31:07.078] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:31:07.079] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:31:07.080] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:31:07.080] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:31:07.081] Exporting '...future.elements_ii' (80 bytes) to cluster node #1 ...
[15:31:07.081] Exporting '...future.elements_ii' (80 bytes) to cluster node #1 ... DONE
[15:31:07.082] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:31:07.082] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:31:07.083] Exporting '...future.globals.maxSize' (56 bytes) to cluster node #1 ...
[15:31:07.083] Exporting '...future.globals.maxSize' (56 bytes) to cluster node #1 ... DONE
[15:31:07.084] Exporting 5 global objects (1.35 KiB) to cluster node #1 ... DONE
[15:31:07.084] MultisessionFuture started
[15:31:07.085] - Launch lazy future ... done
[15:31:07.085] run() for 'MultisessionFuture' ... done
[15:31:07.085] Created future:
[15:31:07.110] receiveMessageFromWorker() for ClusterFuture ...
[15:31:07.111] - Validating connection of MultisessionFuture
[15:31:07.112] - received message: FutureResult
[15:31:07.112] - Received FutureResult
[15:31:07.112] - Erased future from FutureRegistry
[15:31:07.113] result() for ClusterFuture ...
[15:31:07.113] - result already collected: FutureResult
[15:31:07.113] result() for ClusterFuture ... done
[15:31:07.114] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:07.086] MultisessionFuture:
[15:31:07.086] Label: 'future_apply-1'
[15:31:07.086] Expression:
[15:31:07.086] {
[15:31:07.086]     do.call(function(...) {
[15:31:07.086]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:07.086]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:07.086]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:07.086]             on.exit(options(oopts), add = TRUE)
[15:31:07.086]         }
[15:31:07.086]         {
[15:31:07.086]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:07.086]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:07.086]                 ...future.FUN(...future.X_jj, ...)
[15:31:07.086]             })
[15:31:07.086]         }
[15:31:07.086]     }, args = future.call.arguments)
[15:31:07.086] }
[15:31:07.086] Lazy evaluation: FALSE
[15:31:07.086] Asynchronous evaluation: TRUE
[15:31:07.086] Local evaluation: TRUE
[15:31:07.086] Environment: R_GlobalEnv
[15:31:07.086] Capture standard output: TRUE
[15:31:07.086] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:07.086] Globals: 5 objects totaling 1.35 KiB (DotDotDotList 'future.call.arguments' of 0 bytes, function '...future.FUN' of 1.22 KiB, list '...future.elements_ii' of 80 bytes, NULL '...future.seeds_ii' of 0 bytes, numeric '...future.globals.maxSize' of 56 bytes)
[15:31:07.086] Packages: 1 packages ('stats')
[15:31:07.086] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:07.086] Resolved: TRUE
[15:31:07.086] Value: <not collected>
[15:31:07.086] Conditions captured: <none>
[15:31:07.086] Early signaling: FALSE
[15:31:07.086] Owner process: 6672a580-6d3c-e82f-380e-108c475ace70
[15:31:07.086] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:07.114] Chunk #1 of 2 ... DONE
[15:31:07.115] Chunk #2 of 2 ...
[15:31:07.115]  - Adjusted option 'future.globals.maxSize': Inf -> 2 * Inf = Inf (bytes)
[15:31:07.116]  - seeds: <none>
[15:31:07.116]  - All globals exported: [n=5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:07.116] getGlobalsAndPackages() ...
[15:31:07.116] - globals passed as-is: [5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:07.117] Resolving globals: FALSE
[15:31:07.117] Tweak future expression to call with '...' arguments ...
[15:31:07.118] {
[15:31:07.118]     do.call(function(...) {
[15:31:07.118]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:07.118]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:07.118]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:07.118]             on.exit(options(oopts), add = TRUE)
[15:31:07.118]         }
[15:31:07.118]         {
[15:31:07.118]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:07.118]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:07.118]                 ...future.FUN(...future.X_jj, ...)
[15:31:07.118]             })
[15:31:07.118]         }
[15:31:07.118]     }, args = future.call.arguments)
[15:31:07.118] }
[15:31:07.118] Tweak future expression to call with '...' arguments ... DONE
[15:31:07.119] - globals: [5] 'future.call.arguments', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:07.120] - packages: [1] 'stats'
[15:31:07.120] getGlobalsAndPackages() ... DONE
[15:31:07.121] run() for 'Future' ...
[15:31:07.121] - state: 'created'
[15:31:07.122] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:07.139] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:07.140] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:31:07.140]   - Field: 'node'
[15:31:07.140]   - Field: 'label'
[15:31:07.141]   - Field: 'local'
[15:31:07.141]   - Field: 'owner'
[15:31:07.141]   - Field: 'envir'
[15:31:07.142]   - Field: 'workers'
[15:31:07.142]   - Field: 'packages'
[15:31:07.142]   - Field: 'gc'
[15:31:07.142]   - Field: 'conditions'
[15:31:07.143]   - Field: 'persistent'
[15:31:07.143]   - Field: 'expr'
[15:31:07.143]   - Field: 'uuid'
[15:31:07.144]   - Field: 'seed'
[15:31:07.144]   - Field: 'version'
[15:31:07.144]   - Field: 'result'
[15:31:07.145]   - Field: 'asynchronous'
[15:31:07.145]   - Field: 'calls'
[15:31:07.145]   - Field: 'globals'
[15:31:07.145]   - Field: 'stdout'
[15:31:07.146]   - Field: 'earlySignal'
[15:31:07.146]   - Field: 'lazy'
[15:31:07.146]   - Field: 'state'
[15:31:07.146] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:31:07.146] - Launch lazy future ...
[15:31:07.147] Packages needed by the future expression (n = 1): 'stats'
[15:31:07.147] Packages needed by future strategies (n = 0): <none>
[15:31:07.149] {
[15:31:07.149]     {
[15:31:07.149]         {
[15:31:07.149]             ...future.startTime <- base::Sys.time()
[15:31:07.149]             {
[15:31:07.149]                 {
[15:31:07.149]                   {
[15:31:07.149]                     {
[15:31:07.149]                       {
[15:31:07.149]                         base::local({
[15:31:07.149]                           has_future <- base::requireNamespace("future", 
[15:31:07.149]                             quietly = TRUE)
[15:31:07.149]                           if (has_future) {
[15:31:07.149]                             ns <- base::getNamespace("future")
[15:31:07.149]                             version <- ns[[".package"]][["version"]]
[15:31:07.149]                             if (is.null(version)) 
[15:31:07.149]                               version <- utils::packageVersion("future")
[15:31:07.149]                           }
[15:31:07.149]                           else {
[15:31:07.149]                             version <- NULL
[15:31:07.149]                           }
[15:31:07.149]                           if (!has_future || version < "1.8.0") {
[15:31:07.149]                             info <- base::c(r_version = base::gsub("R version ", 
[15:31:07.149]                               "", base::R.version$version.string), 
[15:31:07.149]                               platform = base::sprintf("%s (%s-bit)", 
[15:31:07.149]                                 base::R.version$platform, 8 * 
[15:31:07.149]                                   base::.Machine$sizeof.pointer), 
[15:31:07.149]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:07.149]                                 "release", "version")], collapse = " "), 
[15:31:07.149]                               hostname = base::Sys.info()[["nodename"]])
[15:31:07.149]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:31:07.149]                               info)
[15:31:07.149]                             info <- base::paste(info, collapse = "; ")
[15:31:07.149]                             if (!has_future) {
[15:31:07.149]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:07.149]                                 info)
[15:31:07.149]                             }
[15:31:07.149]                             else {
[15:31:07.149]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:07.149]                                 info, version)
[15:31:07.149]                             }
[15:31:07.149]                             base::stop(msg)
[15:31:07.149]                           }
[15:31:07.149]                         })
[15:31:07.149]                       }
[15:31:07.149]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:07.149]                       base::options(mc.cores = 1L)
[15:31:07.149]                     }
[15:31:07.149]                     base::local({
[15:31:07.149]                       for (pkg in "stats") {
[15:31:07.149]                         base::loadNamespace(pkg)
[15:31:07.149]                         base::library(pkg, character.only = TRUE)
[15:31:07.149]                       }
[15:31:07.149]                     })
[15:31:07.149]                   }
[15:31:07.149]                   ...future.strategy.old <- future::plan("list")
[15:31:07.149]                   options(future.plan = NULL)
[15:31:07.149]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:07.149]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:07.149]                 }
[15:31:07.149]                 ...future.workdir <- getwd()
[15:31:07.149]             }
[15:31:07.149]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:07.149]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:07.149]         }
[15:31:07.149]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:07.149]             future.globals.maxSize = Inf, future.globals.method = NULL, 
[15:31:07.149]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:07.149]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:07.149]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:07.149]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:07.149]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:07.149]             base::names(...future.oldOptions))
[15:31:07.149]     }
[15:31:07.149]     if (FALSE) {
[15:31:07.149]     }
[15:31:07.149]     else {
[15:31:07.149]         if (TRUE) {
[15:31:07.149]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:07.149]                 open = "w")
[15:31:07.149]         }
[15:31:07.149]         else {
[15:31:07.149]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:07.149]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:07.149]         }
[15:31:07.149]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:07.149]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:07.149]             base::sink(type = "output", split = FALSE)
[15:31:07.149]             base::close(...future.stdout)
[15:31:07.149]         }, add = TRUE)
[15:31:07.149]     }
[15:31:07.149]     ...future.frame <- base::sys.nframe()
[15:31:07.149]     ...future.conditions <- base::list()
[15:31:07.149]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:07.149]     if (FALSE) {
[15:31:07.149]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:07.149]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:07.149]     }
[15:31:07.149]     ...future.result <- base::tryCatch({
[15:31:07.149]         base::withCallingHandlers({
[15:31:07.149]             ...future.value <- base::withVisible(base::local({
[15:31:07.149]                 ...future.makeSendCondition <- base::local({
[15:31:07.149]                   sendCondition <- NULL
[15:31:07.149]                   function(frame = 1L) {
[15:31:07.149]                     if (is.function(sendCondition)) 
[15:31:07.149]                       return(sendCondition)
[15:31:07.149]                     ns <- getNamespace("parallel")
[15:31:07.149]                     if (exists("sendData", mode = "function", 
[15:31:07.149]                       envir = ns)) {
[15:31:07.149]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:07.149]                         envir = ns)
[15:31:07.149]                       envir <- sys.frame(frame)
[15:31:07.149]                       master <- NULL
[15:31:07.149]                       while (!identical(envir, .GlobalEnv) && 
[15:31:07.149]                         !identical(envir, emptyenv())) {
[15:31:07.149]                         if (exists("master", mode = "list", envir = envir, 
[15:31:07.149]                           inherits = FALSE)) {
[15:31:07.149]                           master <- get("master", mode = "list", 
[15:31:07.149]                             envir = envir, inherits = FALSE)
[15:31:07.149]                           if (inherits(master, c("SOCKnode", 
[15:31:07.149]                             "SOCK0node"))) {
[15:31:07.149]                             sendCondition <<- function(cond) {
[15:31:07.149]                               data <- list(type = "VALUE", value = cond, 
[15:31:07.149]                                 success = TRUE)
[15:31:07.149]                               parallel_sendData(master, data)
[15:31:07.149]                             }
[15:31:07.149]                             return(sendCondition)
[15:31:07.149]                           }
[15:31:07.149]                         }
[15:31:07.149]                         frame <- frame + 1L
[15:31:07.149]                         envir <- sys.frame(frame)
[15:31:07.149]                       }
[15:31:07.149]                     }
[15:31:07.149]                     sendCondition <<- function(cond) NULL
[15:31:07.149]                   }
[15:31:07.149]                 })
[15:31:07.149]                 withCallingHandlers({
[15:31:07.149]                   {
[15:31:07.149]                     do.call(function(...) {
[15:31:07.149]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:07.149]                       if (!identical(...future.globals.maxSize.org, 
[15:31:07.149]                         ...future.globals.maxSize)) {
[15:31:07.149]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:07.149]                         on.exit(options(oopts), add = TRUE)
[15:31:07.149]                       }
[15:31:07.149]                       {
[15:31:07.149]                         lapply(seq_along(...future.elements_ii), 
[15:31:07.149]                           FUN = function(jj) {
[15:31:07.149]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:07.149]                             ...future.FUN(...future.X_jj, ...)
[15:31:07.149]                           })
[15:31:07.149]                       }
[15:31:07.149]                     }, args = future.call.arguments)
[15:31:07.149]                   }
[15:31:07.149]                 }, immediateCondition = function(cond) {
[15:31:07.149]                   sendCondition <- ...future.makeSendCondition()
[15:31:07.149]                   sendCondition(cond)
[15:31:07.149]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:07.149]                   {
[15:31:07.149]                     inherits <- base::inherits
[15:31:07.149]                     invokeRestart <- base::invokeRestart
[15:31:07.149]                     is.null <- base::is.null
[15:31:07.149]                     muffled <- FALSE
[15:31:07.149]                     if (inherits(cond, "message")) {
[15:31:07.149]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:07.149]                       if (muffled) 
[15:31:07.149]                         invokeRestart("muffleMessage")
[15:31:07.149]                     }
[15:31:07.149]                     else if (inherits(cond, "warning")) {
[15:31:07.149]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:07.149]                       if (muffled) 
[15:31:07.149]                         invokeRestart("muffleWarning")
[15:31:07.149]                     }
[15:31:07.149]                     else if (inherits(cond, "condition")) {
[15:31:07.149]                       if (!is.null(pattern)) {
[15:31:07.149]                         computeRestarts <- base::computeRestarts
[15:31:07.149]                         grepl <- base::grepl
[15:31:07.149]                         restarts <- computeRestarts(cond)
[15:31:07.149]                         for (restart in restarts) {
[15:31:07.149]                           name <- restart$name
[15:31:07.149]                           if (is.null(name)) 
[15:31:07.149]                             next
[15:31:07.149]                           if (!grepl(pattern, name)) 
[15:31:07.149]                             next
[15:31:07.149]                           invokeRestart(restart)
[15:31:07.149]                           muffled <- TRUE
[15:31:07.149]                           break
[15:31:07.149]                         }
[15:31:07.149]                       }
[15:31:07.149]                     }
[15:31:07.149]                     invisible(muffled)
[15:31:07.149]                   }
[15:31:07.149]                   muffleCondition(cond)
[15:31:07.149]                 })
[15:31:07.149]             }))
[15:31:07.149]             future::FutureResult(value = ...future.value$value, 
[15:31:07.149]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:07.149]                   ...future.rng), globalenv = if (FALSE) 
[15:31:07.149]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:07.149]                     ...future.globalenv.names))
[15:31:07.149]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:07.149]         }, condition = base::local({
[15:31:07.149]             c <- base::c
[15:31:07.149]             inherits <- base::inherits
[15:31:07.149]             invokeRestart <- base::invokeRestart
[15:31:07.149]             length <- base::length
[15:31:07.149]             list <- base::list
[15:31:07.149]             seq.int <- base::seq.int
[15:31:07.149]             signalCondition <- base::signalCondition
[15:31:07.149]             sys.calls <- base::sys.calls
[15:31:07.149]             `[[` <- base::`[[`
[15:31:07.149]             `+` <- base::`+`
[15:31:07.149]             `<<-` <- base::`<<-`
[15:31:07.149]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:07.149]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:07.149]                   3L)]
[15:31:07.149]             }
[15:31:07.149]             function(cond) {
[15:31:07.149]                 is_error <- inherits(cond, "error")
[15:31:07.149]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:07.149]                   NULL)
[15:31:07.149]                 if (is_error) {
[15:31:07.149]                   sessionInformation <- function() {
[15:31:07.149]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:07.149]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:07.149]                       search = base::search(), system = base::Sys.info())
[15:31:07.149]                   }
[15:31:07.149]                   ...future.conditions[[length(...future.conditions) + 
[15:31:07.149]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:07.149]                     cond$call), session = sessionInformation(), 
[15:31:07.149]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:07.149]                   signalCondition(cond)
[15:31:07.149]                 }
[15:31:07.149]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:07.149]                 "immediateCondition"))) {
[15:31:07.149]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:07.149]                   ...future.conditions[[length(...future.conditions) + 
[15:31:07.149]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:07.149]                   if (TRUE && !signal) {
[15:31:07.149]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:07.149]                     {
[15:31:07.149]                       inherits <- base::inherits
[15:31:07.149]                       invokeRestart <- base::invokeRestart
[15:31:07.149]                       is.null <- base::is.null
[15:31:07.149]                       muffled <- FALSE
[15:31:07.149]                       if (inherits(cond, "message")) {
[15:31:07.149]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:07.149]                         if (muffled) 
[15:31:07.149]                           invokeRestart("muffleMessage")
[15:31:07.149]                       }
[15:31:07.149]                       else if (inherits(cond, "warning")) {
[15:31:07.149]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:07.149]                         if (muffled) 
[15:31:07.149]                           invokeRestart("muffleWarning")
[15:31:07.149]                       }
[15:31:07.149]                       else if (inherits(cond, "condition")) {
[15:31:07.149]                         if (!is.null(pattern)) {
[15:31:07.149]                           computeRestarts <- base::computeRestarts
[15:31:07.149]                           grepl <- base::grepl
[15:31:07.149]                           restarts <- computeRestarts(cond)
[15:31:07.149]                           for (restart in restarts) {
[15:31:07.149]                             name <- restart$name
[15:31:07.149]                             if (is.null(name)) 
[15:31:07.149]                               next
[15:31:07.149]                             if (!grepl(pattern, name)) 
[15:31:07.149]                               next
[15:31:07.149]                             invokeRestart(restart)
[15:31:07.149]                             muffled <- TRUE
[15:31:07.149]                             break
[15:31:07.149]                           }
[15:31:07.149]                         }
[15:31:07.149]                       }
[15:31:07.149]                       invisible(muffled)
[15:31:07.149]                     }
[15:31:07.149]                     muffleCondition(cond, pattern = "^muffle")
[15:31:07.149]                   }
[15:31:07.149]                 }
[15:31:07.149]                 else {
[15:31:07.149]                   if (TRUE) {
[15:31:07.149]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:07.149]                     {
[15:31:07.149]                       inherits <- base::inherits
[15:31:07.149]                       invokeRestart <- base::invokeRestart
[15:31:07.149]                       is.null <- base::is.null
[15:31:07.149]                       muffled <- FALSE
[15:31:07.149]                       if (inherits(cond, "message")) {
[15:31:07.149]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:07.149]                         if (muffled) 
[15:31:07.149]                           invokeRestart("muffleMessage")
[15:31:07.149]                       }
[15:31:07.149]                       else if (inherits(cond, "warning")) {
[15:31:07.149]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:07.149]                         if (muffled) 
[15:31:07.149]                           invokeRestart("muffleWarning")
[15:31:07.149]                       }
[15:31:07.149]                       else if (inherits(cond, "condition")) {
[15:31:07.149]                         if (!is.null(pattern)) {
[15:31:07.149]                           computeRestarts <- base::computeRestarts
[15:31:07.149]                           grepl <- base::grepl
[15:31:07.149]                           restarts <- computeRestarts(cond)
[15:31:07.149]                           for (restart in restarts) {
[15:31:07.149]                             name <- restart$name
[15:31:07.149]                             if (is.null(name)) 
[15:31:07.149]                               next
[15:31:07.149]                             if (!grepl(pattern, name)) 
[15:31:07.149]                               next
[15:31:07.149]                             invokeRestart(restart)
[15:31:07.149]                             muffled <- TRUE
[15:31:07.149]                             break
[15:31:07.149]                           }
[15:31:07.149]                         }
[15:31:07.149]                       }
[15:31:07.149]                       invisible(muffled)
[15:31:07.149]                     }
[15:31:07.149]                     muffleCondition(cond, pattern = "^muffle")
[15:31:07.149]                   }
[15:31:07.149]                 }
[15:31:07.149]             }
[15:31:07.149]         }))
[15:31:07.149]     }, error = function(ex) {
[15:31:07.149]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:07.149]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:07.149]                 ...future.rng), started = ...future.startTime, 
[15:31:07.149]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:07.149]             version = "1.8"), class = "FutureResult")
[15:31:07.149]     }, finally = {
[15:31:07.149]         if (!identical(...future.workdir, getwd())) 
[15:31:07.149]             setwd(...future.workdir)
[15:31:07.149]         {
[15:31:07.149]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:07.149]                 ...future.oldOptions$nwarnings <- NULL
[15:31:07.149]             }
[15:31:07.149]             base::options(...future.oldOptions)
[15:31:07.149]             if (.Platform$OS.type == "windows") {
[15:31:07.149]                 old_names <- names(...future.oldEnvVars)
[15:31:07.149]                 envs <- base::Sys.getenv()
[15:31:07.149]                 names <- names(envs)
[15:31:07.149]                 common <- intersect(names, old_names)
[15:31:07.149]                 added <- setdiff(names, old_names)
[15:31:07.149]                 removed <- setdiff(old_names, names)
[15:31:07.149]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:07.149]                   envs[common]]
[15:31:07.149]                 NAMES <- toupper(changed)
[15:31:07.149]                 args <- list()
[15:31:07.149]                 for (kk in seq_along(NAMES)) {
[15:31:07.149]                   name <- changed[[kk]]
[15:31:07.149]                   NAME <- NAMES[[kk]]
[15:31:07.149]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:07.149]                     next
[15:31:07.149]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:07.149]                 }
[15:31:07.149]                 NAMES <- toupper(added)
[15:31:07.149]                 for (kk in seq_along(NAMES)) {
[15:31:07.149]                   name <- added[[kk]]
[15:31:07.149]                   NAME <- NAMES[[kk]]
[15:31:07.149]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:07.149]                     next
[15:31:07.149]                   args[[name]] <- ""
[15:31:07.149]                 }
[15:31:07.149]                 NAMES <- toupper(removed)
[15:31:07.149]                 for (kk in seq_along(NAMES)) {
[15:31:07.149]                   name <- removed[[kk]]
[15:31:07.149]                   NAME <- NAMES[[kk]]
[15:31:07.149]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:07.149]                     next
[15:31:07.149]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:07.149]                 }
[15:31:07.149]                 if (length(args) > 0) 
[15:31:07.149]                   base::do.call(base::Sys.setenv, args = args)
[15:31:07.149]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:07.149]             }
[15:31:07.149]             else {
[15:31:07.149]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:07.149]             }
[15:31:07.149]             {
[15:31:07.149]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:07.149]                   0L) {
[15:31:07.149]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:07.149]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:07.149]                   base::options(opts)
[15:31:07.149]                 }
[15:31:07.149]                 {
[15:31:07.149]                   {
[15:31:07.149]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:07.149]                     NULL
[15:31:07.149]                   }
[15:31:07.149]                   options(future.plan = NULL)
[15:31:07.149]                   if (is.na(NA_character_)) 
[15:31:07.149]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:07.149]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:07.149]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:07.149]                     .init = FALSE)
[15:31:07.149]                 }
[15:31:07.149]             }
[15:31:07.149]         }
[15:31:07.149]     })
[15:31:07.149]     if (TRUE) {
[15:31:07.149]         base::sink(type = "output", split = FALSE)
[15:31:07.149]         if (TRUE) {
[15:31:07.149]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:07.149]         }
[15:31:07.149]         else {
[15:31:07.149]             ...future.result["stdout"] <- base::list(NULL)
[15:31:07.149]         }
[15:31:07.149]         base::close(...future.stdout)
[15:31:07.149]         ...future.stdout <- NULL
[15:31:07.149]     }
[15:31:07.149]     ...future.result$conditions <- ...future.conditions
[15:31:07.149]     ...future.result$finished <- base::Sys.time()
[15:31:07.149]     ...future.result
[15:31:07.149] }
[15:31:07.159] Exporting 5 global objects (1.35 KiB) to cluster node #1 ...
[15:31:07.160] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:31:07.160] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:31:07.161] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:31:07.162] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:31:07.162] Exporting '...future.elements_ii' (80 bytes) to cluster node #1 ...
[15:31:07.163] Exporting '...future.elements_ii' (80 bytes) to cluster node #1 ... DONE
[15:31:07.163] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:31:07.164] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:31:07.164] Exporting '...future.globals.maxSize' (56 bytes) to cluster node #1 ...
[15:31:07.165] Exporting '...future.globals.maxSize' (56 bytes) to cluster node #1 ... DONE
[15:31:07.165] Exporting 5 global objects (1.35 KiB) to cluster node #1 ... DONE
[15:31:07.166] MultisessionFuture started
[15:31:07.167] - Launch lazy future ... done
[15:31:07.167] run() for 'MultisessionFuture' ... done
[15:31:07.167] Created future:
[15:31:07.198] receiveMessageFromWorker() for ClusterFuture ...
[15:31:07.198] - Validating connection of MultisessionFuture
[15:31:07.199] - received message: FutureResult
[15:31:07.199] - Received FutureResult
[15:31:07.199] - Erased future from FutureRegistry
[15:31:07.200] result() for ClusterFuture ...
[15:31:07.200] - result already collected: FutureResult
[15:31:07.200] result() for ClusterFuture ... done
[15:31:07.200] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:07.168] MultisessionFuture:
[15:31:07.168] Label: 'future_apply-2'
[15:31:07.168] Expression:
[15:31:07.168] {
[15:31:07.168]     do.call(function(...) {
[15:31:07.168]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:07.168]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:07.168]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:07.168]             on.exit(options(oopts), add = TRUE)
[15:31:07.168]         }
[15:31:07.168]         {
[15:31:07.168]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:07.168]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:07.168]                 ...future.FUN(...future.X_jj, ...)
[15:31:07.168]             })
[15:31:07.168]         }
[15:31:07.168]     }, args = future.call.arguments)
[15:31:07.168] }
[15:31:07.168] Lazy evaluation: FALSE
[15:31:07.168] Asynchronous evaluation: TRUE
[15:31:07.168] Local evaluation: TRUE
[15:31:07.168] Environment: R_GlobalEnv
[15:31:07.168] Capture standard output: TRUE
[15:31:07.168] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:07.168] Globals: 5 objects totaling 1.35 KiB (DotDotDotList 'future.call.arguments' of 0 bytes, function '...future.FUN' of 1.22 KiB, list '...future.elements_ii' of 80 bytes, NULL '...future.seeds_ii' of 0 bytes, numeric '...future.globals.maxSize' of 56 bytes)
[15:31:07.168] Packages: 1 packages ('stats')
[15:31:07.168] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:07.168] Resolved: TRUE
[15:31:07.168] Value: <not collected>
[15:31:07.168] Conditions captured: <none>
[15:31:07.168] Early signaling: FALSE
[15:31:07.168] Owner process: 6672a580-6d3c-e82f-380e-108c475ace70
[15:31:07.168] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:07.201] Chunk #2 of 2 ... DONE
[15:31:07.201] Launching 2 futures (chunks) ... DONE
[15:31:07.202] Resolving 2 futures (chunks) ...
[15:31:07.202] resolve() on list ...
[15:31:07.202]  recursive: 0
[15:31:07.202]  length: 2
[15:31:07.203] 
[15:31:07.203] Future #1
[15:31:07.203] result() for ClusterFuture ...
[15:31:07.203] - result already collected: FutureResult
[15:31:07.204] result() for ClusterFuture ... done
[15:31:07.204] result() for ClusterFuture ...
[15:31:07.204] - result already collected: FutureResult
[15:31:07.204] result() for ClusterFuture ... done
[15:31:07.204] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:31:07.205] - nx: 2
[15:31:07.205] - relay: TRUE
[15:31:07.205] - stdout: TRUE
[15:31:07.205] - signal: TRUE
[15:31:07.205] - resignal: FALSE
[15:31:07.205] - force: TRUE
[15:31:07.206] - relayed: [n=2] FALSE, FALSE
[15:31:07.206] - queued futures: [n=2] FALSE, FALSE
[15:31:07.206]  - until=1
[15:31:07.206]  - relaying element #1
[15:31:07.206] result() for ClusterFuture ...
[15:31:07.206] - result already collected: FutureResult
[15:31:07.207] result() for ClusterFuture ... done
[15:31:07.207] result() for ClusterFuture ...
[15:31:07.207] - result already collected: FutureResult
[15:31:07.207] result() for ClusterFuture ... done
[15:31:07.207] result() for ClusterFuture ...
[15:31:07.207] - result already collected: FutureResult
[15:31:07.208] result() for ClusterFuture ... done
[15:31:07.208] result() for ClusterFuture ...
[15:31:07.208] - result already collected: FutureResult
[15:31:07.208] result() for ClusterFuture ... done
[15:31:07.208] - relayed: [n=2] TRUE, FALSE
[15:31:07.208] - queued futures: [n=2] TRUE, FALSE
[15:31:07.208] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:31:07.209]  length: 1 (resolved future 1)
[15:31:07.209] Future #2
[15:31:07.209] result() for ClusterFuture ...
[15:31:07.209] - result already collected: FutureResult
[15:31:07.209] result() for ClusterFuture ... done
[15:31:07.210] result() for ClusterFuture ...
[15:31:07.210] - result already collected: FutureResult
[15:31:07.210] result() for ClusterFuture ... done
[15:31:07.210] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:31:07.210] - nx: 2
[15:31:07.210] - relay: TRUE
[15:31:07.210] - stdout: TRUE
[15:31:07.211] - signal: TRUE
[15:31:07.211] - resignal: FALSE
[15:31:07.211] - force: TRUE
[15:31:07.211] - relayed: [n=2] TRUE, FALSE
[15:31:07.211] - queued futures: [n=2] TRUE, FALSE
[15:31:07.211]  - until=2
[15:31:07.212]  - relaying element #2
[15:31:07.212] result() for ClusterFuture ...
[15:31:07.212] - result already collected: FutureResult
[15:31:07.212] result() for ClusterFuture ... done
[15:31:07.212] result() for ClusterFuture ...
[15:31:07.212] - result already collected: FutureResult
[15:31:07.213] result() for ClusterFuture ... done
[15:31:07.213] result() for ClusterFuture ...
[15:31:07.213] - result already collected: FutureResult
[15:31:07.213] result() for ClusterFuture ... done
[15:31:07.213] result() for ClusterFuture ...
[15:31:07.213] - result already collected: FutureResult
[15:31:07.214] result() for ClusterFuture ... done
[15:31:07.214] - relayed: [n=2] TRUE, TRUE
[15:31:07.214] - queued futures: [n=2] TRUE, TRUE
[15:31:07.214] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:31:07.214]  length: 0 (resolved future 2)
[15:31:07.214] Relaying remaining futures
[15:31:07.215] signalConditionsASAP(NULL, pos=0) ...
[15:31:07.215] - nx: 2
[15:31:07.215] - relay: TRUE
[15:31:07.215] - stdout: TRUE
[15:31:07.215] - signal: TRUE
[15:31:07.215] - resignal: FALSE
[15:31:07.215] - force: TRUE
[15:31:07.216] - relayed: [n=2] TRUE, TRUE
[15:31:07.216] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:31:07.216] - relayed: [n=2] TRUE, TRUE
[15:31:07.216] - queued futures: [n=2] TRUE, TRUE
[15:31:07.216] signalConditionsASAP(NULL, pos=0) ... done
[15:31:07.217] resolve() on list ... DONE
[15:31:07.217] result() for ClusterFuture ...
[15:31:07.217] - result already collected: FutureResult
[15:31:07.217] result() for ClusterFuture ... done
[15:31:07.217] result() for ClusterFuture ...
[15:31:07.218] - result already collected: FutureResult
[15:31:07.218] result() for ClusterFuture ... done
[15:31:07.218] result() for ClusterFuture ...
[15:31:07.218] - result already collected: FutureResult
[15:31:07.218] result() for ClusterFuture ... done
[15:31:07.218] result() for ClusterFuture ...
[15:31:07.219] - result already collected: FutureResult
[15:31:07.219] result() for ClusterFuture ... done
[15:31:07.219]  - Number of value chunks collected: 2
[15:31:07.219] Resolving 2 futures (chunks) ... DONE
[15:31:07.219] Reducing values from 2 chunks ...
[15:31:07.219]  - Number of values collected after concatenation: 2
[15:31:07.220]  - Number of values expected: 2
[15:31:07.220] Reducing values from 2 chunks ... DONE
[15:31:07.220] future_lapply() ... DONE
     [,1] [,2]
0%      1  2.0
25%     1  3.5
50%     2  5.0
75%     4  6.5
100%    7  8.0
[15:31:07.221] getGlobalsAndPackagesXApply() ...
[15:31:07.221]  - future.globals: TRUE
[15:31:07.221] getGlobalsAndPackages() ...
[15:31:07.221] Searching for globals...
[15:31:07.223] - globals found: [1] 'FUN'
[15:31:07.224] Searching for globals ... DONE
[15:31:07.224] Resolving globals: FALSE
[15:31:07.224] The total size of the 1 globals is 848 bytes (848 bytes)
[15:31:07.225] The total size of the 1 globals exported for future expression ('FUN(X = structure(c(3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 2, 1, 2, 3,; 4, 5), dim = c(8L, 2L), dimnames = list(row = NULL, col = c("x1",; "x2"))))') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:31:07.225] - globals: [1] 'FUN'
[15:31:07.226] 
[15:31:07.226] getGlobalsAndPackages() ... DONE
[15:31:07.226]  - globals found/used: [n=1] 'FUN'
[15:31:07.226]  - needed namespaces: [n=0] 
[15:31:07.226] Finding globals ... DONE
[15:31:07.226]  - use_args: TRUE
[15:31:07.227]  - Getting '...' globals ...
[15:31:07.227] resolve() on list ...
[15:31:07.227]  recursive: 0
[15:31:07.227]  length: 1
[15:31:07.227]  elements: '...'
[15:31:07.228]  length: 0 (resolved future 1)
[15:31:07.228] resolve() on list ... DONE
[15:31:07.228]    - '...' content: [n=0] 
[15:31:07.228] List of 1
[15:31:07.228]  $ ...: list()
[15:31:07.228]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:07.228]  - attr(*, "where")=List of 1
[15:31:07.228]   ..$ ...:<environment: 0x000001bcbe925060> 
[15:31:07.228]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:07.228]  - attr(*, "resolved")= logi TRUE
[15:31:07.228]  - attr(*, "total_size")= num NA
[15:31:07.232]  - Getting '...' globals ... DONE
[15:31:07.232] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:07.232] List of 2
[15:31:07.232]  $ ...future.FUN:function (x)  
[15:31:07.232]  $ ...          : list()
[15:31:07.232]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:07.232]  - attr(*, "where")=List of 2
[15:31:07.232]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:07.232]   ..$ ...          :<environment: 0x000001bcbe925060> 
[15:31:07.232]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:07.232]  - attr(*, "resolved")= logi FALSE
[15:31:07.232]  - attr(*, "total_size")= num 848
[15:31:07.236] Packages to be attached in all futures: [n=0] 
[15:31:07.236] getGlobalsAndPackagesXApply() ... DONE
[15:31:07.239] future_lapply() ...
[15:31:07.243] Number of chunks: 2
[15:31:07.243] getGlobalsAndPackagesXApply() ...
[15:31:07.243]  - future.globals: <name-value list> with names 'list()'
[15:31:07.243]  - use_args: TRUE
[15:31:07.244] Globals to be used in all futures (chunks): [n=2] '...', '...future.FUN'
[15:31:07.244] List of 2
[15:31:07.244]  $ ...          : list()
[15:31:07.244]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:07.244]  $ ...future.FUN:function (x)  
[15:31:07.244]  - attr(*, "where")=List of 2
[15:31:07.244]   ..$ ...          :<environment: 0x000001bcbe925060> 
[15:31:07.244]   ..$ ...future.FUN:<environment: namespace:base> 
[15:31:07.244]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:07.244]  - attr(*, "resolved")= logi FALSE
[15:31:07.244]  - attr(*, "total_size")= num NA
[15:31:07.249] Packages to be attached in all futures: [n=0] 
[15:31:07.249] getGlobalsAndPackagesXApply() ... DONE
[15:31:07.249] Number of futures (= number of chunks): 2
[15:31:07.250] Launching 2 futures (chunks) ...
[15:31:07.250] Chunk #1 of 2 ...
[15:31:07.250]  - Adjusted option 'future.globals.maxSize': Inf -> 2 * Inf = Inf (bytes)
[15:31:07.251]  - seeds: <none>
[15:31:07.251]  - All globals exported: [n=5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:07.251] getGlobalsAndPackages() ...
[15:31:07.254] - globals passed as-is: [5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:07.255] Resolving globals: FALSE
[15:31:07.255] Tweak future expression to call with '...' arguments ...
[15:31:07.255] {
[15:31:07.255]     do.call(function(...) {
[15:31:07.255]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:07.255]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:07.255]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:07.255]             on.exit(options(oopts), add = TRUE)
[15:31:07.255]         }
[15:31:07.255]         {
[15:31:07.255]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:07.255]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:07.255]                 ...future.FUN(...future.X_jj, ...)
[15:31:07.255]             })
[15:31:07.255]         }
[15:31:07.255]     }, args = future.call.arguments)
[15:31:07.255] }
[15:31:07.256] Tweak future expression to call with '...' arguments ... DONE
[15:31:07.257] - globals: [5] 'future.call.arguments', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:07.257] 
[15:31:07.257] getGlobalsAndPackages() ... DONE
[15:31:07.258] run() for 'Future' ...
[15:31:07.258] - state: 'created'
[15:31:07.258] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:07.276] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:07.276] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:31:07.277]   - Field: 'node'
[15:31:07.277]   - Field: 'label'
[15:31:07.277]   - Field: 'local'
[15:31:07.278]   - Field: 'owner'
[15:31:07.278]   - Field: 'envir'
[15:31:07.278]   - Field: 'workers'
[15:31:07.278]   - Field: 'packages'
[15:31:07.279]   - Field: 'gc'
[15:31:07.279]   - Field: 'conditions'
[15:31:07.279]   - Field: 'persistent'
[15:31:07.280]   - Field: 'expr'
[15:31:07.280]   - Field: 'uuid'
[15:31:07.280]   - Field: 'seed'
[15:31:07.281]   - Field: 'version'
[15:31:07.281]   - Field: 'result'
[15:31:07.281]   - Field: 'asynchronous'
[15:31:07.282]   - Field: 'calls'
[15:31:07.282]   - Field: 'globals'
[15:31:07.282]   - Field: 'stdout'
[15:31:07.282]   - Field: 'earlySignal'
[15:31:07.283]   - Field: 'lazy'
[15:31:07.283]   - Field: 'state'
[15:31:07.283] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:31:07.284] - Launch lazy future ...
[15:31:07.284] Packages needed by the future expression (n = 0): <none>
[15:31:07.285] Packages needed by future strategies (n = 0): <none>
[15:31:07.286] {
[15:31:07.286]     {
[15:31:07.286]         {
[15:31:07.286]             ...future.startTime <- base::Sys.time()
[15:31:07.286]             {
[15:31:07.286]                 {
[15:31:07.286]                   {
[15:31:07.286]                     {
[15:31:07.286]                       base::local({
[15:31:07.286]                         has_future <- base::requireNamespace("future", 
[15:31:07.286]                           quietly = TRUE)
[15:31:07.286]                         if (has_future) {
[15:31:07.286]                           ns <- base::getNamespace("future")
[15:31:07.286]                           version <- ns[[".package"]][["version"]]
[15:31:07.286]                           if (is.null(version)) 
[15:31:07.286]                             version <- utils::packageVersion("future")
[15:31:07.286]                         }
[15:31:07.286]                         else {
[15:31:07.286]                           version <- NULL
[15:31:07.286]                         }
[15:31:07.286]                         if (!has_future || version < "1.8.0") {
[15:31:07.286]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:07.286]                             "", base::R.version$version.string), 
[15:31:07.286]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:07.286]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:07.286]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:07.286]                               "release", "version")], collapse = " "), 
[15:31:07.286]                             hostname = base::Sys.info()[["nodename"]])
[15:31:07.286]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:07.286]                             info)
[15:31:07.286]                           info <- base::paste(info, collapse = "; ")
[15:31:07.286]                           if (!has_future) {
[15:31:07.286]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:07.286]                               info)
[15:31:07.286]                           }
[15:31:07.286]                           else {
[15:31:07.286]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:07.286]                               info, version)
[15:31:07.286]                           }
[15:31:07.286]                           base::stop(msg)
[15:31:07.286]                         }
[15:31:07.286]                       })
[15:31:07.286]                     }
[15:31:07.286]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:07.286]                     base::options(mc.cores = 1L)
[15:31:07.286]                   }
[15:31:07.286]                   ...future.strategy.old <- future::plan("list")
[15:31:07.286]                   options(future.plan = NULL)
[15:31:07.286]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:07.286]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:07.286]                 }
[15:31:07.286]                 ...future.workdir <- getwd()
[15:31:07.286]             }
[15:31:07.286]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:07.286]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:07.286]         }
[15:31:07.286]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:07.286]             future.globals.maxSize = Inf, future.globals.method = NULL, 
[15:31:07.286]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:07.286]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:07.286]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:07.286]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:07.286]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:07.286]             base::names(...future.oldOptions))
[15:31:07.286]     }
[15:31:07.286]     if (FALSE) {
[15:31:07.286]     }
[15:31:07.286]     else {
[15:31:07.286]         if (TRUE) {
[15:31:07.286]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:07.286]                 open = "w")
[15:31:07.286]         }
[15:31:07.286]         else {
[15:31:07.286]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:07.286]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:07.286]         }
[15:31:07.286]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:07.286]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:07.286]             base::sink(type = "output", split = FALSE)
[15:31:07.286]             base::close(...future.stdout)
[15:31:07.286]         }, add = TRUE)
[15:31:07.286]     }
[15:31:07.286]     ...future.frame <- base::sys.nframe()
[15:31:07.286]     ...future.conditions <- base::list()
[15:31:07.286]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:07.286]     if (FALSE) {
[15:31:07.286]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:07.286]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:07.286]     }
[15:31:07.286]     ...future.result <- base::tryCatch({
[15:31:07.286]         base::withCallingHandlers({
[15:31:07.286]             ...future.value <- base::withVisible(base::local({
[15:31:07.286]                 ...future.makeSendCondition <- base::local({
[15:31:07.286]                   sendCondition <- NULL
[15:31:07.286]                   function(frame = 1L) {
[15:31:07.286]                     if (is.function(sendCondition)) 
[15:31:07.286]                       return(sendCondition)
[15:31:07.286]                     ns <- getNamespace("parallel")
[15:31:07.286]                     if (exists("sendData", mode = "function", 
[15:31:07.286]                       envir = ns)) {
[15:31:07.286]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:07.286]                         envir = ns)
[15:31:07.286]                       envir <- sys.frame(frame)
[15:31:07.286]                       master <- NULL
[15:31:07.286]                       while (!identical(envir, .GlobalEnv) && 
[15:31:07.286]                         !identical(envir, emptyenv())) {
[15:31:07.286]                         if (exists("master", mode = "list", envir = envir, 
[15:31:07.286]                           inherits = FALSE)) {
[15:31:07.286]                           master <- get("master", mode = "list", 
[15:31:07.286]                             envir = envir, inherits = FALSE)
[15:31:07.286]                           if (inherits(master, c("SOCKnode", 
[15:31:07.286]                             "SOCK0node"))) {
[15:31:07.286]                             sendCondition <<- function(cond) {
[15:31:07.286]                               data <- list(type = "VALUE", value = cond, 
[15:31:07.286]                                 success = TRUE)
[15:31:07.286]                               parallel_sendData(master, data)
[15:31:07.286]                             }
[15:31:07.286]                             return(sendCondition)
[15:31:07.286]                           }
[15:31:07.286]                         }
[15:31:07.286]                         frame <- frame + 1L
[15:31:07.286]                         envir <- sys.frame(frame)
[15:31:07.286]                       }
[15:31:07.286]                     }
[15:31:07.286]                     sendCondition <<- function(cond) NULL
[15:31:07.286]                   }
[15:31:07.286]                 })
[15:31:07.286]                 withCallingHandlers({
[15:31:07.286]                   {
[15:31:07.286]                     do.call(function(...) {
[15:31:07.286]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:07.286]                       if (!identical(...future.globals.maxSize.org, 
[15:31:07.286]                         ...future.globals.maxSize)) {
[15:31:07.286]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:07.286]                         on.exit(options(oopts), add = TRUE)
[15:31:07.286]                       }
[15:31:07.286]                       {
[15:31:07.286]                         lapply(seq_along(...future.elements_ii), 
[15:31:07.286]                           FUN = function(jj) {
[15:31:07.286]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:07.286]                             ...future.FUN(...future.X_jj, ...)
[15:31:07.286]                           })
[15:31:07.286]                       }
[15:31:07.286]                     }, args = future.call.arguments)
[15:31:07.286]                   }
[15:31:07.286]                 }, immediateCondition = function(cond) {
[15:31:07.286]                   sendCondition <- ...future.makeSendCondition()
[15:31:07.286]                   sendCondition(cond)
[15:31:07.286]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:07.286]                   {
[15:31:07.286]                     inherits <- base::inherits
[15:31:07.286]                     invokeRestart <- base::invokeRestart
[15:31:07.286]                     is.null <- base::is.null
[15:31:07.286]                     muffled <- FALSE
[15:31:07.286]                     if (inherits(cond, "message")) {
[15:31:07.286]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:07.286]                       if (muffled) 
[15:31:07.286]                         invokeRestart("muffleMessage")
[15:31:07.286]                     }
[15:31:07.286]                     else if (inherits(cond, "warning")) {
[15:31:07.286]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:07.286]                       if (muffled) 
[15:31:07.286]                         invokeRestart("muffleWarning")
[15:31:07.286]                     }
[15:31:07.286]                     else if (inherits(cond, "condition")) {
[15:31:07.286]                       if (!is.null(pattern)) {
[15:31:07.286]                         computeRestarts <- base::computeRestarts
[15:31:07.286]                         grepl <- base::grepl
[15:31:07.286]                         restarts <- computeRestarts(cond)
[15:31:07.286]                         for (restart in restarts) {
[15:31:07.286]                           name <- restart$name
[15:31:07.286]                           if (is.null(name)) 
[15:31:07.286]                             next
[15:31:07.286]                           if (!grepl(pattern, name)) 
[15:31:07.286]                             next
[15:31:07.286]                           invokeRestart(restart)
[15:31:07.286]                           muffled <- TRUE
[15:31:07.286]                           break
[15:31:07.286]                         }
[15:31:07.286]                       }
[15:31:07.286]                     }
[15:31:07.286]                     invisible(muffled)
[15:31:07.286]                   }
[15:31:07.286]                   muffleCondition(cond)
[15:31:07.286]                 })
[15:31:07.286]             }))
[15:31:07.286]             future::FutureResult(value = ...future.value$value, 
[15:31:07.286]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:07.286]                   ...future.rng), globalenv = if (FALSE) 
[15:31:07.286]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:07.286]                     ...future.globalenv.names))
[15:31:07.286]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:07.286]         }, condition = base::local({
[15:31:07.286]             c <- base::c
[15:31:07.286]             inherits <- base::inherits
[15:31:07.286]             invokeRestart <- base::invokeRestart
[15:31:07.286]             length <- base::length
[15:31:07.286]             list <- base::list
[15:31:07.286]             seq.int <- base::seq.int
[15:31:07.286]             signalCondition <- base::signalCondition
[15:31:07.286]             sys.calls <- base::sys.calls
[15:31:07.286]             `[[` <- base::`[[`
[15:31:07.286]             `+` <- base::`+`
[15:31:07.286]             `<<-` <- base::`<<-`
[15:31:07.286]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:07.286]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:07.286]                   3L)]
[15:31:07.286]             }
[15:31:07.286]             function(cond) {
[15:31:07.286]                 is_error <- inherits(cond, "error")
[15:31:07.286]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:07.286]                   NULL)
[15:31:07.286]                 if (is_error) {
[15:31:07.286]                   sessionInformation <- function() {
[15:31:07.286]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:07.286]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:07.286]                       search = base::search(), system = base::Sys.info())
[15:31:07.286]                   }
[15:31:07.286]                   ...future.conditions[[length(...future.conditions) + 
[15:31:07.286]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:07.286]                     cond$call), session = sessionInformation(), 
[15:31:07.286]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:07.286]                   signalCondition(cond)
[15:31:07.286]                 }
[15:31:07.286]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:07.286]                 "immediateCondition"))) {
[15:31:07.286]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:07.286]                   ...future.conditions[[length(...future.conditions) + 
[15:31:07.286]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:07.286]                   if (TRUE && !signal) {
[15:31:07.286]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:07.286]                     {
[15:31:07.286]                       inherits <- base::inherits
[15:31:07.286]                       invokeRestart <- base::invokeRestart
[15:31:07.286]                       is.null <- base::is.null
[15:31:07.286]                       muffled <- FALSE
[15:31:07.286]                       if (inherits(cond, "message")) {
[15:31:07.286]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:07.286]                         if (muffled) 
[15:31:07.286]                           invokeRestart("muffleMessage")
[15:31:07.286]                       }
[15:31:07.286]                       else if (inherits(cond, "warning")) {
[15:31:07.286]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:07.286]                         if (muffled) 
[15:31:07.286]                           invokeRestart("muffleWarning")
[15:31:07.286]                       }
[15:31:07.286]                       else if (inherits(cond, "condition")) {
[15:31:07.286]                         if (!is.null(pattern)) {
[15:31:07.286]                           computeRestarts <- base::computeRestarts
[15:31:07.286]                           grepl <- base::grepl
[15:31:07.286]                           restarts <- computeRestarts(cond)
[15:31:07.286]                           for (restart in restarts) {
[15:31:07.286]                             name <- restart$name
[15:31:07.286]                             if (is.null(name)) 
[15:31:07.286]                               next
[15:31:07.286]                             if (!grepl(pattern, name)) 
[15:31:07.286]                               next
[15:31:07.286]                             invokeRestart(restart)
[15:31:07.286]                             muffled <- TRUE
[15:31:07.286]                             break
[15:31:07.286]                           }
[15:31:07.286]                         }
[15:31:07.286]                       }
[15:31:07.286]                       invisible(muffled)
[15:31:07.286]                     }
[15:31:07.286]                     muffleCondition(cond, pattern = "^muffle")
[15:31:07.286]                   }
[15:31:07.286]                 }
[15:31:07.286]                 else {
[15:31:07.286]                   if (TRUE) {
[15:31:07.286]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:07.286]                     {
[15:31:07.286]                       inherits <- base::inherits
[15:31:07.286]                       invokeRestart <- base::invokeRestart
[15:31:07.286]                       is.null <- base::is.null
[15:31:07.286]                       muffled <- FALSE
[15:31:07.286]                       if (inherits(cond, "message")) {
[15:31:07.286]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:07.286]                         if (muffled) 
[15:31:07.286]                           invokeRestart("muffleMessage")
[15:31:07.286]                       }
[15:31:07.286]                       else if (inherits(cond, "warning")) {
[15:31:07.286]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:07.286]                         if (muffled) 
[15:31:07.286]                           invokeRestart("muffleWarning")
[15:31:07.286]                       }
[15:31:07.286]                       else if (inherits(cond, "condition")) {
[15:31:07.286]                         if (!is.null(pattern)) {
[15:31:07.286]                           computeRestarts <- base::computeRestarts
[15:31:07.286]                           grepl <- base::grepl
[15:31:07.286]                           restarts <- computeRestarts(cond)
[15:31:07.286]                           for (restart in restarts) {
[15:31:07.286]                             name <- restart$name
[15:31:07.286]                             if (is.null(name)) 
[15:31:07.286]                               next
[15:31:07.286]                             if (!grepl(pattern, name)) 
[15:31:07.286]                               next
[15:31:07.286]                             invokeRestart(restart)
[15:31:07.286]                             muffled <- TRUE
[15:31:07.286]                             break
[15:31:07.286]                           }
[15:31:07.286]                         }
[15:31:07.286]                       }
[15:31:07.286]                       invisible(muffled)
[15:31:07.286]                     }
[15:31:07.286]                     muffleCondition(cond, pattern = "^muffle")
[15:31:07.286]                   }
[15:31:07.286]                 }
[15:31:07.286]             }
[15:31:07.286]         }))
[15:31:07.286]     }, error = function(ex) {
[15:31:07.286]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:07.286]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:07.286]                 ...future.rng), started = ...future.startTime, 
[15:31:07.286]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:07.286]             version = "1.8"), class = "FutureResult")
[15:31:07.286]     }, finally = {
[15:31:07.286]         if (!identical(...future.workdir, getwd())) 
[15:31:07.286]             setwd(...future.workdir)
[15:31:07.286]         {
[15:31:07.286]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:07.286]                 ...future.oldOptions$nwarnings <- NULL
[15:31:07.286]             }
[15:31:07.286]             base::options(...future.oldOptions)
[15:31:07.286]             if (.Platform$OS.type == "windows") {
[15:31:07.286]                 old_names <- names(...future.oldEnvVars)
[15:31:07.286]                 envs <- base::Sys.getenv()
[15:31:07.286]                 names <- names(envs)
[15:31:07.286]                 common <- intersect(names, old_names)
[15:31:07.286]                 added <- setdiff(names, old_names)
[15:31:07.286]                 removed <- setdiff(old_names, names)
[15:31:07.286]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:07.286]                   envs[common]]
[15:31:07.286]                 NAMES <- toupper(changed)
[15:31:07.286]                 args <- list()
[15:31:07.286]                 for (kk in seq_along(NAMES)) {
[15:31:07.286]                   name <- changed[[kk]]
[15:31:07.286]                   NAME <- NAMES[[kk]]
[15:31:07.286]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:07.286]                     next
[15:31:07.286]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:07.286]                 }
[15:31:07.286]                 NAMES <- toupper(added)
[15:31:07.286]                 for (kk in seq_along(NAMES)) {
[15:31:07.286]                   name <- added[[kk]]
[15:31:07.286]                   NAME <- NAMES[[kk]]
[15:31:07.286]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:07.286]                     next
[15:31:07.286]                   args[[name]] <- ""
[15:31:07.286]                 }
[15:31:07.286]                 NAMES <- toupper(removed)
[15:31:07.286]                 for (kk in seq_along(NAMES)) {
[15:31:07.286]                   name <- removed[[kk]]
[15:31:07.286]                   NAME <- NAMES[[kk]]
[15:31:07.286]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:07.286]                     next
[15:31:07.286]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:07.286]                 }
[15:31:07.286]                 if (length(args) > 0) 
[15:31:07.286]                   base::do.call(base::Sys.setenv, args = args)
[15:31:07.286]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:07.286]             }
[15:31:07.286]             else {
[15:31:07.286]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:07.286]             }
[15:31:07.286]             {
[15:31:07.286]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:07.286]                   0L) {
[15:31:07.286]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:07.286]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:07.286]                   base::options(opts)
[15:31:07.286]                 }
[15:31:07.286]                 {
[15:31:07.286]                   {
[15:31:07.286]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:07.286]                     NULL
[15:31:07.286]                   }
[15:31:07.286]                   options(future.plan = NULL)
[15:31:07.286]                   if (is.na(NA_character_)) 
[15:31:07.286]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:07.286]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:07.286]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:07.286]                     .init = FALSE)
[15:31:07.286]                 }
[15:31:07.286]             }
[15:31:07.286]         }
[15:31:07.286]     })
[15:31:07.286]     if (TRUE) {
[15:31:07.286]         base::sink(type = "output", split = FALSE)
[15:31:07.286]         if (TRUE) {
[15:31:07.286]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:07.286]         }
[15:31:07.286]         else {
[15:31:07.286]             ...future.result["stdout"] <- base::list(NULL)
[15:31:07.286]         }
[15:31:07.286]         base::close(...future.stdout)
[15:31:07.286]         ...future.stdout <- NULL
[15:31:07.286]     }
[15:31:07.286]     ...future.result$conditions <- ...future.conditions
[15:31:07.286]     ...future.result$finished <- base::Sys.time()
[15:31:07.286]     ...future.result
[15:31:07.286] }
[15:31:07.296] Exporting 5 global objects (0.99 KiB) to cluster node #1 ...
[15:31:07.296] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:31:07.297] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:31:07.297] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:31:07.298] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:31:07.298] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:31:07.299] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:31:07.299] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:31:07.300] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:31:07.300] Exporting '...future.globals.maxSize' (56 bytes) to cluster node #1 ...
[15:31:07.301] Exporting '...future.globals.maxSize' (56 bytes) to cluster node #1 ... DONE
[15:31:07.301] Exporting 5 global objects (0.99 KiB) to cluster node #1 ... DONE
[15:31:07.302] MultisessionFuture started
[15:31:07.302] - Launch lazy future ... done
[15:31:07.303] run() for 'MultisessionFuture' ... done
[15:31:07.303] Created future:
[15:31:07.334] receiveMessageFromWorker() for ClusterFuture ...
[15:31:07.334] - Validating connection of MultisessionFuture
[15:31:07.335] - received message: FutureResult
[15:31:07.335] - Received FutureResult
[15:31:07.336] - Erased future from FutureRegistry
[15:31:07.336] result() for ClusterFuture ...
[15:31:07.336] - result already collected: FutureResult
[15:31:07.336] result() for ClusterFuture ... done
[15:31:07.337] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:07.303] MultisessionFuture:
[15:31:07.303] Label: 'future_apply-1'
[15:31:07.303] Expression:
[15:31:07.303] {
[15:31:07.303]     do.call(function(...) {
[15:31:07.303]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:07.303]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:07.303]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:07.303]             on.exit(options(oopts), add = TRUE)
[15:31:07.303]         }
[15:31:07.303]         {
[15:31:07.303]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:07.303]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:07.303]                 ...future.FUN(...future.X_jj, ...)
[15:31:07.303]             })
[15:31:07.303]         }
[15:31:07.303]     }, args = future.call.arguments)
[15:31:07.303] }
[15:31:07.303] Lazy evaluation: FALSE
[15:31:07.303] Asynchronous evaluation: TRUE
[15:31:07.303] Local evaluation: TRUE
[15:31:07.303] Environment: R_GlobalEnv
[15:31:07.303] Capture standard output: TRUE
[15:31:07.303] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:07.303] Globals: 5 objects totaling 0.99 KiB (DotDotDotList 'future.call.arguments' of 0 bytes, function '...future.FUN' of 848 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, numeric '...future.globals.maxSize' of 56 bytes)
[15:31:07.303] Packages: <none>
[15:31:07.303] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:07.303] Resolved: TRUE
[15:31:07.303] Value: <not collected>
[15:31:07.303] Conditions captured: <none>
[15:31:07.303] Early signaling: FALSE
[15:31:07.303] Owner process: 6672a580-6d3c-e82f-380e-108c475ace70
[15:31:07.303] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:07.337] Chunk #1 of 2 ... DONE
[15:31:07.338] Chunk #2 of 2 ...
[15:31:07.338]  - Adjusted option 'future.globals.maxSize': Inf -> 2 * Inf = Inf (bytes)
[15:31:07.338]  - seeds: <none>
[15:31:07.339]  - All globals exported: [n=5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:07.339] getGlobalsAndPackages() ...
[15:31:07.339] - globals passed as-is: [5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:07.340] Resolving globals: FALSE
[15:31:07.340] Tweak future expression to call with '...' arguments ...
[15:31:07.340] {
[15:31:07.340]     do.call(function(...) {
[15:31:07.340]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:07.340]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:07.340]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:07.340]             on.exit(options(oopts), add = TRUE)
[15:31:07.340]         }
[15:31:07.340]         {
[15:31:07.340]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:07.340]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:07.340]                 ...future.FUN(...future.X_jj, ...)
[15:31:07.340]             })
[15:31:07.340]         }
[15:31:07.340]     }, args = future.call.arguments)
[15:31:07.340] }
[15:31:07.341] Tweak future expression to call with '...' arguments ... DONE
[15:31:07.342] - globals: [5] 'future.call.arguments', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:07.342] 
[15:31:07.342] getGlobalsAndPackages() ... DONE
[15:31:07.343] run() for 'Future' ...
[15:31:07.343] - state: 'created'
[15:31:07.344] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:07.363] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:07.364] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:31:07.364]   - Field: 'node'
[15:31:07.365]   - Field: 'label'
[15:31:07.365]   - Field: 'local'
[15:31:07.365]   - Field: 'owner'
[15:31:07.365]   - Field: 'envir'
[15:31:07.366]   - Field: 'workers'
[15:31:07.366]   - Field: 'packages'
[15:31:07.366]   - Field: 'gc'
[15:31:07.367]   - Field: 'conditions'
[15:31:07.367]   - Field: 'persistent'
[15:31:07.367]   - Field: 'expr'
[15:31:07.367]   - Field: 'uuid'
[15:31:07.368]   - Field: 'seed'
[15:31:07.368]   - Field: 'version'
[15:31:07.368]   - Field: 'result'
[15:31:07.368]   - Field: 'asynchronous'
[15:31:07.369]   - Field: 'calls'
[15:31:07.369]   - Field: 'globals'
[15:31:07.369]   - Field: 'stdout'
[15:31:07.370]   - Field: 'earlySignal'
[15:31:07.370]   - Field: 'lazy'
[15:31:07.370]   - Field: 'state'
[15:31:07.370] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:31:07.371] - Launch lazy future ...
[15:31:07.371] Packages needed by the future expression (n = 0): <none>
[15:31:07.372] Packages needed by future strategies (n = 0): <none>
[15:31:07.372] {
[15:31:07.372]     {
[15:31:07.372]         {
[15:31:07.372]             ...future.startTime <- base::Sys.time()
[15:31:07.372]             {
[15:31:07.372]                 {
[15:31:07.372]                   {
[15:31:07.372]                     {
[15:31:07.372]                       base::local({
[15:31:07.372]                         has_future <- base::requireNamespace("future", 
[15:31:07.372]                           quietly = TRUE)
[15:31:07.372]                         if (has_future) {
[15:31:07.372]                           ns <- base::getNamespace("future")
[15:31:07.372]                           version <- ns[[".package"]][["version"]]
[15:31:07.372]                           if (is.null(version)) 
[15:31:07.372]                             version <- utils::packageVersion("future")
[15:31:07.372]                         }
[15:31:07.372]                         else {
[15:31:07.372]                           version <- NULL
[15:31:07.372]                         }
[15:31:07.372]                         if (!has_future || version < "1.8.0") {
[15:31:07.372]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:07.372]                             "", base::R.version$version.string), 
[15:31:07.372]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:07.372]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:07.372]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:07.372]                               "release", "version")], collapse = " "), 
[15:31:07.372]                             hostname = base::Sys.info()[["nodename"]])
[15:31:07.372]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:07.372]                             info)
[15:31:07.372]                           info <- base::paste(info, collapse = "; ")
[15:31:07.372]                           if (!has_future) {
[15:31:07.372]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:07.372]                               info)
[15:31:07.372]                           }
[15:31:07.372]                           else {
[15:31:07.372]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:07.372]                               info, version)
[15:31:07.372]                           }
[15:31:07.372]                           base::stop(msg)
[15:31:07.372]                         }
[15:31:07.372]                       })
[15:31:07.372]                     }
[15:31:07.372]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:07.372]                     base::options(mc.cores = 1L)
[15:31:07.372]                   }
[15:31:07.372]                   ...future.strategy.old <- future::plan("list")
[15:31:07.372]                   options(future.plan = NULL)
[15:31:07.372]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:07.372]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:07.372]                 }
[15:31:07.372]                 ...future.workdir <- getwd()
[15:31:07.372]             }
[15:31:07.372]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:07.372]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:07.372]         }
[15:31:07.372]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:07.372]             future.globals.maxSize = Inf, future.globals.method = NULL, 
[15:31:07.372]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:07.372]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:07.372]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:07.372]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:07.372]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:07.372]             base::names(...future.oldOptions))
[15:31:07.372]     }
[15:31:07.372]     if (FALSE) {
[15:31:07.372]     }
[15:31:07.372]     else {
[15:31:07.372]         if (TRUE) {
[15:31:07.372]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:07.372]                 open = "w")
[15:31:07.372]         }
[15:31:07.372]         else {
[15:31:07.372]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:07.372]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:07.372]         }
[15:31:07.372]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:07.372]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:07.372]             base::sink(type = "output", split = FALSE)
[15:31:07.372]             base::close(...future.stdout)
[15:31:07.372]         }, add = TRUE)
[15:31:07.372]     }
[15:31:07.372]     ...future.frame <- base::sys.nframe()
[15:31:07.372]     ...future.conditions <- base::list()
[15:31:07.372]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:07.372]     if (FALSE) {
[15:31:07.372]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:07.372]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:07.372]     }
[15:31:07.372]     ...future.result <- base::tryCatch({
[15:31:07.372]         base::withCallingHandlers({
[15:31:07.372]             ...future.value <- base::withVisible(base::local({
[15:31:07.372]                 ...future.makeSendCondition <- base::local({
[15:31:07.372]                   sendCondition <- NULL
[15:31:07.372]                   function(frame = 1L) {
[15:31:07.372]                     if (is.function(sendCondition)) 
[15:31:07.372]                       return(sendCondition)
[15:31:07.372]                     ns <- getNamespace("parallel")
[15:31:07.372]                     if (exists("sendData", mode = "function", 
[15:31:07.372]                       envir = ns)) {
[15:31:07.372]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:07.372]                         envir = ns)
[15:31:07.372]                       envir <- sys.frame(frame)
[15:31:07.372]                       master <- NULL
[15:31:07.372]                       while (!identical(envir, .GlobalEnv) && 
[15:31:07.372]                         !identical(envir, emptyenv())) {
[15:31:07.372]                         if (exists("master", mode = "list", envir = envir, 
[15:31:07.372]                           inherits = FALSE)) {
[15:31:07.372]                           master <- get("master", mode = "list", 
[15:31:07.372]                             envir = envir, inherits = FALSE)
[15:31:07.372]                           if (inherits(master, c("SOCKnode", 
[15:31:07.372]                             "SOCK0node"))) {
[15:31:07.372]                             sendCondition <<- function(cond) {
[15:31:07.372]                               data <- list(type = "VALUE", value = cond, 
[15:31:07.372]                                 success = TRUE)
[15:31:07.372]                               parallel_sendData(master, data)
[15:31:07.372]                             }
[15:31:07.372]                             return(sendCondition)
[15:31:07.372]                           }
[15:31:07.372]                         }
[15:31:07.372]                         frame <- frame + 1L
[15:31:07.372]                         envir <- sys.frame(frame)
[15:31:07.372]                       }
[15:31:07.372]                     }
[15:31:07.372]                     sendCondition <<- function(cond) NULL
[15:31:07.372]                   }
[15:31:07.372]                 })
[15:31:07.372]                 withCallingHandlers({
[15:31:07.372]                   {
[15:31:07.372]                     do.call(function(...) {
[15:31:07.372]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:07.372]                       if (!identical(...future.globals.maxSize.org, 
[15:31:07.372]                         ...future.globals.maxSize)) {
[15:31:07.372]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:07.372]                         on.exit(options(oopts), add = TRUE)
[15:31:07.372]                       }
[15:31:07.372]                       {
[15:31:07.372]                         lapply(seq_along(...future.elements_ii), 
[15:31:07.372]                           FUN = function(jj) {
[15:31:07.372]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:07.372]                             ...future.FUN(...future.X_jj, ...)
[15:31:07.372]                           })
[15:31:07.372]                       }
[15:31:07.372]                     }, args = future.call.arguments)
[15:31:07.372]                   }
[15:31:07.372]                 }, immediateCondition = function(cond) {
[15:31:07.372]                   sendCondition <- ...future.makeSendCondition()
[15:31:07.372]                   sendCondition(cond)
[15:31:07.372]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:07.372]                   {
[15:31:07.372]                     inherits <- base::inherits
[15:31:07.372]                     invokeRestart <- base::invokeRestart
[15:31:07.372]                     is.null <- base::is.null
[15:31:07.372]                     muffled <- FALSE
[15:31:07.372]                     if (inherits(cond, "message")) {
[15:31:07.372]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:07.372]                       if (muffled) 
[15:31:07.372]                         invokeRestart("muffleMessage")
[15:31:07.372]                     }
[15:31:07.372]                     else if (inherits(cond, "warning")) {
[15:31:07.372]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:07.372]                       if (muffled) 
[15:31:07.372]                         invokeRestart("muffleWarning")
[15:31:07.372]                     }
[15:31:07.372]                     else if (inherits(cond, "condition")) {
[15:31:07.372]                       if (!is.null(pattern)) {
[15:31:07.372]                         computeRestarts <- base::computeRestarts
[15:31:07.372]                         grepl <- base::grepl
[15:31:07.372]                         restarts <- computeRestarts(cond)
[15:31:07.372]                         for (restart in restarts) {
[15:31:07.372]                           name <- restart$name
[15:31:07.372]                           if (is.null(name)) 
[15:31:07.372]                             next
[15:31:07.372]                           if (!grepl(pattern, name)) 
[15:31:07.372]                             next
[15:31:07.372]                           invokeRestart(restart)
[15:31:07.372]                           muffled <- TRUE
[15:31:07.372]                           break
[15:31:07.372]                         }
[15:31:07.372]                       }
[15:31:07.372]                     }
[15:31:07.372]                     invisible(muffled)
[15:31:07.372]                   }
[15:31:07.372]                   muffleCondition(cond)
[15:31:07.372]                 })
[15:31:07.372]             }))
[15:31:07.372]             future::FutureResult(value = ...future.value$value, 
[15:31:07.372]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:07.372]                   ...future.rng), globalenv = if (FALSE) 
[15:31:07.372]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:07.372]                     ...future.globalenv.names))
[15:31:07.372]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:07.372]         }, condition = base::local({
[15:31:07.372]             c <- base::c
[15:31:07.372]             inherits <- base::inherits
[15:31:07.372]             invokeRestart <- base::invokeRestart
[15:31:07.372]             length <- base::length
[15:31:07.372]             list <- base::list
[15:31:07.372]             seq.int <- base::seq.int
[15:31:07.372]             signalCondition <- base::signalCondition
[15:31:07.372]             sys.calls <- base::sys.calls
[15:31:07.372]             `[[` <- base::`[[`
[15:31:07.372]             `+` <- base::`+`
[15:31:07.372]             `<<-` <- base::`<<-`
[15:31:07.372]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:07.372]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:07.372]                   3L)]
[15:31:07.372]             }
[15:31:07.372]             function(cond) {
[15:31:07.372]                 is_error <- inherits(cond, "error")
[15:31:07.372]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:07.372]                   NULL)
[15:31:07.372]                 if (is_error) {
[15:31:07.372]                   sessionInformation <- function() {
[15:31:07.372]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:07.372]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:07.372]                       search = base::search(), system = base::Sys.info())
[15:31:07.372]                   }
[15:31:07.372]                   ...future.conditions[[length(...future.conditions) + 
[15:31:07.372]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:07.372]                     cond$call), session = sessionInformation(), 
[15:31:07.372]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:07.372]                   signalCondition(cond)
[15:31:07.372]                 }
[15:31:07.372]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:07.372]                 "immediateCondition"))) {
[15:31:07.372]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:07.372]                   ...future.conditions[[length(...future.conditions) + 
[15:31:07.372]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:07.372]                   if (TRUE && !signal) {
[15:31:07.372]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:07.372]                     {
[15:31:07.372]                       inherits <- base::inherits
[15:31:07.372]                       invokeRestart <- base::invokeRestart
[15:31:07.372]                       is.null <- base::is.null
[15:31:07.372]                       muffled <- FALSE
[15:31:07.372]                       if (inherits(cond, "message")) {
[15:31:07.372]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:07.372]                         if (muffled) 
[15:31:07.372]                           invokeRestart("muffleMessage")
[15:31:07.372]                       }
[15:31:07.372]                       else if (inherits(cond, "warning")) {
[15:31:07.372]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:07.372]                         if (muffled) 
[15:31:07.372]                           invokeRestart("muffleWarning")
[15:31:07.372]                       }
[15:31:07.372]                       else if (inherits(cond, "condition")) {
[15:31:07.372]                         if (!is.null(pattern)) {
[15:31:07.372]                           computeRestarts <- base::computeRestarts
[15:31:07.372]                           grepl <- base::grepl
[15:31:07.372]                           restarts <- computeRestarts(cond)
[15:31:07.372]                           for (restart in restarts) {
[15:31:07.372]                             name <- restart$name
[15:31:07.372]                             if (is.null(name)) 
[15:31:07.372]                               next
[15:31:07.372]                             if (!grepl(pattern, name)) 
[15:31:07.372]                               next
[15:31:07.372]                             invokeRestart(restart)
[15:31:07.372]                             muffled <- TRUE
[15:31:07.372]                             break
[15:31:07.372]                           }
[15:31:07.372]                         }
[15:31:07.372]                       }
[15:31:07.372]                       invisible(muffled)
[15:31:07.372]                     }
[15:31:07.372]                     muffleCondition(cond, pattern = "^muffle")
[15:31:07.372]                   }
[15:31:07.372]                 }
[15:31:07.372]                 else {
[15:31:07.372]                   if (TRUE) {
[15:31:07.372]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:07.372]                     {
[15:31:07.372]                       inherits <- base::inherits
[15:31:07.372]                       invokeRestart <- base::invokeRestart
[15:31:07.372]                       is.null <- base::is.null
[15:31:07.372]                       muffled <- FALSE
[15:31:07.372]                       if (inherits(cond, "message")) {
[15:31:07.372]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:07.372]                         if (muffled) 
[15:31:07.372]                           invokeRestart("muffleMessage")
[15:31:07.372]                       }
[15:31:07.372]                       else if (inherits(cond, "warning")) {
[15:31:07.372]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:07.372]                         if (muffled) 
[15:31:07.372]                           invokeRestart("muffleWarning")
[15:31:07.372]                       }
[15:31:07.372]                       else if (inherits(cond, "condition")) {
[15:31:07.372]                         if (!is.null(pattern)) {
[15:31:07.372]                           computeRestarts <- base::computeRestarts
[15:31:07.372]                           grepl <- base::grepl
[15:31:07.372]                           restarts <- computeRestarts(cond)
[15:31:07.372]                           for (restart in restarts) {
[15:31:07.372]                             name <- restart$name
[15:31:07.372]                             if (is.null(name)) 
[15:31:07.372]                               next
[15:31:07.372]                             if (!grepl(pattern, name)) 
[15:31:07.372]                               next
[15:31:07.372]                             invokeRestart(restart)
[15:31:07.372]                             muffled <- TRUE
[15:31:07.372]                             break
[15:31:07.372]                           }
[15:31:07.372]                         }
[15:31:07.372]                       }
[15:31:07.372]                       invisible(muffled)
[15:31:07.372]                     }
[15:31:07.372]                     muffleCondition(cond, pattern = "^muffle")
[15:31:07.372]                   }
[15:31:07.372]                 }
[15:31:07.372]             }
[15:31:07.372]         }))
[15:31:07.372]     }, error = function(ex) {
[15:31:07.372]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:07.372]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:07.372]                 ...future.rng), started = ...future.startTime, 
[15:31:07.372]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:07.372]             version = "1.8"), class = "FutureResult")
[15:31:07.372]     }, finally = {
[15:31:07.372]         if (!identical(...future.workdir, getwd())) 
[15:31:07.372]             setwd(...future.workdir)
[15:31:07.372]         {
[15:31:07.372]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:07.372]                 ...future.oldOptions$nwarnings <- NULL
[15:31:07.372]             }
[15:31:07.372]             base::options(...future.oldOptions)
[15:31:07.372]             if (.Platform$OS.type == "windows") {
[15:31:07.372]                 old_names <- names(...future.oldEnvVars)
[15:31:07.372]                 envs <- base::Sys.getenv()
[15:31:07.372]                 names <- names(envs)
[15:31:07.372]                 common <- intersect(names, old_names)
[15:31:07.372]                 added <- setdiff(names, old_names)
[15:31:07.372]                 removed <- setdiff(old_names, names)
[15:31:07.372]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:07.372]                   envs[common]]
[15:31:07.372]                 NAMES <- toupper(changed)
[15:31:07.372]                 args <- list()
[15:31:07.372]                 for (kk in seq_along(NAMES)) {
[15:31:07.372]                   name <- changed[[kk]]
[15:31:07.372]                   NAME <- NAMES[[kk]]
[15:31:07.372]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:07.372]                     next
[15:31:07.372]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:07.372]                 }
[15:31:07.372]                 NAMES <- toupper(added)
[15:31:07.372]                 for (kk in seq_along(NAMES)) {
[15:31:07.372]                   name <- added[[kk]]
[15:31:07.372]                   NAME <- NAMES[[kk]]
[15:31:07.372]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:07.372]                     next
[15:31:07.372]                   args[[name]] <- ""
[15:31:07.372]                 }
[15:31:07.372]                 NAMES <- toupper(removed)
[15:31:07.372]                 for (kk in seq_along(NAMES)) {
[15:31:07.372]                   name <- removed[[kk]]
[15:31:07.372]                   NAME <- NAMES[[kk]]
[15:31:07.372]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:07.372]                     next
[15:31:07.372]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:07.372]                 }
[15:31:07.372]                 if (length(args) > 0) 
[15:31:07.372]                   base::do.call(base::Sys.setenv, args = args)
[15:31:07.372]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:07.372]             }
[15:31:07.372]             else {
[15:31:07.372]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:07.372]             }
[15:31:07.372]             {
[15:31:07.372]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:07.372]                   0L) {
[15:31:07.372]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:07.372]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:07.372]                   base::options(opts)
[15:31:07.372]                 }
[15:31:07.372]                 {
[15:31:07.372]                   {
[15:31:07.372]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:07.372]                     NULL
[15:31:07.372]                   }
[15:31:07.372]                   options(future.plan = NULL)
[15:31:07.372]                   if (is.na(NA_character_)) 
[15:31:07.372]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:07.372]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:07.372]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:07.372]                     .init = FALSE)
[15:31:07.372]                 }
[15:31:07.372]             }
[15:31:07.372]         }
[15:31:07.372]     })
[15:31:07.372]     if (TRUE) {
[15:31:07.372]         base::sink(type = "output", split = FALSE)
[15:31:07.372]         if (TRUE) {
[15:31:07.372]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:07.372]         }
[15:31:07.372]         else {
[15:31:07.372]             ...future.result["stdout"] <- base::list(NULL)
[15:31:07.372]         }
[15:31:07.372]         base::close(...future.stdout)
[15:31:07.372]         ...future.stdout <- NULL
[15:31:07.372]     }
[15:31:07.372]     ...future.result$conditions <- ...future.conditions
[15:31:07.372]     ...future.result$finished <- base::Sys.time()
[15:31:07.372]     ...future.result
[15:31:07.372] }
[15:31:07.382] Exporting 5 global objects (0.99 KiB) to cluster node #1 ...
[15:31:07.383] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:31:07.383] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:31:07.384] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:31:07.384] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:31:07.385] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ...
[15:31:07.385] Exporting '...future.elements_ii' (112 bytes) to cluster node #1 ... DONE
[15:31:07.385] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:31:07.386] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:31:07.386] Exporting '...future.globals.maxSize' (56 bytes) to cluster node #1 ...
[15:31:07.387] Exporting '...future.globals.maxSize' (56 bytes) to cluster node #1 ... DONE
[15:31:07.387] Exporting 5 global objects (0.99 KiB) to cluster node #1 ... DONE
[15:31:07.388] MultisessionFuture started
[15:31:07.389] - Launch lazy future ... done
[15:31:07.389] run() for 'MultisessionFuture' ... done
[15:31:07.389] Created future:
[15:31:07.414] receiveMessageFromWorker() for ClusterFuture ...
[15:31:07.414] - Validating connection of MultisessionFuture
[15:31:07.415] - received message: FutureResult
[15:31:07.415] - Received FutureResult
[15:31:07.415] - Erased future from FutureRegistry
[15:31:07.416] result() for ClusterFuture ...
[15:31:07.416] - result already collected: FutureResult
[15:31:07.416] result() for ClusterFuture ... done
[15:31:07.416] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:07.389] MultisessionFuture:
[15:31:07.389] Label: 'future_apply-2'
[15:31:07.389] Expression:
[15:31:07.389] {
[15:31:07.389]     do.call(function(...) {
[15:31:07.389]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:07.389]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:07.389]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:07.389]             on.exit(options(oopts), add = TRUE)
[15:31:07.389]         }
[15:31:07.389]         {
[15:31:07.389]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:07.389]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:07.389]                 ...future.FUN(...future.X_jj, ...)
[15:31:07.389]             })
[15:31:07.389]         }
[15:31:07.389]     }, args = future.call.arguments)
[15:31:07.389] }
[15:31:07.389] Lazy evaluation: FALSE
[15:31:07.389] Asynchronous evaluation: TRUE
[15:31:07.389] Local evaluation: TRUE
[15:31:07.389] Environment: R_GlobalEnv
[15:31:07.389] Capture standard output: TRUE
[15:31:07.389] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:07.389] Globals: 5 objects totaling 0.99 KiB (DotDotDotList 'future.call.arguments' of 0 bytes, function '...future.FUN' of 848 bytes, list '...future.elements_ii' of 112 bytes, NULL '...future.seeds_ii' of 0 bytes, numeric '...future.globals.maxSize' of 56 bytes)
[15:31:07.389] Packages: <none>
[15:31:07.389] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:07.389] Resolved: TRUE
[15:31:07.389] Value: <not collected>
[15:31:07.389] Conditions captured: <none>
[15:31:07.389] Early signaling: FALSE
[15:31:07.389] Owner process: 6672a580-6d3c-e82f-380e-108c475ace70
[15:31:07.389] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:07.417] Chunk #2 of 2 ... DONE
[15:31:07.417] Launching 2 futures (chunks) ... DONE
[15:31:07.417] Resolving 2 futures (chunks) ...
[15:31:07.417] resolve() on list ...
[15:31:07.417]  recursive: 0
[15:31:07.418]  length: 2
[15:31:07.418] 
[15:31:07.418] Future #1
[15:31:07.418] result() for ClusterFuture ...
[15:31:07.419] - result already collected: FutureResult
[15:31:07.419] result() for ClusterFuture ... done
[15:31:07.419] result() for ClusterFuture ...
[15:31:07.420] - result already collected: FutureResult
[15:31:07.420] result() for ClusterFuture ... done
[15:31:07.421] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:31:07.421] - nx: 2
[15:31:07.421] - relay: TRUE
[15:31:07.422] - stdout: TRUE
[15:31:07.422] - signal: TRUE
[15:31:07.422] - resignal: FALSE
[15:31:07.423] - force: TRUE
[15:31:07.423] - relayed: [n=2] FALSE, FALSE
[15:31:07.423] - queued futures: [n=2] FALSE, FALSE
[15:31:07.424]  - until=1
[15:31:07.424]  - relaying element #1
[15:31:07.424] result() for ClusterFuture ...
[15:31:07.425] - result already collected: FutureResult
[15:31:07.425] result() for ClusterFuture ... done
[15:31:07.425] result() for ClusterFuture ...
[15:31:07.426] - result already collected: FutureResult
[15:31:07.426] result() for ClusterFuture ... done
[15:31:07.426] result() for ClusterFuture ...
[15:31:07.427] - result already collected: FutureResult
[15:31:07.427] result() for ClusterFuture ... done
[15:31:07.427] result() for ClusterFuture ...
[15:31:07.428] - result already collected: FutureResult
[15:31:07.428] result() for ClusterFuture ... done
[15:31:07.428] - relayed: [n=2] TRUE, FALSE
[15:31:07.429] - queued futures: [n=2] TRUE, FALSE
[15:31:07.429] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:31:07.430]  length: 1 (resolved future 1)
[15:31:07.430] Future #2
[15:31:07.430] result() for ClusterFuture ...
[15:31:07.431] - result already collected: FutureResult
[15:31:07.431] result() for ClusterFuture ... done
[15:31:07.431] result() for ClusterFuture ...
[15:31:07.432] - result already collected: FutureResult
[15:31:07.432] result() for ClusterFuture ... done
[15:31:07.432] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:31:07.433] - nx: 2
[15:31:07.433] - relay: TRUE
[15:31:07.433] - stdout: TRUE
[15:31:07.434] - signal: TRUE
[15:31:07.434] - resignal: FALSE
[15:31:07.434] - force: TRUE
[15:31:07.435] - relayed: [n=2] TRUE, FALSE
[15:31:07.435] - queued futures: [n=2] TRUE, FALSE
[15:31:07.435]  - until=2
[15:31:07.436]  - relaying element #2
[15:31:07.436] result() for ClusterFuture ...
[15:31:07.436] - result already collected: FutureResult
[15:31:07.437] result() for ClusterFuture ... done
[15:31:07.437] result() for ClusterFuture ...
[15:31:07.437] - result already collected: FutureResult
[15:31:07.438] result() for ClusterFuture ... done
[15:31:07.438] result() for ClusterFuture ...
[15:31:07.439] - result already collected: FutureResult
[15:31:07.439] result() for ClusterFuture ... done
[15:31:07.439] result() for ClusterFuture ...
[15:31:07.440] - result already collected: FutureResult
[15:31:07.440] result() for ClusterFuture ... done
[15:31:07.440] - relayed: [n=2] TRUE, TRUE
[15:31:07.441] - queued futures: [n=2] TRUE, TRUE
[15:31:07.441] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:31:07.441]  length: 0 (resolved future 2)
[15:31:07.442] Relaying remaining futures
[15:31:07.442] signalConditionsASAP(NULL, pos=0) ...
[15:31:07.442] - nx: 2
[15:31:07.443] - relay: TRUE
[15:31:07.443] - stdout: TRUE
[15:31:07.443] - signal: TRUE
[15:31:07.444] - resignal: FALSE
[15:31:07.444] - force: TRUE
[15:31:07.444] - relayed: [n=2] TRUE, TRUE
[15:31:07.445] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:31:07.445] - relayed: [n=2] TRUE, TRUE
[15:31:07.446] - queued futures: [n=2] TRUE, TRUE
[15:31:07.446] signalConditionsASAP(NULL, pos=0) ... done
[15:31:07.446] resolve() on list ... DONE
[15:31:07.447] result() for ClusterFuture ...
[15:31:07.447] - result already collected: FutureResult
[15:31:07.447] result() for ClusterFuture ... done
[15:31:07.448] result() for ClusterFuture ...
[15:31:07.448] - result already collected: FutureResult
[15:31:07.448] result() for ClusterFuture ... done
[15:31:07.449] result() for ClusterFuture ...
[15:31:07.449] - result already collected: FutureResult
[15:31:07.449] result() for ClusterFuture ... done
[15:31:07.450] result() for ClusterFuture ...
[15:31:07.450] - result already collected: FutureResult
[15:31:07.450] result() for ClusterFuture ... done
[15:31:07.451]  - Number of value chunks collected: 2
[15:31:07.451] Resolving 2 futures (chunks) ... DONE
[15:31:07.451] Reducing values from 2 chunks ...
[15:31:07.452]  - Number of values collected after concatenation: 2
[15:31:07.452]  - Number of values expected: 2
[15:31:07.452] Reducing values from 2 chunks ... DONE
[15:31:07.453] future_lapply() ... DONE
      col
row    x1 x2
  [1,]  3  4
  [2,]  3  3
  [3,]  3  2
  [4,]  3  1
  [5,]  3  2
  [6,]  3  3
  [7,]  3  4
  [8,]  3  5
[15:31:07.454] getGlobalsAndPackagesXApply() ...
[15:31:07.454]  - future.globals: TRUE
[15:31:07.454] getGlobalsAndPackages() ...
[15:31:07.455] Searching for globals...
[15:31:07.458] - globals found: [1] 'FUN'
[15:31:07.458] Searching for globals ... DONE
[15:31:07.458] Resolving globals: FALSE
[15:31:07.459] The total size of the 1 globals is 848 bytes (848 bytes)
[15:31:07.460] The total size of the 1 globals exported for future expression ('FUN(X = structure(c(3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 2, 1, 2, 3,; 4, 5, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 2, 1, 2, 3, 4, 5, 3, 3, 3,; 3, 3, 3, 3, 3, 4, 3, 2, 1, 2, 3, 4, 5), dim = c(8L, 2L, 3L), dimnames = list(; row = NULL, col = c("x1", "x2"), C = c("cop.1", "cop.2",; "cop.3"))))') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:31:07.461] - globals: [1] 'FUN'
[15:31:07.461] 
[15:31:07.461] getGlobalsAndPackages() ... DONE
[15:31:07.462]  - globals found/used: [n=1] 'FUN'
[15:31:07.462]  - needed namespaces: [n=0] 
[15:31:07.462] Finding globals ... DONE
[15:31:07.463]  - use_args: TRUE
[15:31:07.463]  - Getting '...' globals ...
[15:31:07.464] resolve() on list ...
[15:31:07.464]  recursive: 0
[15:31:07.465]  length: 1
[15:31:07.465]  elements: '...'
[15:31:07.466]  length: 0 (resolved future 1)
[15:31:07.466] resolve() on list ... DONE
[15:31:07.466]    - '...' content: [n=0] 
[15:31:07.467] List of 1
[15:31:07.467]  $ ...: list()
[15:31:07.467]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:07.467]  - attr(*, "where")=List of 1
[15:31:07.467]   ..$ ...:<environment: 0x000001bcbdc20ff0> 
[15:31:07.467]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:07.467]  - attr(*, "resolved")= logi TRUE
[15:31:07.467]  - attr(*, "total_size")= num NA
[15:31:07.473]  - Getting '...' globals ... DONE
[15:31:07.474] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:07.474] List of 2
[15:31:07.474]  $ ...future.FUN:function (x)  
[15:31:07.474]  $ ...          : list()
[15:31:07.474]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:07.474]  - attr(*, "where")=List of 2
[15:31:07.474]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:07.474]   ..$ ...          :<environment: 0x000001bcbdc20ff0> 
[15:31:07.474]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:07.474]  - attr(*, "resolved")= logi FALSE
[15:31:07.474]  - attr(*, "total_size")= num 848
[15:31:07.481] Packages to be attached in all futures: [n=0] 
[15:31:07.481] getGlobalsAndPackagesXApply() ... DONE
[15:31:07.486] future_lapply() ...
[15:31:07.492] Number of chunks: 2
[15:31:07.492] getGlobalsAndPackagesXApply() ...
[15:31:07.493]  - future.globals: <name-value list> with names 'list()'
[15:31:07.493]  - use_args: TRUE
[15:31:07.494] Globals to be used in all futures (chunks): [n=2] '...', '...future.FUN'
[15:31:07.494] List of 2
[15:31:07.494]  $ ...          : list()
[15:31:07.494]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:07.494]  $ ...future.FUN:function (x)  
[15:31:07.494]  - attr(*, "where")=List of 2
[15:31:07.494]   ..$ ...          :<environment: 0x000001bcbdc20ff0> 
[15:31:07.494]   ..$ ...future.FUN:<environment: namespace:base> 
[15:31:07.494]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:07.494]  - attr(*, "resolved")= logi FALSE
[15:31:07.494]  - attr(*, "total_size")= num NA
[15:31:07.503] Packages to be attached in all futures: [n=0] 
[15:31:07.503] getGlobalsAndPackagesXApply() ... DONE
[15:31:07.504] Number of futures (= number of chunks): 2
[15:31:07.504] Launching 2 futures (chunks) ...
[15:31:07.505] Chunk #1 of 2 ...
[15:31:07.505]  - Adjusted option 'future.globals.maxSize': Inf -> 2 * Inf = Inf (bytes)
[15:31:07.505]  - seeds: <none>
[15:31:07.506]  - All globals exported: [n=5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:07.506] getGlobalsAndPackages() ...
[15:31:07.507] - globals passed as-is: [5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:07.507] Resolving globals: FALSE
[15:31:07.507] Tweak future expression to call with '...' arguments ...
[15:31:07.508] {
[15:31:07.508]     do.call(function(...) {
[15:31:07.508]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:07.508]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:07.508]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:07.508]             on.exit(options(oopts), add = TRUE)
[15:31:07.508]         }
[15:31:07.508]         {
[15:31:07.508]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:07.508]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:07.508]                 ...future.FUN(...future.X_jj, ...)
[15:31:07.508]             })
[15:31:07.508]         }
[15:31:07.508]     }, args = future.call.arguments)
[15:31:07.508] }
[15:31:07.509] Tweak future expression to call with '...' arguments ... DONE
[15:31:07.510] - globals: [5] 'future.call.arguments', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:07.510] 
[15:31:07.511] getGlobalsAndPackages() ... DONE
[15:31:07.511] run() for 'Future' ...
[15:31:07.512] - state: 'created'
[15:31:07.512] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:07.534] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:07.535] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:31:07.535]   - Field: 'node'
[15:31:07.536]   - Field: 'label'
[15:31:07.536]   - Field: 'local'
[15:31:07.536]   - Field: 'owner'
[15:31:07.537]   - Field: 'envir'
[15:31:07.537]   - Field: 'workers'
[15:31:07.537]   - Field: 'packages'
[15:31:07.538]   - Field: 'gc'
[15:31:07.538]   - Field: 'conditions'
[15:31:07.539]   - Field: 'persistent'
[15:31:07.539]   - Field: 'expr'
[15:31:07.539]   - Field: 'uuid'
[15:31:07.540]   - Field: 'seed'
[15:31:07.540]   - Field: 'version'
[15:31:07.541]   - Field: 'result'
[15:31:07.541]   - Field: 'asynchronous'
[15:31:07.541]   - Field: 'calls'
[15:31:07.542]   - Field: 'globals'
[15:31:07.542]   - Field: 'stdout'
[15:31:07.542]   - Field: 'earlySignal'
[15:31:07.543]   - Field: 'lazy'
[15:31:07.543]   - Field: 'state'
[15:31:07.544] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:31:07.544] - Launch lazy future ...
[15:31:07.545] Packages needed by the future expression (n = 0): <none>
[15:31:07.545] Packages needed by future strategies (n = 0): <none>
[15:31:07.546] {
[15:31:07.546]     {
[15:31:07.546]         {
[15:31:07.546]             ...future.startTime <- base::Sys.time()
[15:31:07.546]             {
[15:31:07.546]                 {
[15:31:07.546]                   {
[15:31:07.546]                     {
[15:31:07.546]                       base::local({
[15:31:07.546]                         has_future <- base::requireNamespace("future", 
[15:31:07.546]                           quietly = TRUE)
[15:31:07.546]                         if (has_future) {
[15:31:07.546]                           ns <- base::getNamespace("future")
[15:31:07.546]                           version <- ns[[".package"]][["version"]]
[15:31:07.546]                           if (is.null(version)) 
[15:31:07.546]                             version <- utils::packageVersion("future")
[15:31:07.546]                         }
[15:31:07.546]                         else {
[15:31:07.546]                           version <- NULL
[15:31:07.546]                         }
[15:31:07.546]                         if (!has_future || version < "1.8.0") {
[15:31:07.546]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:07.546]                             "", base::R.version$version.string), 
[15:31:07.546]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:07.546]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:07.546]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:07.546]                               "release", "version")], collapse = " "), 
[15:31:07.546]                             hostname = base::Sys.info()[["nodename"]])
[15:31:07.546]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:07.546]                             info)
[15:31:07.546]                           info <- base::paste(info, collapse = "; ")
[15:31:07.546]                           if (!has_future) {
[15:31:07.546]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:07.546]                               info)
[15:31:07.546]                           }
[15:31:07.546]                           else {
[15:31:07.546]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:07.546]                               info, version)
[15:31:07.546]                           }
[15:31:07.546]                           base::stop(msg)
[15:31:07.546]                         }
[15:31:07.546]                       })
[15:31:07.546]                     }
[15:31:07.546]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:07.546]                     base::options(mc.cores = 1L)
[15:31:07.546]                   }
[15:31:07.546]                   ...future.strategy.old <- future::plan("list")
[15:31:07.546]                   options(future.plan = NULL)
[15:31:07.546]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:07.546]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:07.546]                 }
[15:31:07.546]                 ...future.workdir <- getwd()
[15:31:07.546]             }
[15:31:07.546]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:07.546]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:07.546]         }
[15:31:07.546]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:07.546]             future.globals.maxSize = Inf, future.globals.method = NULL, 
[15:31:07.546]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:07.546]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:07.546]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:07.546]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:07.546]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:07.546]             base::names(...future.oldOptions))
[15:31:07.546]     }
[15:31:07.546]     if (FALSE) {
[15:31:07.546]     }
[15:31:07.546]     else {
[15:31:07.546]         if (TRUE) {
[15:31:07.546]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:07.546]                 open = "w")
[15:31:07.546]         }
[15:31:07.546]         else {
[15:31:07.546]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:07.546]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:07.546]         }
[15:31:07.546]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:07.546]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:07.546]             base::sink(type = "output", split = FALSE)
[15:31:07.546]             base::close(...future.stdout)
[15:31:07.546]         }, add = TRUE)
[15:31:07.546]     }
[15:31:07.546]     ...future.frame <- base::sys.nframe()
[15:31:07.546]     ...future.conditions <- base::list()
[15:31:07.546]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:07.546]     if (FALSE) {
[15:31:07.546]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:07.546]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:07.546]     }
[15:31:07.546]     ...future.result <- base::tryCatch({
[15:31:07.546]         base::withCallingHandlers({
[15:31:07.546]             ...future.value <- base::withVisible(base::local({
[15:31:07.546]                 ...future.makeSendCondition <- base::local({
[15:31:07.546]                   sendCondition <- NULL
[15:31:07.546]                   function(frame = 1L) {
[15:31:07.546]                     if (is.function(sendCondition)) 
[15:31:07.546]                       return(sendCondition)
[15:31:07.546]                     ns <- getNamespace("parallel")
[15:31:07.546]                     if (exists("sendData", mode = "function", 
[15:31:07.546]                       envir = ns)) {
[15:31:07.546]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:07.546]                         envir = ns)
[15:31:07.546]                       envir <- sys.frame(frame)
[15:31:07.546]                       master <- NULL
[15:31:07.546]                       while (!identical(envir, .GlobalEnv) && 
[15:31:07.546]                         !identical(envir, emptyenv())) {
[15:31:07.546]                         if (exists("master", mode = "list", envir = envir, 
[15:31:07.546]                           inherits = FALSE)) {
[15:31:07.546]                           master <- get("master", mode = "list", 
[15:31:07.546]                             envir = envir, inherits = FALSE)
[15:31:07.546]                           if (inherits(master, c("SOCKnode", 
[15:31:07.546]                             "SOCK0node"))) {
[15:31:07.546]                             sendCondition <<- function(cond) {
[15:31:07.546]                               data <- list(type = "VALUE", value = cond, 
[15:31:07.546]                                 success = TRUE)
[15:31:07.546]                               parallel_sendData(master, data)
[15:31:07.546]                             }
[15:31:07.546]                             return(sendCondition)
[15:31:07.546]                           }
[15:31:07.546]                         }
[15:31:07.546]                         frame <- frame + 1L
[15:31:07.546]                         envir <- sys.frame(frame)
[15:31:07.546]                       }
[15:31:07.546]                     }
[15:31:07.546]                     sendCondition <<- function(cond) NULL
[15:31:07.546]                   }
[15:31:07.546]                 })
[15:31:07.546]                 withCallingHandlers({
[15:31:07.546]                   {
[15:31:07.546]                     do.call(function(...) {
[15:31:07.546]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:07.546]                       if (!identical(...future.globals.maxSize.org, 
[15:31:07.546]                         ...future.globals.maxSize)) {
[15:31:07.546]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:07.546]                         on.exit(options(oopts), add = TRUE)
[15:31:07.546]                       }
[15:31:07.546]                       {
[15:31:07.546]                         lapply(seq_along(...future.elements_ii), 
[15:31:07.546]                           FUN = function(jj) {
[15:31:07.546]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:07.546]                             ...future.FUN(...future.X_jj, ...)
[15:31:07.546]                           })
[15:31:07.546]                       }
[15:31:07.546]                     }, args = future.call.arguments)
[15:31:07.546]                   }
[15:31:07.546]                 }, immediateCondition = function(cond) {
[15:31:07.546]                   sendCondition <- ...future.makeSendCondition()
[15:31:07.546]                   sendCondition(cond)
[15:31:07.546]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:07.546]                   {
[15:31:07.546]                     inherits <- base::inherits
[15:31:07.546]                     invokeRestart <- base::invokeRestart
[15:31:07.546]                     is.null <- base::is.null
[15:31:07.546]                     muffled <- FALSE
[15:31:07.546]                     if (inherits(cond, "message")) {
[15:31:07.546]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:07.546]                       if (muffled) 
[15:31:07.546]                         invokeRestart("muffleMessage")
[15:31:07.546]                     }
[15:31:07.546]                     else if (inherits(cond, "warning")) {
[15:31:07.546]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:07.546]                       if (muffled) 
[15:31:07.546]                         invokeRestart("muffleWarning")
[15:31:07.546]                     }
[15:31:07.546]                     else if (inherits(cond, "condition")) {
[15:31:07.546]                       if (!is.null(pattern)) {
[15:31:07.546]                         computeRestarts <- base::computeRestarts
[15:31:07.546]                         grepl <- base::grepl
[15:31:07.546]                         restarts <- computeRestarts(cond)
[15:31:07.546]                         for (restart in restarts) {
[15:31:07.546]                           name <- restart$name
[15:31:07.546]                           if (is.null(name)) 
[15:31:07.546]                             next
[15:31:07.546]                           if (!grepl(pattern, name)) 
[15:31:07.546]                             next
[15:31:07.546]                           invokeRestart(restart)
[15:31:07.546]                           muffled <- TRUE
[15:31:07.546]                           break
[15:31:07.546]                         }
[15:31:07.546]                       }
[15:31:07.546]                     }
[15:31:07.546]                     invisible(muffled)
[15:31:07.546]                   }
[15:31:07.546]                   muffleCondition(cond)
[15:31:07.546]                 })
[15:31:07.546]             }))
[15:31:07.546]             future::FutureResult(value = ...future.value$value, 
[15:31:07.546]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:07.546]                   ...future.rng), globalenv = if (FALSE) 
[15:31:07.546]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:07.546]                     ...future.globalenv.names))
[15:31:07.546]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:07.546]         }, condition = base::local({
[15:31:07.546]             c <- base::c
[15:31:07.546]             inherits <- base::inherits
[15:31:07.546]             invokeRestart <- base::invokeRestart
[15:31:07.546]             length <- base::length
[15:31:07.546]             list <- base::list
[15:31:07.546]             seq.int <- base::seq.int
[15:31:07.546]             signalCondition <- base::signalCondition
[15:31:07.546]             sys.calls <- base::sys.calls
[15:31:07.546]             `[[` <- base::`[[`
[15:31:07.546]             `+` <- base::`+`
[15:31:07.546]             `<<-` <- base::`<<-`
[15:31:07.546]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:07.546]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:07.546]                   3L)]
[15:31:07.546]             }
[15:31:07.546]             function(cond) {
[15:31:07.546]                 is_error <- inherits(cond, "error")
[15:31:07.546]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:07.546]                   NULL)
[15:31:07.546]                 if (is_error) {
[15:31:07.546]                   sessionInformation <- function() {
[15:31:07.546]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:07.546]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:07.546]                       search = base::search(), system = base::Sys.info())
[15:31:07.546]                   }
[15:31:07.546]                   ...future.conditions[[length(...future.conditions) + 
[15:31:07.546]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:07.546]                     cond$call), session = sessionInformation(), 
[15:31:07.546]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:07.546]                   signalCondition(cond)
[15:31:07.546]                 }
[15:31:07.546]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:07.546]                 "immediateCondition"))) {
[15:31:07.546]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:07.546]                   ...future.conditions[[length(...future.conditions) + 
[15:31:07.546]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:07.546]                   if (TRUE && !signal) {
[15:31:07.546]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:07.546]                     {
[15:31:07.546]                       inherits <- base::inherits
[15:31:07.546]                       invokeRestart <- base::invokeRestart
[15:31:07.546]                       is.null <- base::is.null
[15:31:07.546]                       muffled <- FALSE
[15:31:07.546]                       if (inherits(cond, "message")) {
[15:31:07.546]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:07.546]                         if (muffled) 
[15:31:07.546]                           invokeRestart("muffleMessage")
[15:31:07.546]                       }
[15:31:07.546]                       else if (inherits(cond, "warning")) {
[15:31:07.546]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:07.546]                         if (muffled) 
[15:31:07.546]                           invokeRestart("muffleWarning")
[15:31:07.546]                       }
[15:31:07.546]                       else if (inherits(cond, "condition")) {
[15:31:07.546]                         if (!is.null(pattern)) {
[15:31:07.546]                           computeRestarts <- base::computeRestarts
[15:31:07.546]                           grepl <- base::grepl
[15:31:07.546]                           restarts <- computeRestarts(cond)
[15:31:07.546]                           for (restart in restarts) {
[15:31:07.546]                             name <- restart$name
[15:31:07.546]                             if (is.null(name)) 
[15:31:07.546]                               next
[15:31:07.546]                             if (!grepl(pattern, name)) 
[15:31:07.546]                               next
[15:31:07.546]                             invokeRestart(restart)
[15:31:07.546]                             muffled <- TRUE
[15:31:07.546]                             break
[15:31:07.546]                           }
[15:31:07.546]                         }
[15:31:07.546]                       }
[15:31:07.546]                       invisible(muffled)
[15:31:07.546]                     }
[15:31:07.546]                     muffleCondition(cond, pattern = "^muffle")
[15:31:07.546]                   }
[15:31:07.546]                 }
[15:31:07.546]                 else {
[15:31:07.546]                   if (TRUE) {
[15:31:07.546]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:07.546]                     {
[15:31:07.546]                       inherits <- base::inherits
[15:31:07.546]                       invokeRestart <- base::invokeRestart
[15:31:07.546]                       is.null <- base::is.null
[15:31:07.546]                       muffled <- FALSE
[15:31:07.546]                       if (inherits(cond, "message")) {
[15:31:07.546]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:07.546]                         if (muffled) 
[15:31:07.546]                           invokeRestart("muffleMessage")
[15:31:07.546]                       }
[15:31:07.546]                       else if (inherits(cond, "warning")) {
[15:31:07.546]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:07.546]                         if (muffled) 
[15:31:07.546]                           invokeRestart("muffleWarning")
[15:31:07.546]                       }
[15:31:07.546]                       else if (inherits(cond, "condition")) {
[15:31:07.546]                         if (!is.null(pattern)) {
[15:31:07.546]                           computeRestarts <- base::computeRestarts
[15:31:07.546]                           grepl <- base::grepl
[15:31:07.546]                           restarts <- computeRestarts(cond)
[15:31:07.546]                           for (restart in restarts) {
[15:31:07.546]                             name <- restart$name
[15:31:07.546]                             if (is.null(name)) 
[15:31:07.546]                               next
[15:31:07.546]                             if (!grepl(pattern, name)) 
[15:31:07.546]                               next
[15:31:07.546]                             invokeRestart(restart)
[15:31:07.546]                             muffled <- TRUE
[15:31:07.546]                             break
[15:31:07.546]                           }
[15:31:07.546]                         }
[15:31:07.546]                       }
[15:31:07.546]                       invisible(muffled)
[15:31:07.546]                     }
[15:31:07.546]                     muffleCondition(cond, pattern = "^muffle")
[15:31:07.546]                   }
[15:31:07.546]                 }
[15:31:07.546]             }
[15:31:07.546]         }))
[15:31:07.546]     }, error = function(ex) {
[15:31:07.546]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:07.546]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:07.546]                 ...future.rng), started = ...future.startTime, 
[15:31:07.546]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:07.546]             version = "1.8"), class = "FutureResult")
[15:31:07.546]     }, finally = {
[15:31:07.546]         if (!identical(...future.workdir, getwd())) 
[15:31:07.546]             setwd(...future.workdir)
[15:31:07.546]         {
[15:31:07.546]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:07.546]                 ...future.oldOptions$nwarnings <- NULL
[15:31:07.546]             }
[15:31:07.546]             base::options(...future.oldOptions)
[15:31:07.546]             if (.Platform$OS.type == "windows") {
[15:31:07.546]                 old_names <- names(...future.oldEnvVars)
[15:31:07.546]                 envs <- base::Sys.getenv()
[15:31:07.546]                 names <- names(envs)
[15:31:07.546]                 common <- intersect(names, old_names)
[15:31:07.546]                 added <- setdiff(names, old_names)
[15:31:07.546]                 removed <- setdiff(old_names, names)
[15:31:07.546]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:07.546]                   envs[common]]
[15:31:07.546]                 NAMES <- toupper(changed)
[15:31:07.546]                 args <- list()
[15:31:07.546]                 for (kk in seq_along(NAMES)) {
[15:31:07.546]                   name <- changed[[kk]]
[15:31:07.546]                   NAME <- NAMES[[kk]]
[15:31:07.546]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:07.546]                     next
[15:31:07.546]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:07.546]                 }
[15:31:07.546]                 NAMES <- toupper(added)
[15:31:07.546]                 for (kk in seq_along(NAMES)) {
[15:31:07.546]                   name <- added[[kk]]
[15:31:07.546]                   NAME <- NAMES[[kk]]
[15:31:07.546]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:07.546]                     next
[15:31:07.546]                   args[[name]] <- ""
[15:31:07.546]                 }
[15:31:07.546]                 NAMES <- toupper(removed)
[15:31:07.546]                 for (kk in seq_along(NAMES)) {
[15:31:07.546]                   name <- removed[[kk]]
[15:31:07.546]                   NAME <- NAMES[[kk]]
[15:31:07.546]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:07.546]                     next
[15:31:07.546]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:07.546]                 }
[15:31:07.546]                 if (length(args) > 0) 
[15:31:07.546]                   base::do.call(base::Sys.setenv, args = args)
[15:31:07.546]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:07.546]             }
[15:31:07.546]             else {
[15:31:07.546]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:07.546]             }
[15:31:07.546]             {
[15:31:07.546]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:07.546]                   0L) {
[15:31:07.546]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:07.546]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:07.546]                   base::options(opts)
[15:31:07.546]                 }
[15:31:07.546]                 {
[15:31:07.546]                   {
[15:31:07.546]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:07.546]                     NULL
[15:31:07.546]                   }
[15:31:07.546]                   options(future.plan = NULL)
[15:31:07.546]                   if (is.na(NA_character_)) 
[15:31:07.546]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:07.546]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:07.546]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:07.546]                     .init = FALSE)
[15:31:07.546]                 }
[15:31:07.546]             }
[15:31:07.546]         }
[15:31:07.546]     })
[15:31:07.546]     if (TRUE) {
[15:31:07.546]         base::sink(type = "output", split = FALSE)
[15:31:07.546]         if (TRUE) {
[15:31:07.546]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:07.546]         }
[15:31:07.546]         else {
[15:31:07.546]             ...future.result["stdout"] <- base::list(NULL)
[15:31:07.546]         }
[15:31:07.546]         base::close(...future.stdout)
[15:31:07.546]         ...future.stdout <- NULL
[15:31:07.546]     }
[15:31:07.546]     ...future.result$conditions <- ...future.conditions
[15:31:07.546]     ...future.result$finished <- base::Sys.time()
[15:31:07.546]     ...future.result
[15:31:07.546] }
[15:31:07.558] Exporting 5 global objects (1.21 KiB) to cluster node #1 ...
[15:31:07.558] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:31:07.559] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:31:07.560] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:31:07.560] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:31:07.561] Exporting '...future.elements_ii' (336 bytes) to cluster node #1 ...
[15:31:07.562] Exporting '...future.elements_ii' (336 bytes) to cluster node #1 ... DONE
[15:31:07.562] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:31:07.563] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:31:07.563] Exporting '...future.globals.maxSize' (56 bytes) to cluster node #1 ...
[15:31:07.564] Exporting '...future.globals.maxSize' (56 bytes) to cluster node #1 ... DONE
[15:31:07.564] Exporting 5 global objects (1.21 KiB) to cluster node #1 ... DONE
[15:31:07.565] MultisessionFuture started
[15:31:07.566] - Launch lazy future ... done
[15:31:07.566] run() for 'MultisessionFuture' ... done
[15:31:07.567] Created future:
[15:31:07.591] receiveMessageFromWorker() for ClusterFuture ...
[15:31:07.591] - Validating connection of MultisessionFuture
[15:31:07.592] - received message: FutureResult
[15:31:07.592] - Received FutureResult
[15:31:07.593] - Erased future from FutureRegistry
[15:31:07.593] result() for ClusterFuture ...
[15:31:07.593] - result already collected: FutureResult
[15:31:07.593] result() for ClusterFuture ... done
[15:31:07.594] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:07.567] MultisessionFuture:
[15:31:07.567] Label: 'future_apply-1'
[15:31:07.567] Expression:
[15:31:07.567] {
[15:31:07.567]     do.call(function(...) {
[15:31:07.567]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:07.567]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:07.567]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:07.567]             on.exit(options(oopts), add = TRUE)
[15:31:07.567]         }
[15:31:07.567]         {
[15:31:07.567]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:07.567]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:07.567]                 ...future.FUN(...future.X_jj, ...)
[15:31:07.567]             })
[15:31:07.567]         }
[15:31:07.567]     }, args = future.call.arguments)
[15:31:07.567] }
[15:31:07.567] Lazy evaluation: FALSE
[15:31:07.567] Asynchronous evaluation: TRUE
[15:31:07.567] Local evaluation: TRUE
[15:31:07.567] Environment: R_GlobalEnv
[15:31:07.567] Capture standard output: TRUE
[15:31:07.567] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:07.567] Globals: 5 objects totaling 1.21 KiB (DotDotDotList 'future.call.arguments' of 0 bytes, function '...future.FUN' of 848 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, numeric '...future.globals.maxSize' of 56 bytes)
[15:31:07.567] Packages: <none>
[15:31:07.567] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:07.567] Resolved: TRUE
[15:31:07.567] Value: <not collected>
[15:31:07.567] Conditions captured: <none>
[15:31:07.567] Early signaling: FALSE
[15:31:07.567] Owner process: 6672a580-6d3c-e82f-380e-108c475ace70
[15:31:07.567] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:07.594] Chunk #1 of 2 ... DONE
[15:31:07.595] Chunk #2 of 2 ...
[15:31:07.595]  - Adjusted option 'future.globals.maxSize': Inf -> 2 * Inf = Inf (bytes)
[15:31:07.595]  - seeds: <none>
[15:31:07.596]  - All globals exported: [n=5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:07.596] getGlobalsAndPackages() ...
[15:31:07.596] - globals passed as-is: [5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:07.597] Resolving globals: FALSE
[15:31:07.597] Tweak future expression to call with '...' arguments ...
[15:31:07.597] {
[15:31:07.597]     do.call(function(...) {
[15:31:07.597]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:07.597]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:07.597]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:07.597]             on.exit(options(oopts), add = TRUE)
[15:31:07.597]         }
[15:31:07.597]         {
[15:31:07.597]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:07.597]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:07.597]                 ...future.FUN(...future.X_jj, ...)
[15:31:07.597]             })
[15:31:07.597]         }
[15:31:07.597]     }, args = future.call.arguments)
[15:31:07.597] }
[15:31:07.598] Tweak future expression to call with '...' arguments ... DONE
[15:31:07.599] - globals: [5] 'future.call.arguments', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:07.599] 
[15:31:07.599] getGlobalsAndPackages() ... DONE
[15:31:07.600] run() for 'Future' ...
[15:31:07.600] - state: 'created'
[15:31:07.601] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:07.619] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:07.620] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:31:07.620]   - Field: 'node'
[15:31:07.621]   - Field: 'label'
[15:31:07.621]   - Field: 'local'
[15:31:07.621]   - Field: 'owner'
[15:31:07.622]   - Field: 'envir'
[15:31:07.622]   - Field: 'workers'
[15:31:07.622]   - Field: 'packages'
[15:31:07.622]   - Field: 'gc'
[15:31:07.623]   - Field: 'conditions'
[15:31:07.623]   - Field: 'persistent'
[15:31:07.623]   - Field: 'expr'
[15:31:07.624]   - Field: 'uuid'
[15:31:07.624]   - Field: 'seed'
[15:31:07.624]   - Field: 'version'
[15:31:07.625]   - Field: 'result'
[15:31:07.625]   - Field: 'asynchronous'
[15:31:07.625]   - Field: 'calls'
[15:31:07.625]   - Field: 'globals'
[15:31:07.626]   - Field: 'stdout'
[15:31:07.626]   - Field: 'earlySignal'
[15:31:07.626]   - Field: 'lazy'
[15:31:07.627]   - Field: 'state'
[15:31:07.627] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:31:07.627] - Launch lazy future ...
[15:31:07.628] Packages needed by the future expression (n = 0): <none>
[15:31:07.628] Packages needed by future strategies (n = 0): <none>
[15:31:07.629] {
[15:31:07.629]     {
[15:31:07.629]         {
[15:31:07.629]             ...future.startTime <- base::Sys.time()
[15:31:07.629]             {
[15:31:07.629]                 {
[15:31:07.629]                   {
[15:31:07.629]                     {
[15:31:07.629]                       base::local({
[15:31:07.629]                         has_future <- base::requireNamespace("future", 
[15:31:07.629]                           quietly = TRUE)
[15:31:07.629]                         if (has_future) {
[15:31:07.629]                           ns <- base::getNamespace("future")
[15:31:07.629]                           version <- ns[[".package"]][["version"]]
[15:31:07.629]                           if (is.null(version)) 
[15:31:07.629]                             version <- utils::packageVersion("future")
[15:31:07.629]                         }
[15:31:07.629]                         else {
[15:31:07.629]                           version <- NULL
[15:31:07.629]                         }
[15:31:07.629]                         if (!has_future || version < "1.8.0") {
[15:31:07.629]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:07.629]                             "", base::R.version$version.string), 
[15:31:07.629]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:07.629]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:07.629]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:07.629]                               "release", "version")], collapse = " "), 
[15:31:07.629]                             hostname = base::Sys.info()[["nodename"]])
[15:31:07.629]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:07.629]                             info)
[15:31:07.629]                           info <- base::paste(info, collapse = "; ")
[15:31:07.629]                           if (!has_future) {
[15:31:07.629]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:07.629]                               info)
[15:31:07.629]                           }
[15:31:07.629]                           else {
[15:31:07.629]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:07.629]                               info, version)
[15:31:07.629]                           }
[15:31:07.629]                           base::stop(msg)
[15:31:07.629]                         }
[15:31:07.629]                       })
[15:31:07.629]                     }
[15:31:07.629]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:07.629]                     base::options(mc.cores = 1L)
[15:31:07.629]                   }
[15:31:07.629]                   ...future.strategy.old <- future::plan("list")
[15:31:07.629]                   options(future.plan = NULL)
[15:31:07.629]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:07.629]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:07.629]                 }
[15:31:07.629]                 ...future.workdir <- getwd()
[15:31:07.629]             }
[15:31:07.629]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:07.629]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:07.629]         }
[15:31:07.629]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:07.629]             future.globals.maxSize = Inf, future.globals.method = NULL, 
[15:31:07.629]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:07.629]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:07.629]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:07.629]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:07.629]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:07.629]             base::names(...future.oldOptions))
[15:31:07.629]     }
[15:31:07.629]     if (FALSE) {
[15:31:07.629]     }
[15:31:07.629]     else {
[15:31:07.629]         if (TRUE) {
[15:31:07.629]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:07.629]                 open = "w")
[15:31:07.629]         }
[15:31:07.629]         else {
[15:31:07.629]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:07.629]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:07.629]         }
[15:31:07.629]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:07.629]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:07.629]             base::sink(type = "output", split = FALSE)
[15:31:07.629]             base::close(...future.stdout)
[15:31:07.629]         }, add = TRUE)
[15:31:07.629]     }
[15:31:07.629]     ...future.frame <- base::sys.nframe()
[15:31:07.629]     ...future.conditions <- base::list()
[15:31:07.629]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:07.629]     if (FALSE) {
[15:31:07.629]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:07.629]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:07.629]     }
[15:31:07.629]     ...future.result <- base::tryCatch({
[15:31:07.629]         base::withCallingHandlers({
[15:31:07.629]             ...future.value <- base::withVisible(base::local({
[15:31:07.629]                 ...future.makeSendCondition <- base::local({
[15:31:07.629]                   sendCondition <- NULL
[15:31:07.629]                   function(frame = 1L) {
[15:31:07.629]                     if (is.function(sendCondition)) 
[15:31:07.629]                       return(sendCondition)
[15:31:07.629]                     ns <- getNamespace("parallel")
[15:31:07.629]                     if (exists("sendData", mode = "function", 
[15:31:07.629]                       envir = ns)) {
[15:31:07.629]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:07.629]                         envir = ns)
[15:31:07.629]                       envir <- sys.frame(frame)
[15:31:07.629]                       master <- NULL
[15:31:07.629]                       while (!identical(envir, .GlobalEnv) && 
[15:31:07.629]                         !identical(envir, emptyenv())) {
[15:31:07.629]                         if (exists("master", mode = "list", envir = envir, 
[15:31:07.629]                           inherits = FALSE)) {
[15:31:07.629]                           master <- get("master", mode = "list", 
[15:31:07.629]                             envir = envir, inherits = FALSE)
[15:31:07.629]                           if (inherits(master, c("SOCKnode", 
[15:31:07.629]                             "SOCK0node"))) {
[15:31:07.629]                             sendCondition <<- function(cond) {
[15:31:07.629]                               data <- list(type = "VALUE", value = cond, 
[15:31:07.629]                                 success = TRUE)
[15:31:07.629]                               parallel_sendData(master, data)
[15:31:07.629]                             }
[15:31:07.629]                             return(sendCondition)
[15:31:07.629]                           }
[15:31:07.629]                         }
[15:31:07.629]                         frame <- frame + 1L
[15:31:07.629]                         envir <- sys.frame(frame)
[15:31:07.629]                       }
[15:31:07.629]                     }
[15:31:07.629]                     sendCondition <<- function(cond) NULL
[15:31:07.629]                   }
[15:31:07.629]                 })
[15:31:07.629]                 withCallingHandlers({
[15:31:07.629]                   {
[15:31:07.629]                     do.call(function(...) {
[15:31:07.629]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:07.629]                       if (!identical(...future.globals.maxSize.org, 
[15:31:07.629]                         ...future.globals.maxSize)) {
[15:31:07.629]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:07.629]                         on.exit(options(oopts), add = TRUE)
[15:31:07.629]                       }
[15:31:07.629]                       {
[15:31:07.629]                         lapply(seq_along(...future.elements_ii), 
[15:31:07.629]                           FUN = function(jj) {
[15:31:07.629]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:07.629]                             ...future.FUN(...future.X_jj, ...)
[15:31:07.629]                           })
[15:31:07.629]                       }
[15:31:07.629]                     }, args = future.call.arguments)
[15:31:07.629]                   }
[15:31:07.629]                 }, immediateCondition = function(cond) {
[15:31:07.629]                   sendCondition <- ...future.makeSendCondition()
[15:31:07.629]                   sendCondition(cond)
[15:31:07.629]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:07.629]                   {
[15:31:07.629]                     inherits <- base::inherits
[15:31:07.629]                     invokeRestart <- base::invokeRestart
[15:31:07.629]                     is.null <- base::is.null
[15:31:07.629]                     muffled <- FALSE
[15:31:07.629]                     if (inherits(cond, "message")) {
[15:31:07.629]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:07.629]                       if (muffled) 
[15:31:07.629]                         invokeRestart("muffleMessage")
[15:31:07.629]                     }
[15:31:07.629]                     else if (inherits(cond, "warning")) {
[15:31:07.629]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:07.629]                       if (muffled) 
[15:31:07.629]                         invokeRestart("muffleWarning")
[15:31:07.629]                     }
[15:31:07.629]                     else if (inherits(cond, "condition")) {
[15:31:07.629]                       if (!is.null(pattern)) {
[15:31:07.629]                         computeRestarts <- base::computeRestarts
[15:31:07.629]                         grepl <- base::grepl
[15:31:07.629]                         restarts <- computeRestarts(cond)
[15:31:07.629]                         for (restart in restarts) {
[15:31:07.629]                           name <- restart$name
[15:31:07.629]                           if (is.null(name)) 
[15:31:07.629]                             next
[15:31:07.629]                           if (!grepl(pattern, name)) 
[15:31:07.629]                             next
[15:31:07.629]                           invokeRestart(restart)
[15:31:07.629]                           muffled <- TRUE
[15:31:07.629]                           break
[15:31:07.629]                         }
[15:31:07.629]                       }
[15:31:07.629]                     }
[15:31:07.629]                     invisible(muffled)
[15:31:07.629]                   }
[15:31:07.629]                   muffleCondition(cond)
[15:31:07.629]                 })
[15:31:07.629]             }))
[15:31:07.629]             future::FutureResult(value = ...future.value$value, 
[15:31:07.629]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:07.629]                   ...future.rng), globalenv = if (FALSE) 
[15:31:07.629]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:07.629]                     ...future.globalenv.names))
[15:31:07.629]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:07.629]         }, condition = base::local({
[15:31:07.629]             c <- base::c
[15:31:07.629]             inherits <- base::inherits
[15:31:07.629]             invokeRestart <- base::invokeRestart
[15:31:07.629]             length <- base::length
[15:31:07.629]             list <- base::list
[15:31:07.629]             seq.int <- base::seq.int
[15:31:07.629]             signalCondition <- base::signalCondition
[15:31:07.629]             sys.calls <- base::sys.calls
[15:31:07.629]             `[[` <- base::`[[`
[15:31:07.629]             `+` <- base::`+`
[15:31:07.629]             `<<-` <- base::`<<-`
[15:31:07.629]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:07.629]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:07.629]                   3L)]
[15:31:07.629]             }
[15:31:07.629]             function(cond) {
[15:31:07.629]                 is_error <- inherits(cond, "error")
[15:31:07.629]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:07.629]                   NULL)
[15:31:07.629]                 if (is_error) {
[15:31:07.629]                   sessionInformation <- function() {
[15:31:07.629]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:07.629]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:07.629]                       search = base::search(), system = base::Sys.info())
[15:31:07.629]                   }
[15:31:07.629]                   ...future.conditions[[length(...future.conditions) + 
[15:31:07.629]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:07.629]                     cond$call), session = sessionInformation(), 
[15:31:07.629]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:07.629]                   signalCondition(cond)
[15:31:07.629]                 }
[15:31:07.629]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:07.629]                 "immediateCondition"))) {
[15:31:07.629]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:07.629]                   ...future.conditions[[length(...future.conditions) + 
[15:31:07.629]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:07.629]                   if (TRUE && !signal) {
[15:31:07.629]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:07.629]                     {
[15:31:07.629]                       inherits <- base::inherits
[15:31:07.629]                       invokeRestart <- base::invokeRestart
[15:31:07.629]                       is.null <- base::is.null
[15:31:07.629]                       muffled <- FALSE
[15:31:07.629]                       if (inherits(cond, "message")) {
[15:31:07.629]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:07.629]                         if (muffled) 
[15:31:07.629]                           invokeRestart("muffleMessage")
[15:31:07.629]                       }
[15:31:07.629]                       else if (inherits(cond, "warning")) {
[15:31:07.629]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:07.629]                         if (muffled) 
[15:31:07.629]                           invokeRestart("muffleWarning")
[15:31:07.629]                       }
[15:31:07.629]                       else if (inherits(cond, "condition")) {
[15:31:07.629]                         if (!is.null(pattern)) {
[15:31:07.629]                           computeRestarts <- base::computeRestarts
[15:31:07.629]                           grepl <- base::grepl
[15:31:07.629]                           restarts <- computeRestarts(cond)
[15:31:07.629]                           for (restart in restarts) {
[15:31:07.629]                             name <- restart$name
[15:31:07.629]                             if (is.null(name)) 
[15:31:07.629]                               next
[15:31:07.629]                             if (!grepl(pattern, name)) 
[15:31:07.629]                               next
[15:31:07.629]                             invokeRestart(restart)
[15:31:07.629]                             muffled <- TRUE
[15:31:07.629]                             break
[15:31:07.629]                           }
[15:31:07.629]                         }
[15:31:07.629]                       }
[15:31:07.629]                       invisible(muffled)
[15:31:07.629]                     }
[15:31:07.629]                     muffleCondition(cond, pattern = "^muffle")
[15:31:07.629]                   }
[15:31:07.629]                 }
[15:31:07.629]                 else {
[15:31:07.629]                   if (TRUE) {
[15:31:07.629]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:07.629]                     {
[15:31:07.629]                       inherits <- base::inherits
[15:31:07.629]                       invokeRestart <- base::invokeRestart
[15:31:07.629]                       is.null <- base::is.null
[15:31:07.629]                       muffled <- FALSE
[15:31:07.629]                       if (inherits(cond, "message")) {
[15:31:07.629]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:07.629]                         if (muffled) 
[15:31:07.629]                           invokeRestart("muffleMessage")
[15:31:07.629]                       }
[15:31:07.629]                       else if (inherits(cond, "warning")) {
[15:31:07.629]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:07.629]                         if (muffled) 
[15:31:07.629]                           invokeRestart("muffleWarning")
[15:31:07.629]                       }
[15:31:07.629]                       else if (inherits(cond, "condition")) {
[15:31:07.629]                         if (!is.null(pattern)) {
[15:31:07.629]                           computeRestarts <- base::computeRestarts
[15:31:07.629]                           grepl <- base::grepl
[15:31:07.629]                           restarts <- computeRestarts(cond)
[15:31:07.629]                           for (restart in restarts) {
[15:31:07.629]                             name <- restart$name
[15:31:07.629]                             if (is.null(name)) 
[15:31:07.629]                               next
[15:31:07.629]                             if (!grepl(pattern, name)) 
[15:31:07.629]                               next
[15:31:07.629]                             invokeRestart(restart)
[15:31:07.629]                             muffled <- TRUE
[15:31:07.629]                             break
[15:31:07.629]                           }
[15:31:07.629]                         }
[15:31:07.629]                       }
[15:31:07.629]                       invisible(muffled)
[15:31:07.629]                     }
[15:31:07.629]                     muffleCondition(cond, pattern = "^muffle")
[15:31:07.629]                   }
[15:31:07.629]                 }
[15:31:07.629]             }
[15:31:07.629]         }))
[15:31:07.629]     }, error = function(ex) {
[15:31:07.629]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:07.629]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:07.629]                 ...future.rng), started = ...future.startTime, 
[15:31:07.629]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:07.629]             version = "1.8"), class = "FutureResult")
[15:31:07.629]     }, finally = {
[15:31:07.629]         if (!identical(...future.workdir, getwd())) 
[15:31:07.629]             setwd(...future.workdir)
[15:31:07.629]         {
[15:31:07.629]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:07.629]                 ...future.oldOptions$nwarnings <- NULL
[15:31:07.629]             }
[15:31:07.629]             base::options(...future.oldOptions)
[15:31:07.629]             if (.Platform$OS.type == "windows") {
[15:31:07.629]                 old_names <- names(...future.oldEnvVars)
[15:31:07.629]                 envs <- base::Sys.getenv()
[15:31:07.629]                 names <- names(envs)
[15:31:07.629]                 common <- intersect(names, old_names)
[15:31:07.629]                 added <- setdiff(names, old_names)
[15:31:07.629]                 removed <- setdiff(old_names, names)
[15:31:07.629]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:07.629]                   envs[common]]
[15:31:07.629]                 NAMES <- toupper(changed)
[15:31:07.629]                 args <- list()
[15:31:07.629]                 for (kk in seq_along(NAMES)) {
[15:31:07.629]                   name <- changed[[kk]]
[15:31:07.629]                   NAME <- NAMES[[kk]]
[15:31:07.629]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:07.629]                     next
[15:31:07.629]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:07.629]                 }
[15:31:07.629]                 NAMES <- toupper(added)
[15:31:07.629]                 for (kk in seq_along(NAMES)) {
[15:31:07.629]                   name <- added[[kk]]
[15:31:07.629]                   NAME <- NAMES[[kk]]
[15:31:07.629]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:07.629]                     next
[15:31:07.629]                   args[[name]] <- ""
[15:31:07.629]                 }
[15:31:07.629]                 NAMES <- toupper(removed)
[15:31:07.629]                 for (kk in seq_along(NAMES)) {
[15:31:07.629]                   name <- removed[[kk]]
[15:31:07.629]                   NAME <- NAMES[[kk]]
[15:31:07.629]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:07.629]                     next
[15:31:07.629]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:07.629]                 }
[15:31:07.629]                 if (length(args) > 0) 
[15:31:07.629]                   base::do.call(base::Sys.setenv, args = args)
[15:31:07.629]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:07.629]             }
[15:31:07.629]             else {
[15:31:07.629]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:07.629]             }
[15:31:07.629]             {
[15:31:07.629]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:07.629]                   0L) {
[15:31:07.629]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:07.629]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:07.629]                   base::options(opts)
[15:31:07.629]                 }
[15:31:07.629]                 {
[15:31:07.629]                   {
[15:31:07.629]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:07.629]                     NULL
[15:31:07.629]                   }
[15:31:07.629]                   options(future.plan = NULL)
[15:31:07.629]                   if (is.na(NA_character_)) 
[15:31:07.629]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:07.629]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:07.629]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:07.629]                     .init = FALSE)
[15:31:07.629]                 }
[15:31:07.629]             }
[15:31:07.629]         }
[15:31:07.629]     })
[15:31:07.629]     if (TRUE) {
[15:31:07.629]         base::sink(type = "output", split = FALSE)
[15:31:07.629]         if (TRUE) {
[15:31:07.629]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:07.629]         }
[15:31:07.629]         else {
[15:31:07.629]             ...future.result["stdout"] <- base::list(NULL)
[15:31:07.629]         }
[15:31:07.629]         base::close(...future.stdout)
[15:31:07.629]         ...future.stdout <- NULL
[15:31:07.629]     }
[15:31:07.629]     ...future.result$conditions <- ...future.conditions
[15:31:07.629]     ...future.result$finished <- base::Sys.time()
[15:31:07.629]     ...future.result
[15:31:07.629] }
[15:31:07.640] Exporting 5 global objects (1.21 KiB) to cluster node #1 ...
[15:31:07.644] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:31:07.645] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:31:07.645] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:31:07.646] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:31:07.647] Exporting '...future.elements_ii' (336 bytes) to cluster node #1 ...
[15:31:07.647] Exporting '...future.elements_ii' (336 bytes) to cluster node #1 ... DONE
[15:31:07.648] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:31:07.648] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:31:07.649] Exporting '...future.globals.maxSize' (56 bytes) to cluster node #1 ...
[15:31:07.650] Exporting '...future.globals.maxSize' (56 bytes) to cluster node #1 ... DONE
[15:31:07.650] Exporting 5 global objects (1.21 KiB) to cluster node #1 ... DONE
[15:31:07.651] MultisessionFuture started
[15:31:07.651] - Launch lazy future ... done
[15:31:07.652] run() for 'MultisessionFuture' ... done
[15:31:07.652] Created future:
[15:31:07.681] receiveMessageFromWorker() for ClusterFuture ...
[15:31:07.682] - Validating connection of MultisessionFuture
[15:31:07.683] - received message: FutureResult
[15:31:07.683] - Received FutureResult
[15:31:07.684] - Erased future from FutureRegistry
[15:31:07.684] result() for ClusterFuture ...
[15:31:07.685] - result already collected: FutureResult
[15:31:07.685] result() for ClusterFuture ... done
[15:31:07.685] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:07.652] MultisessionFuture:
[15:31:07.652] Label: 'future_apply-2'
[15:31:07.652] Expression:
[15:31:07.652] {
[15:31:07.652]     do.call(function(...) {
[15:31:07.652]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:07.652]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:07.652]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:07.652]             on.exit(options(oopts), add = TRUE)
[15:31:07.652]         }
[15:31:07.652]         {
[15:31:07.652]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:07.652]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:07.652]                 ...future.FUN(...future.X_jj, ...)
[15:31:07.652]             })
[15:31:07.652]         }
[15:31:07.652]     }, args = future.call.arguments)
[15:31:07.652] }
[15:31:07.652] Lazy evaluation: FALSE
[15:31:07.652] Asynchronous evaluation: TRUE
[15:31:07.652] Local evaluation: TRUE
[15:31:07.652] Environment: R_GlobalEnv
[15:31:07.652] Capture standard output: TRUE
[15:31:07.652] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:07.652] Globals: 5 objects totaling 1.21 KiB (DotDotDotList 'future.call.arguments' of 0 bytes, function '...future.FUN' of 848 bytes, list '...future.elements_ii' of 336 bytes, NULL '...future.seeds_ii' of 0 bytes, numeric '...future.globals.maxSize' of 56 bytes)
[15:31:07.652] Packages: <none>
[15:31:07.652] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:07.652] Resolved: TRUE
[15:31:07.652] Value: <not collected>
[15:31:07.652] Conditions captured: <none>
[15:31:07.652] Early signaling: FALSE
[15:31:07.652] Owner process: 6672a580-6d3c-e82f-380e-108c475ace70
[15:31:07.652] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:07.686] Chunk #2 of 2 ... DONE
[15:31:07.687] Launching 2 futures (chunks) ... DONE
[15:31:07.687] Resolving 2 futures (chunks) ...
[15:31:07.687] resolve() on list ...
[15:31:07.687]  recursive: 0
[15:31:07.688]  length: 2
[15:31:07.688] 
[15:31:07.688] Future #1
[15:31:07.689] result() for ClusterFuture ...
[15:31:07.689] - result already collected: FutureResult
[15:31:07.689] result() for ClusterFuture ... done
[15:31:07.690] result() for ClusterFuture ...
[15:31:07.690] - result already collected: FutureResult
[15:31:07.690] result() for ClusterFuture ... done
[15:31:07.691] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:31:07.691] - nx: 2
[15:31:07.691] - relay: TRUE
[15:31:07.692] - stdout: TRUE
[15:31:07.692] - signal: TRUE
[15:31:07.692] - resignal: FALSE
[15:31:07.693] - force: TRUE
[15:31:07.693] - relayed: [n=2] FALSE, FALSE
[15:31:07.693] - queued futures: [n=2] FALSE, FALSE
[15:31:07.694]  - until=1
[15:31:07.694]  - relaying element #1
[15:31:07.694] result() for ClusterFuture ...
[15:31:07.694] - result already collected: FutureResult
[15:31:07.695] result() for ClusterFuture ... done
[15:31:07.695] result() for ClusterFuture ...
[15:31:07.695] - result already collected: FutureResult
[15:31:07.696] result() for ClusterFuture ... done
[15:31:07.696] result() for ClusterFuture ...
[15:31:07.696] - result already collected: FutureResult
[15:31:07.697] result() for ClusterFuture ... done
[15:31:07.697] result() for ClusterFuture ...
[15:31:07.697] - result already collected: FutureResult
[15:31:07.698] result() for ClusterFuture ... done
[15:31:07.698] - relayed: [n=2] TRUE, FALSE
[15:31:07.698] - queued futures: [n=2] TRUE, FALSE
[15:31:07.699] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:31:07.699]  length: 1 (resolved future 1)
[15:31:07.699] Future #2
[15:31:07.700] result() for ClusterFuture ...
[15:31:07.700] - result already collected: FutureResult
[15:31:07.700] result() for ClusterFuture ... done
[15:31:07.701] result() for ClusterFuture ...
[15:31:07.701] - result already collected: FutureResult
[15:31:07.701] result() for ClusterFuture ... done
[15:31:07.702] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:31:07.702] - nx: 2
[15:31:07.702] - relay: TRUE
[15:31:07.702] - stdout: TRUE
[15:31:07.703] - signal: TRUE
[15:31:07.703] - resignal: FALSE
[15:31:07.703] - force: TRUE
[15:31:07.704] - relayed: [n=2] TRUE, FALSE
[15:31:07.704] - queued futures: [n=2] TRUE, FALSE
[15:31:07.704]  - until=2
[15:31:07.705]  - relaying element #2
[15:31:07.705] result() for ClusterFuture ...
[15:31:07.705] - result already collected: FutureResult
[15:31:07.705] result() for ClusterFuture ... done
[15:31:07.706] result() for ClusterFuture ...
[15:31:07.706] - result already collected: FutureResult
[15:31:07.706] result() for ClusterFuture ... done
[15:31:07.707] result() for ClusterFuture ...
[15:31:07.707] - result already collected: FutureResult
[15:31:07.707] result() for ClusterFuture ... done
[15:31:07.708] result() for ClusterFuture ...
[15:31:07.708] - result already collected: FutureResult
[15:31:07.708] result() for ClusterFuture ... done
[15:31:07.709] - relayed: [n=2] TRUE, TRUE
[15:31:07.709] - queued futures: [n=2] TRUE, TRUE
[15:31:07.709] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:31:07.710]  length: 0 (resolved future 2)
[15:31:07.710] Relaying remaining futures
[15:31:07.710] signalConditionsASAP(NULL, pos=0) ...
[15:31:07.711] - nx: 2
[15:31:07.711] - relay: TRUE
[15:31:07.711] - stdout: TRUE
[15:31:07.711] - signal: TRUE
[15:31:07.712] - resignal: FALSE
[15:31:07.712] - force: TRUE
[15:31:07.712] - relayed: [n=2] TRUE, TRUE
[15:31:07.713] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:31:07.713] - relayed: [n=2] TRUE, TRUE
[15:31:07.714] - queued futures: [n=2] TRUE, TRUE
[15:31:07.714] signalConditionsASAP(NULL, pos=0) ... done
[15:31:07.714] resolve() on list ... DONE
[15:31:07.714] result() for ClusterFuture ...
[15:31:07.715] - result already collected: FutureResult
[15:31:07.715] result() for ClusterFuture ... done
[15:31:07.715] result() for ClusterFuture ...
[15:31:07.716] - result already collected: FutureResult
[15:31:07.716] result() for ClusterFuture ... done
[15:31:07.717] result() for ClusterFuture ...
[15:31:07.717] - result already collected: FutureResult
[15:31:07.717] result() for ClusterFuture ... done
[15:31:07.717] result() for ClusterFuture ...
[15:31:07.718] - result already collected: FutureResult
[15:31:07.718] result() for ClusterFuture ... done
[15:31:07.719]  - Number of value chunks collected: 2
[15:31:07.719] Resolving 2 futures (chunks) ... DONE
[15:31:07.719] Reducing values from 2 chunks ...
[15:31:07.719]  - Number of values collected after concatenation: 6
[15:31:07.720]  - Number of values expected: 6
[15:31:07.720] Reducing values from 2 chunks ... DONE
[15:31:07.720] future_lapply() ... DONE
, , C = cop.1

      col
row    x1 x2
  [1,]  3  4
  [2,]  3  3
  [3,]  3  2
  [4,]  3  1
  [5,]  3  2
  [6,]  3  3
  [7,]  3  4
  [8,]  3  5

, , C = cop.2

      col
row    x1 x2
  [1,]  3  4
  [2,]  3  3
  [3,]  3  2
  [4,]  3  1
  [5,]  3  2
  [6,]  3  3
  [7,]  3  4
  [8,]  3  5

, , C = cop.3

      col
row    x1 x2
  [1,]  3  4
  [2,]  3  3
  [3,]  3  2
  [4,]  3  1
  [5,]  3  2
  [6,]  3  3
  [7,]  3  4
  [8,]  3  5

[15:31:07.722] getGlobalsAndPackagesXApply() ...
[15:31:07.722]  - future.globals: TRUE
[15:31:07.722] getGlobalsAndPackages() ...
[15:31:07.722] Searching for globals...
[15:31:07.726] - globals found: [3] 'FUN', 'seq_len', 'max'
[15:31:07.726] Searching for globals ... DONE
[15:31:07.726] Resolving globals: FALSE
[15:31:07.727] The total size of the 1 globals is 1.73 KiB (1768 bytes)
[15:31:07.728] The total size of the 1 globals exported for future expression ('FUN(X = structure(1:24, dim = 2:4))') is 1.73 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.73 KiB of class 'function')
[15:31:07.728] - globals: [1] 'FUN'
[15:31:07.729] 
[15:31:07.729] getGlobalsAndPackages() ... DONE
[15:31:07.729]  - globals found/used: [n=1] 'FUN'
[15:31:07.730]  - needed namespaces: [n=0] 
[15:31:07.730] Finding globals ... DONE
[15:31:07.730]  - use_args: TRUE
[15:31:07.731]  - Getting '...' globals ...
[15:31:07.732] resolve() on list ...
[15:31:07.732]  recursive: 0
[15:31:07.732]  length: 1
[15:31:07.732]  elements: '...'
[15:31:07.733]  length: 0 (resolved future 1)
[15:31:07.733] resolve() on list ... DONE
[15:31:07.734]    - '...' content: [n=0] 
[15:31:07.734] List of 1
[15:31:07.734]  $ ...: list()
[15:31:07.734]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:07.734]  - attr(*, "where")=List of 1
[15:31:07.734]   ..$ ...:<environment: 0x000001bcb977cf40> 
[15:31:07.734]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:07.734]  - attr(*, "resolved")= logi TRUE
[15:31:07.734]  - attr(*, "total_size")= num NA
[15:31:07.740]  - Getting '...' globals ... DONE
[15:31:07.740] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:07.741] List of 2
[15:31:07.741]  $ ...future.FUN:function (x)  
[15:31:07.741]  $ ...          : list()
[15:31:07.741]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:07.741]  - attr(*, "where")=List of 2
[15:31:07.741]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:07.741]   ..$ ...          :<environment: 0x000001bcb977cf40> 
[15:31:07.741]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:07.741]  - attr(*, "resolved")= logi FALSE
[15:31:07.741]  - attr(*, "total_size")= num 1768
[15:31:07.747] Packages to be attached in all futures: [n=0] 
[15:31:07.747] getGlobalsAndPackagesXApply() ... DONE
[15:31:07.752] future_lapply() ...
[15:31:07.757] Number of chunks: 2
[15:31:07.758] getGlobalsAndPackagesXApply() ...
[15:31:07.758]  - future.globals: <name-value list> with names 'list()'
[15:31:07.758]  - use_args: TRUE
[15:31:07.759] Globals to be used in all futures (chunks): [n=2] '...', '...future.FUN'
[15:31:07.759] List of 2
[15:31:07.759]  $ ...          : list()
[15:31:07.759]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:07.759]  $ ...future.FUN:function (x)  
[15:31:07.759]  - attr(*, "where")=List of 2
[15:31:07.759]   ..$ ...          :<environment: 0x000001bcb977cf40> 
[15:31:07.759]   ..$ ...future.FUN:<environment: R_GlobalEnv> 
[15:31:07.759]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:07.759]  - attr(*, "resolved")= logi FALSE
[15:31:07.759]  - attr(*, "total_size")= num NA
[15:31:07.765] Packages to be attached in all futures: [n=0] 
[15:31:07.765] getGlobalsAndPackagesXApply() ... DONE
[15:31:07.766] Number of futures (= number of chunks): 2
[15:31:07.766] Launching 2 futures (chunks) ...
[15:31:07.767] Chunk #1 of 2 ...
[15:31:07.767]  - Adjusted option 'future.globals.maxSize': Inf -> 2 * Inf = Inf (bytes)
[15:31:07.767]  - seeds: <none>
[15:31:07.768]  - All globals exported: [n=5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:07.768] getGlobalsAndPackages() ...
[15:31:07.768] - globals passed as-is: [5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:07.769] Resolving globals: FALSE
[15:31:07.769] Tweak future expression to call with '...' arguments ...
[15:31:07.769] {
[15:31:07.769]     do.call(function(...) {
[15:31:07.769]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:07.769]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:07.769]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:07.769]             on.exit(options(oopts), add = TRUE)
[15:31:07.769]         }
[15:31:07.769]         {
[15:31:07.769]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:07.769]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:07.769]                 ...future.FUN(...future.X_jj, ...)
[15:31:07.769]             })
[15:31:07.769]         }
[15:31:07.769]     }, args = future.call.arguments)
[15:31:07.769] }
[15:31:07.770] Tweak future expression to call with '...' arguments ... DONE
[15:31:07.771] - globals: [5] 'future.call.arguments', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:07.771] 
[15:31:07.771] getGlobalsAndPackages() ... DONE
[15:31:07.772] run() for 'Future' ...
[15:31:07.772] - state: 'created'
[15:31:07.773] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:07.792] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:07.792] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:31:07.793]   - Field: 'node'
[15:31:07.793]   - Field: 'label'
[15:31:07.793]   - Field: 'local'
[15:31:07.794]   - Field: 'owner'
[15:31:07.794]   - Field: 'envir'
[15:31:07.794]   - Field: 'workers'
[15:31:07.795]   - Field: 'packages'
[15:31:07.795]   - Field: 'gc'
[15:31:07.796]   - Field: 'conditions'
[15:31:07.796]   - Field: 'persistent'
[15:31:07.796]   - Field: 'expr'
[15:31:07.796]   - Field: 'uuid'
[15:31:07.797]   - Field: 'seed'
[15:31:07.797]   - Field: 'version'
[15:31:07.797]   - Field: 'result'
[15:31:07.797]   - Field: 'asynchronous'
[15:31:07.798]   - Field: 'calls'
[15:31:07.798]   - Field: 'globals'
[15:31:07.798]   - Field: 'stdout'
[15:31:07.798]   - Field: 'earlySignal'
[15:31:07.799]   - Field: 'lazy'
[15:31:07.799]   - Field: 'state'
[15:31:07.799] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:31:07.799] - Launch lazy future ...
[15:31:07.800] Packages needed by the future expression (n = 0): <none>
[15:31:07.800] Packages needed by future strategies (n = 0): <none>
[15:31:07.801] {
[15:31:07.801]     {
[15:31:07.801]         {
[15:31:07.801]             ...future.startTime <- base::Sys.time()
[15:31:07.801]             {
[15:31:07.801]                 {
[15:31:07.801]                   {
[15:31:07.801]                     {
[15:31:07.801]                       base::local({
[15:31:07.801]                         has_future <- base::requireNamespace("future", 
[15:31:07.801]                           quietly = TRUE)
[15:31:07.801]                         if (has_future) {
[15:31:07.801]                           ns <- base::getNamespace("future")
[15:31:07.801]                           version <- ns[[".package"]][["version"]]
[15:31:07.801]                           if (is.null(version)) 
[15:31:07.801]                             version <- utils::packageVersion("future")
[15:31:07.801]                         }
[15:31:07.801]                         else {
[15:31:07.801]                           version <- NULL
[15:31:07.801]                         }
[15:31:07.801]                         if (!has_future || version < "1.8.0") {
[15:31:07.801]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:07.801]                             "", base::R.version$version.string), 
[15:31:07.801]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:07.801]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:07.801]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:07.801]                               "release", "version")], collapse = " "), 
[15:31:07.801]                             hostname = base::Sys.info()[["nodename"]])
[15:31:07.801]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:07.801]                             info)
[15:31:07.801]                           info <- base::paste(info, collapse = "; ")
[15:31:07.801]                           if (!has_future) {
[15:31:07.801]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:07.801]                               info)
[15:31:07.801]                           }
[15:31:07.801]                           else {
[15:31:07.801]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:07.801]                               info, version)
[15:31:07.801]                           }
[15:31:07.801]                           base::stop(msg)
[15:31:07.801]                         }
[15:31:07.801]                       })
[15:31:07.801]                     }
[15:31:07.801]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:07.801]                     base::options(mc.cores = 1L)
[15:31:07.801]                   }
[15:31:07.801]                   ...future.strategy.old <- future::plan("list")
[15:31:07.801]                   options(future.plan = NULL)
[15:31:07.801]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:07.801]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:07.801]                 }
[15:31:07.801]                 ...future.workdir <- getwd()
[15:31:07.801]             }
[15:31:07.801]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:07.801]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:07.801]         }
[15:31:07.801]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:07.801]             future.globals.maxSize = Inf, future.globals.method = NULL, 
[15:31:07.801]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:07.801]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:07.801]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:07.801]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:07.801]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:07.801]             base::names(...future.oldOptions))
[15:31:07.801]     }
[15:31:07.801]     if (FALSE) {
[15:31:07.801]     }
[15:31:07.801]     else {
[15:31:07.801]         if (TRUE) {
[15:31:07.801]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:07.801]                 open = "w")
[15:31:07.801]         }
[15:31:07.801]         else {
[15:31:07.801]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:07.801]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:07.801]         }
[15:31:07.801]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:07.801]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:07.801]             base::sink(type = "output", split = FALSE)
[15:31:07.801]             base::close(...future.stdout)
[15:31:07.801]         }, add = TRUE)
[15:31:07.801]     }
[15:31:07.801]     ...future.frame <- base::sys.nframe()
[15:31:07.801]     ...future.conditions <- base::list()
[15:31:07.801]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:07.801]     if (FALSE) {
[15:31:07.801]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:07.801]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:07.801]     }
[15:31:07.801]     ...future.result <- base::tryCatch({
[15:31:07.801]         base::withCallingHandlers({
[15:31:07.801]             ...future.value <- base::withVisible(base::local({
[15:31:07.801]                 ...future.makeSendCondition <- base::local({
[15:31:07.801]                   sendCondition <- NULL
[15:31:07.801]                   function(frame = 1L) {
[15:31:07.801]                     if (is.function(sendCondition)) 
[15:31:07.801]                       return(sendCondition)
[15:31:07.801]                     ns <- getNamespace("parallel")
[15:31:07.801]                     if (exists("sendData", mode = "function", 
[15:31:07.801]                       envir = ns)) {
[15:31:07.801]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:07.801]                         envir = ns)
[15:31:07.801]                       envir <- sys.frame(frame)
[15:31:07.801]                       master <- NULL
[15:31:07.801]                       while (!identical(envir, .GlobalEnv) && 
[15:31:07.801]                         !identical(envir, emptyenv())) {
[15:31:07.801]                         if (exists("master", mode = "list", envir = envir, 
[15:31:07.801]                           inherits = FALSE)) {
[15:31:07.801]                           master <- get("master", mode = "list", 
[15:31:07.801]                             envir = envir, inherits = FALSE)
[15:31:07.801]                           if (inherits(master, c("SOCKnode", 
[15:31:07.801]                             "SOCK0node"))) {
[15:31:07.801]                             sendCondition <<- function(cond) {
[15:31:07.801]                               data <- list(type = "VALUE", value = cond, 
[15:31:07.801]                                 success = TRUE)
[15:31:07.801]                               parallel_sendData(master, data)
[15:31:07.801]                             }
[15:31:07.801]                             return(sendCondition)
[15:31:07.801]                           }
[15:31:07.801]                         }
[15:31:07.801]                         frame <- frame + 1L
[15:31:07.801]                         envir <- sys.frame(frame)
[15:31:07.801]                       }
[15:31:07.801]                     }
[15:31:07.801]                     sendCondition <<- function(cond) NULL
[15:31:07.801]                   }
[15:31:07.801]                 })
[15:31:07.801]                 withCallingHandlers({
[15:31:07.801]                   {
[15:31:07.801]                     do.call(function(...) {
[15:31:07.801]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:07.801]                       if (!identical(...future.globals.maxSize.org, 
[15:31:07.801]                         ...future.globals.maxSize)) {
[15:31:07.801]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:07.801]                         on.exit(options(oopts), add = TRUE)
[15:31:07.801]                       }
[15:31:07.801]                       {
[15:31:07.801]                         lapply(seq_along(...future.elements_ii), 
[15:31:07.801]                           FUN = function(jj) {
[15:31:07.801]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:07.801]                             ...future.FUN(...future.X_jj, ...)
[15:31:07.801]                           })
[15:31:07.801]                       }
[15:31:07.801]                     }, args = future.call.arguments)
[15:31:07.801]                   }
[15:31:07.801]                 }, immediateCondition = function(cond) {
[15:31:07.801]                   sendCondition <- ...future.makeSendCondition()
[15:31:07.801]                   sendCondition(cond)
[15:31:07.801]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:07.801]                   {
[15:31:07.801]                     inherits <- base::inherits
[15:31:07.801]                     invokeRestart <- base::invokeRestart
[15:31:07.801]                     is.null <- base::is.null
[15:31:07.801]                     muffled <- FALSE
[15:31:07.801]                     if (inherits(cond, "message")) {
[15:31:07.801]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:07.801]                       if (muffled) 
[15:31:07.801]                         invokeRestart("muffleMessage")
[15:31:07.801]                     }
[15:31:07.801]                     else if (inherits(cond, "warning")) {
[15:31:07.801]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:07.801]                       if (muffled) 
[15:31:07.801]                         invokeRestart("muffleWarning")
[15:31:07.801]                     }
[15:31:07.801]                     else if (inherits(cond, "condition")) {
[15:31:07.801]                       if (!is.null(pattern)) {
[15:31:07.801]                         computeRestarts <- base::computeRestarts
[15:31:07.801]                         grepl <- base::grepl
[15:31:07.801]                         restarts <- computeRestarts(cond)
[15:31:07.801]                         for (restart in restarts) {
[15:31:07.801]                           name <- restart$name
[15:31:07.801]                           if (is.null(name)) 
[15:31:07.801]                             next
[15:31:07.801]                           if (!grepl(pattern, name)) 
[15:31:07.801]                             next
[15:31:07.801]                           invokeRestart(restart)
[15:31:07.801]                           muffled <- TRUE
[15:31:07.801]                           break
[15:31:07.801]                         }
[15:31:07.801]                       }
[15:31:07.801]                     }
[15:31:07.801]                     invisible(muffled)
[15:31:07.801]                   }
[15:31:07.801]                   muffleCondition(cond)
[15:31:07.801]                 })
[15:31:07.801]             }))
[15:31:07.801]             future::FutureResult(value = ...future.value$value, 
[15:31:07.801]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:07.801]                   ...future.rng), globalenv = if (FALSE) 
[15:31:07.801]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:07.801]                     ...future.globalenv.names))
[15:31:07.801]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:07.801]         }, condition = base::local({
[15:31:07.801]             c <- base::c
[15:31:07.801]             inherits <- base::inherits
[15:31:07.801]             invokeRestart <- base::invokeRestart
[15:31:07.801]             length <- base::length
[15:31:07.801]             list <- base::list
[15:31:07.801]             seq.int <- base::seq.int
[15:31:07.801]             signalCondition <- base::signalCondition
[15:31:07.801]             sys.calls <- base::sys.calls
[15:31:07.801]             `[[` <- base::`[[`
[15:31:07.801]             `+` <- base::`+`
[15:31:07.801]             `<<-` <- base::`<<-`
[15:31:07.801]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:07.801]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:07.801]                   3L)]
[15:31:07.801]             }
[15:31:07.801]             function(cond) {
[15:31:07.801]                 is_error <- inherits(cond, "error")
[15:31:07.801]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:07.801]                   NULL)
[15:31:07.801]                 if (is_error) {
[15:31:07.801]                   sessionInformation <- function() {
[15:31:07.801]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:07.801]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:07.801]                       search = base::search(), system = base::Sys.info())
[15:31:07.801]                   }
[15:31:07.801]                   ...future.conditions[[length(...future.conditions) + 
[15:31:07.801]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:07.801]                     cond$call), session = sessionInformation(), 
[15:31:07.801]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:07.801]                   signalCondition(cond)
[15:31:07.801]                 }
[15:31:07.801]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:07.801]                 "immediateCondition"))) {
[15:31:07.801]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:07.801]                   ...future.conditions[[length(...future.conditions) + 
[15:31:07.801]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:07.801]                   if (TRUE && !signal) {
[15:31:07.801]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:07.801]                     {
[15:31:07.801]                       inherits <- base::inherits
[15:31:07.801]                       invokeRestart <- base::invokeRestart
[15:31:07.801]                       is.null <- base::is.null
[15:31:07.801]                       muffled <- FALSE
[15:31:07.801]                       if (inherits(cond, "message")) {
[15:31:07.801]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:07.801]                         if (muffled) 
[15:31:07.801]                           invokeRestart("muffleMessage")
[15:31:07.801]                       }
[15:31:07.801]                       else if (inherits(cond, "warning")) {
[15:31:07.801]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:07.801]                         if (muffled) 
[15:31:07.801]                           invokeRestart("muffleWarning")
[15:31:07.801]                       }
[15:31:07.801]                       else if (inherits(cond, "condition")) {
[15:31:07.801]                         if (!is.null(pattern)) {
[15:31:07.801]                           computeRestarts <- base::computeRestarts
[15:31:07.801]                           grepl <- base::grepl
[15:31:07.801]                           restarts <- computeRestarts(cond)
[15:31:07.801]                           for (restart in restarts) {
[15:31:07.801]                             name <- restart$name
[15:31:07.801]                             if (is.null(name)) 
[15:31:07.801]                               next
[15:31:07.801]                             if (!grepl(pattern, name)) 
[15:31:07.801]                               next
[15:31:07.801]                             invokeRestart(restart)
[15:31:07.801]                             muffled <- TRUE
[15:31:07.801]                             break
[15:31:07.801]                           }
[15:31:07.801]                         }
[15:31:07.801]                       }
[15:31:07.801]                       invisible(muffled)
[15:31:07.801]                     }
[15:31:07.801]                     muffleCondition(cond, pattern = "^muffle")
[15:31:07.801]                   }
[15:31:07.801]                 }
[15:31:07.801]                 else {
[15:31:07.801]                   if (TRUE) {
[15:31:07.801]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:07.801]                     {
[15:31:07.801]                       inherits <- base::inherits
[15:31:07.801]                       invokeRestart <- base::invokeRestart
[15:31:07.801]                       is.null <- base::is.null
[15:31:07.801]                       muffled <- FALSE
[15:31:07.801]                       if (inherits(cond, "message")) {
[15:31:07.801]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:07.801]                         if (muffled) 
[15:31:07.801]                           invokeRestart("muffleMessage")
[15:31:07.801]                       }
[15:31:07.801]                       else if (inherits(cond, "warning")) {
[15:31:07.801]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:07.801]                         if (muffled) 
[15:31:07.801]                           invokeRestart("muffleWarning")
[15:31:07.801]                       }
[15:31:07.801]                       else if (inherits(cond, "condition")) {
[15:31:07.801]                         if (!is.null(pattern)) {
[15:31:07.801]                           computeRestarts <- base::computeRestarts
[15:31:07.801]                           grepl <- base::grepl
[15:31:07.801]                           restarts <- computeRestarts(cond)
[15:31:07.801]                           for (restart in restarts) {
[15:31:07.801]                             name <- restart$name
[15:31:07.801]                             if (is.null(name)) 
[15:31:07.801]                               next
[15:31:07.801]                             if (!grepl(pattern, name)) 
[15:31:07.801]                               next
[15:31:07.801]                             invokeRestart(restart)
[15:31:07.801]                             muffled <- TRUE
[15:31:07.801]                             break
[15:31:07.801]                           }
[15:31:07.801]                         }
[15:31:07.801]                       }
[15:31:07.801]                       invisible(muffled)
[15:31:07.801]                     }
[15:31:07.801]                     muffleCondition(cond, pattern = "^muffle")
[15:31:07.801]                   }
[15:31:07.801]                 }
[15:31:07.801]             }
[15:31:07.801]         }))
[15:31:07.801]     }, error = function(ex) {
[15:31:07.801]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:07.801]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:07.801]                 ...future.rng), started = ...future.startTime, 
[15:31:07.801]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:07.801]             version = "1.8"), class = "FutureResult")
[15:31:07.801]     }, finally = {
[15:31:07.801]         if (!identical(...future.workdir, getwd())) 
[15:31:07.801]             setwd(...future.workdir)
[15:31:07.801]         {
[15:31:07.801]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:07.801]                 ...future.oldOptions$nwarnings <- NULL
[15:31:07.801]             }
[15:31:07.801]             base::options(...future.oldOptions)
[15:31:07.801]             if (.Platform$OS.type == "windows") {
[15:31:07.801]                 old_names <- names(...future.oldEnvVars)
[15:31:07.801]                 envs <- base::Sys.getenv()
[15:31:07.801]                 names <- names(envs)
[15:31:07.801]                 common <- intersect(names, old_names)
[15:31:07.801]                 added <- setdiff(names, old_names)
[15:31:07.801]                 removed <- setdiff(old_names, names)
[15:31:07.801]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:07.801]                   envs[common]]
[15:31:07.801]                 NAMES <- toupper(changed)
[15:31:07.801]                 args <- list()
[15:31:07.801]                 for (kk in seq_along(NAMES)) {
[15:31:07.801]                   name <- changed[[kk]]
[15:31:07.801]                   NAME <- NAMES[[kk]]
[15:31:07.801]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:07.801]                     next
[15:31:07.801]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:07.801]                 }
[15:31:07.801]                 NAMES <- toupper(added)
[15:31:07.801]                 for (kk in seq_along(NAMES)) {
[15:31:07.801]                   name <- added[[kk]]
[15:31:07.801]                   NAME <- NAMES[[kk]]
[15:31:07.801]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:07.801]                     next
[15:31:07.801]                   args[[name]] <- ""
[15:31:07.801]                 }
[15:31:07.801]                 NAMES <- toupper(removed)
[15:31:07.801]                 for (kk in seq_along(NAMES)) {
[15:31:07.801]                   name <- removed[[kk]]
[15:31:07.801]                   NAME <- NAMES[[kk]]
[15:31:07.801]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:07.801]                     next
[15:31:07.801]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:07.801]                 }
[15:31:07.801]                 if (length(args) > 0) 
[15:31:07.801]                   base::do.call(base::Sys.setenv, args = args)
[15:31:07.801]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:07.801]             }
[15:31:07.801]             else {
[15:31:07.801]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:07.801]             }
[15:31:07.801]             {
[15:31:07.801]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:07.801]                   0L) {
[15:31:07.801]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:07.801]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:07.801]                   base::options(opts)
[15:31:07.801]                 }
[15:31:07.801]                 {
[15:31:07.801]                   {
[15:31:07.801]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:07.801]                     NULL
[15:31:07.801]                   }
[15:31:07.801]                   options(future.plan = NULL)
[15:31:07.801]                   if (is.na(NA_character_)) 
[15:31:07.801]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:07.801]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:07.801]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:07.801]                     .init = FALSE)
[15:31:07.801]                 }
[15:31:07.801]             }
[15:31:07.801]         }
[15:31:07.801]     })
[15:31:07.801]     if (TRUE) {
[15:31:07.801]         base::sink(type = "output", split = FALSE)
[15:31:07.801]         if (TRUE) {
[15:31:07.801]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:07.801]         }
[15:31:07.801]         else {
[15:31:07.801]             ...future.result["stdout"] <- base::list(NULL)
[15:31:07.801]         }
[15:31:07.801]         base::close(...future.stdout)
[15:31:07.801]         ...future.stdout <- NULL
[15:31:07.801]     }
[15:31:07.801]     ...future.result$conditions <- ...future.conditions
[15:31:07.801]     ...future.result$finished <- base::Sys.time()
[15:31:07.801]     ...future.result
[15:31:07.801] }
[15:31:07.809] Exporting 5 global objects (1.97 KiB) to cluster node #1 ...
[15:31:07.810] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:31:07.810] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:31:07.811] Exporting '...future.FUN' (1.73 KiB) to cluster node #1 ...
[15:31:07.811] Exporting '...future.FUN' (1.73 KiB) to cluster node #1 ... DONE
[15:31:07.811] Exporting '...future.elements_ii' (192 bytes) to cluster node #1 ...
[15:31:07.812] Exporting '...future.elements_ii' (192 bytes) to cluster node #1 ... DONE
[15:31:07.812] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:31:07.813] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:31:07.813] Exporting '...future.globals.maxSize' (56 bytes) to cluster node #1 ...
[15:31:07.814] Exporting '...future.globals.maxSize' (56 bytes) to cluster node #1 ... DONE
[15:31:07.814] Exporting 5 global objects (1.97 KiB) to cluster node #1 ... DONE
[15:31:07.815] MultisessionFuture started
[15:31:07.815] - Launch lazy future ... done
[15:31:07.815] run() for 'MultisessionFuture' ... done
[15:31:07.816] Created future:
[15:31:07.843] receiveMessageFromWorker() for ClusterFuture ...
[15:31:07.843] - Validating connection of MultisessionFuture
[15:31:07.843] - received message: FutureResult
[15:31:07.844] - Received FutureResult
[15:31:07.844] - Erased future from FutureRegistry
[15:31:07.844] result() for ClusterFuture ...
[15:31:07.844] - result already collected: FutureResult
[15:31:07.844] result() for ClusterFuture ... done
[15:31:07.844] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:07.816] MultisessionFuture:
[15:31:07.816] Label: 'future_apply-1'
[15:31:07.816] Expression:
[15:31:07.816] {
[15:31:07.816]     do.call(function(...) {
[15:31:07.816]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:07.816]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:07.816]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:07.816]             on.exit(options(oopts), add = TRUE)
[15:31:07.816]         }
[15:31:07.816]         {
[15:31:07.816]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:07.816]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:07.816]                 ...future.FUN(...future.X_jj, ...)
[15:31:07.816]             })
[15:31:07.816]         }
[15:31:07.816]     }, args = future.call.arguments)
[15:31:07.816] }
[15:31:07.816] Lazy evaluation: FALSE
[15:31:07.816] Asynchronous evaluation: TRUE
[15:31:07.816] Local evaluation: TRUE
[15:31:07.816] Environment: R_GlobalEnv
[15:31:07.816] Capture standard output: TRUE
[15:31:07.816] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:07.816] Globals: 5 objects totaling 1.97 KiB (DotDotDotList 'future.call.arguments' of 0 bytes, function '...future.FUN' of 1.73 KiB, list '...future.elements_ii' of 192 bytes, NULL '...future.seeds_ii' of 0 bytes, numeric '...future.globals.maxSize' of 56 bytes)
[15:31:07.816] Packages: <none>
[15:31:07.816] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:07.816] Resolved: TRUE
[15:31:07.816] Value: <not collected>
[15:31:07.816] Conditions captured: <none>
[15:31:07.816] Early signaling: FALSE
[15:31:07.816] Owner process: 6672a580-6d3c-e82f-380e-108c475ace70
[15:31:07.816] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:07.845] Chunk #1 of 2 ... DONE
[15:31:07.845] Chunk #2 of 2 ...
[15:31:07.846]  - Adjusted option 'future.globals.maxSize': Inf -> 2 * Inf = Inf (bytes)
[15:31:07.846]  - seeds: <none>
[15:31:07.846]  - All globals exported: [n=5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:07.846] getGlobalsAndPackages() ...
[15:31:07.846] - globals passed as-is: [5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:07.846] Resolving globals: FALSE
[15:31:07.847] Tweak future expression to call with '...' arguments ...
[15:31:07.847] {
[15:31:07.847]     do.call(function(...) {
[15:31:07.847]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:07.847]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:07.847]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:07.847]             on.exit(options(oopts), add = TRUE)
[15:31:07.847]         }
[15:31:07.847]         {
[15:31:07.847]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:07.847]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:07.847]                 ...future.FUN(...future.X_jj, ...)
[15:31:07.847]             })
[15:31:07.847]         }
[15:31:07.847]     }, args = future.call.arguments)
[15:31:07.847] }
[15:31:07.847] Tweak future expression to call with '...' arguments ... DONE
[15:31:07.848] - globals: [5] 'future.call.arguments', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:07.848] 
[15:31:07.848] getGlobalsAndPackages() ... DONE
[15:31:07.849] run() for 'Future' ...
[15:31:07.849] - state: 'created'
[15:31:07.849] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:07.865] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:07.866] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:31:07.866]   - Field: 'node'
[15:31:07.866]   - Field: 'label'
[15:31:07.866]   - Field: 'local'
[15:31:07.867]   - Field: 'owner'
[15:31:07.867]   - Field: 'envir'
[15:31:07.867]   - Field: 'workers'
[15:31:07.867]   - Field: 'packages'
[15:31:07.867]   - Field: 'gc'
[15:31:07.868]   - Field: 'conditions'
[15:31:07.868]   - Field: 'persistent'
[15:31:07.868]   - Field: 'expr'
[15:31:07.868]   - Field: 'uuid'
[15:31:07.868]   - Field: 'seed'
[15:31:07.869]   - Field: 'version'
[15:31:07.869]   - Field: 'result'
[15:31:07.869]   - Field: 'asynchronous'
[15:31:07.869]   - Field: 'calls'
[15:31:07.869]   - Field: 'globals'
[15:31:07.869]   - Field: 'stdout'
[15:31:07.870]   - Field: 'earlySignal'
[15:31:07.870]   - Field: 'lazy'
[15:31:07.870]   - Field: 'state'
[15:31:07.870] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:31:07.870] - Launch lazy future ...
[15:31:07.871] Packages needed by the future expression (n = 0): <none>
[15:31:07.871] Packages needed by future strategies (n = 0): <none>
[15:31:07.872] {
[15:31:07.872]     {
[15:31:07.872]         {
[15:31:07.872]             ...future.startTime <- base::Sys.time()
[15:31:07.872]             {
[15:31:07.872]                 {
[15:31:07.872]                   {
[15:31:07.872]                     {
[15:31:07.872]                       base::local({
[15:31:07.872]                         has_future <- base::requireNamespace("future", 
[15:31:07.872]                           quietly = TRUE)
[15:31:07.872]                         if (has_future) {
[15:31:07.872]                           ns <- base::getNamespace("future")
[15:31:07.872]                           version <- ns[[".package"]][["version"]]
[15:31:07.872]                           if (is.null(version)) 
[15:31:07.872]                             version <- utils::packageVersion("future")
[15:31:07.872]                         }
[15:31:07.872]                         else {
[15:31:07.872]                           version <- NULL
[15:31:07.872]                         }
[15:31:07.872]                         if (!has_future || version < "1.8.0") {
[15:31:07.872]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:07.872]                             "", base::R.version$version.string), 
[15:31:07.872]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:07.872]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:07.872]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:07.872]                               "release", "version")], collapse = " "), 
[15:31:07.872]                             hostname = base::Sys.info()[["nodename"]])
[15:31:07.872]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:07.872]                             info)
[15:31:07.872]                           info <- base::paste(info, collapse = "; ")
[15:31:07.872]                           if (!has_future) {
[15:31:07.872]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:07.872]                               info)
[15:31:07.872]                           }
[15:31:07.872]                           else {
[15:31:07.872]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:07.872]                               info, version)
[15:31:07.872]                           }
[15:31:07.872]                           base::stop(msg)
[15:31:07.872]                         }
[15:31:07.872]                       })
[15:31:07.872]                     }
[15:31:07.872]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:07.872]                     base::options(mc.cores = 1L)
[15:31:07.872]                   }
[15:31:07.872]                   ...future.strategy.old <- future::plan("list")
[15:31:07.872]                   options(future.plan = NULL)
[15:31:07.872]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:07.872]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:07.872]                 }
[15:31:07.872]                 ...future.workdir <- getwd()
[15:31:07.872]             }
[15:31:07.872]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:07.872]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:07.872]         }
[15:31:07.872]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:07.872]             future.globals.maxSize = Inf, future.globals.method = NULL, 
[15:31:07.872]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:07.872]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:07.872]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:07.872]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:07.872]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:07.872]             base::names(...future.oldOptions))
[15:31:07.872]     }
[15:31:07.872]     if (FALSE) {
[15:31:07.872]     }
[15:31:07.872]     else {
[15:31:07.872]         if (TRUE) {
[15:31:07.872]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:07.872]                 open = "w")
[15:31:07.872]         }
[15:31:07.872]         else {
[15:31:07.872]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:07.872]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:07.872]         }
[15:31:07.872]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:07.872]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:07.872]             base::sink(type = "output", split = FALSE)
[15:31:07.872]             base::close(...future.stdout)
[15:31:07.872]         }, add = TRUE)
[15:31:07.872]     }
[15:31:07.872]     ...future.frame <- base::sys.nframe()
[15:31:07.872]     ...future.conditions <- base::list()
[15:31:07.872]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:07.872]     if (FALSE) {
[15:31:07.872]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:07.872]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:07.872]     }
[15:31:07.872]     ...future.result <- base::tryCatch({
[15:31:07.872]         base::withCallingHandlers({
[15:31:07.872]             ...future.value <- base::withVisible(base::local({
[15:31:07.872]                 ...future.makeSendCondition <- base::local({
[15:31:07.872]                   sendCondition <- NULL
[15:31:07.872]                   function(frame = 1L) {
[15:31:07.872]                     if (is.function(sendCondition)) 
[15:31:07.872]                       return(sendCondition)
[15:31:07.872]                     ns <- getNamespace("parallel")
[15:31:07.872]                     if (exists("sendData", mode = "function", 
[15:31:07.872]                       envir = ns)) {
[15:31:07.872]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:07.872]                         envir = ns)
[15:31:07.872]                       envir <- sys.frame(frame)
[15:31:07.872]                       master <- NULL
[15:31:07.872]                       while (!identical(envir, .GlobalEnv) && 
[15:31:07.872]                         !identical(envir, emptyenv())) {
[15:31:07.872]                         if (exists("master", mode = "list", envir = envir, 
[15:31:07.872]                           inherits = FALSE)) {
[15:31:07.872]                           master <- get("master", mode = "list", 
[15:31:07.872]                             envir = envir, inherits = FALSE)
[15:31:07.872]                           if (inherits(master, c("SOCKnode", 
[15:31:07.872]                             "SOCK0node"))) {
[15:31:07.872]                             sendCondition <<- function(cond) {
[15:31:07.872]                               data <- list(type = "VALUE", value = cond, 
[15:31:07.872]                                 success = TRUE)
[15:31:07.872]                               parallel_sendData(master, data)
[15:31:07.872]                             }
[15:31:07.872]                             return(sendCondition)
[15:31:07.872]                           }
[15:31:07.872]                         }
[15:31:07.872]                         frame <- frame + 1L
[15:31:07.872]                         envir <- sys.frame(frame)
[15:31:07.872]                       }
[15:31:07.872]                     }
[15:31:07.872]                     sendCondition <<- function(cond) NULL
[15:31:07.872]                   }
[15:31:07.872]                 })
[15:31:07.872]                 withCallingHandlers({
[15:31:07.872]                   {
[15:31:07.872]                     do.call(function(...) {
[15:31:07.872]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:07.872]                       if (!identical(...future.globals.maxSize.org, 
[15:31:07.872]                         ...future.globals.maxSize)) {
[15:31:07.872]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:07.872]                         on.exit(options(oopts), add = TRUE)
[15:31:07.872]                       }
[15:31:07.872]                       {
[15:31:07.872]                         lapply(seq_along(...future.elements_ii), 
[15:31:07.872]                           FUN = function(jj) {
[15:31:07.872]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:07.872]                             ...future.FUN(...future.X_jj, ...)
[15:31:07.872]                           })
[15:31:07.872]                       }
[15:31:07.872]                     }, args = future.call.arguments)
[15:31:07.872]                   }
[15:31:07.872]                 }, immediateCondition = function(cond) {
[15:31:07.872]                   sendCondition <- ...future.makeSendCondition()
[15:31:07.872]                   sendCondition(cond)
[15:31:07.872]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:07.872]                   {
[15:31:07.872]                     inherits <- base::inherits
[15:31:07.872]                     invokeRestart <- base::invokeRestart
[15:31:07.872]                     is.null <- base::is.null
[15:31:07.872]                     muffled <- FALSE
[15:31:07.872]                     if (inherits(cond, "message")) {
[15:31:07.872]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:07.872]                       if (muffled) 
[15:31:07.872]                         invokeRestart("muffleMessage")
[15:31:07.872]                     }
[15:31:07.872]                     else if (inherits(cond, "warning")) {
[15:31:07.872]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:07.872]                       if (muffled) 
[15:31:07.872]                         invokeRestart("muffleWarning")
[15:31:07.872]                     }
[15:31:07.872]                     else if (inherits(cond, "condition")) {
[15:31:07.872]                       if (!is.null(pattern)) {
[15:31:07.872]                         computeRestarts <- base::computeRestarts
[15:31:07.872]                         grepl <- base::grepl
[15:31:07.872]                         restarts <- computeRestarts(cond)
[15:31:07.872]                         for (restart in restarts) {
[15:31:07.872]                           name <- restart$name
[15:31:07.872]                           if (is.null(name)) 
[15:31:07.872]                             next
[15:31:07.872]                           if (!grepl(pattern, name)) 
[15:31:07.872]                             next
[15:31:07.872]                           invokeRestart(restart)
[15:31:07.872]                           muffled <- TRUE
[15:31:07.872]                           break
[15:31:07.872]                         }
[15:31:07.872]                       }
[15:31:07.872]                     }
[15:31:07.872]                     invisible(muffled)
[15:31:07.872]                   }
[15:31:07.872]                   muffleCondition(cond)
[15:31:07.872]                 })
[15:31:07.872]             }))
[15:31:07.872]             future::FutureResult(value = ...future.value$value, 
[15:31:07.872]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:07.872]                   ...future.rng), globalenv = if (FALSE) 
[15:31:07.872]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:07.872]                     ...future.globalenv.names))
[15:31:07.872]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:07.872]         }, condition = base::local({
[15:31:07.872]             c <- base::c
[15:31:07.872]             inherits <- base::inherits
[15:31:07.872]             invokeRestart <- base::invokeRestart
[15:31:07.872]             length <- base::length
[15:31:07.872]             list <- base::list
[15:31:07.872]             seq.int <- base::seq.int
[15:31:07.872]             signalCondition <- base::signalCondition
[15:31:07.872]             sys.calls <- base::sys.calls
[15:31:07.872]             `[[` <- base::`[[`
[15:31:07.872]             `+` <- base::`+`
[15:31:07.872]             `<<-` <- base::`<<-`
[15:31:07.872]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:07.872]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:07.872]                   3L)]
[15:31:07.872]             }
[15:31:07.872]             function(cond) {
[15:31:07.872]                 is_error <- inherits(cond, "error")
[15:31:07.872]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:07.872]                   NULL)
[15:31:07.872]                 if (is_error) {
[15:31:07.872]                   sessionInformation <- function() {
[15:31:07.872]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:07.872]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:07.872]                       search = base::search(), system = base::Sys.info())
[15:31:07.872]                   }
[15:31:07.872]                   ...future.conditions[[length(...future.conditions) + 
[15:31:07.872]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:07.872]                     cond$call), session = sessionInformation(), 
[15:31:07.872]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:07.872]                   signalCondition(cond)
[15:31:07.872]                 }
[15:31:07.872]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:07.872]                 "immediateCondition"))) {
[15:31:07.872]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:07.872]                   ...future.conditions[[length(...future.conditions) + 
[15:31:07.872]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:07.872]                   if (TRUE && !signal) {
[15:31:07.872]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:07.872]                     {
[15:31:07.872]                       inherits <- base::inherits
[15:31:07.872]                       invokeRestart <- base::invokeRestart
[15:31:07.872]                       is.null <- base::is.null
[15:31:07.872]                       muffled <- FALSE
[15:31:07.872]                       if (inherits(cond, "message")) {
[15:31:07.872]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:07.872]                         if (muffled) 
[15:31:07.872]                           invokeRestart("muffleMessage")
[15:31:07.872]                       }
[15:31:07.872]                       else if (inherits(cond, "warning")) {
[15:31:07.872]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:07.872]                         if (muffled) 
[15:31:07.872]                           invokeRestart("muffleWarning")
[15:31:07.872]                       }
[15:31:07.872]                       else if (inherits(cond, "condition")) {
[15:31:07.872]                         if (!is.null(pattern)) {
[15:31:07.872]                           computeRestarts <- base::computeRestarts
[15:31:07.872]                           grepl <- base::grepl
[15:31:07.872]                           restarts <- computeRestarts(cond)
[15:31:07.872]                           for (restart in restarts) {
[15:31:07.872]                             name <- restart$name
[15:31:07.872]                             if (is.null(name)) 
[15:31:07.872]                               next
[15:31:07.872]                             if (!grepl(pattern, name)) 
[15:31:07.872]                               next
[15:31:07.872]                             invokeRestart(restart)
[15:31:07.872]                             muffled <- TRUE
[15:31:07.872]                             break
[15:31:07.872]                           }
[15:31:07.872]                         }
[15:31:07.872]                       }
[15:31:07.872]                       invisible(muffled)
[15:31:07.872]                     }
[15:31:07.872]                     muffleCondition(cond, pattern = "^muffle")
[15:31:07.872]                   }
[15:31:07.872]                 }
[15:31:07.872]                 else {
[15:31:07.872]                   if (TRUE) {
[15:31:07.872]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:07.872]                     {
[15:31:07.872]                       inherits <- base::inherits
[15:31:07.872]                       invokeRestart <- base::invokeRestart
[15:31:07.872]                       is.null <- base::is.null
[15:31:07.872]                       muffled <- FALSE
[15:31:07.872]                       if (inherits(cond, "message")) {
[15:31:07.872]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:07.872]                         if (muffled) 
[15:31:07.872]                           invokeRestart("muffleMessage")
[15:31:07.872]                       }
[15:31:07.872]                       else if (inherits(cond, "warning")) {
[15:31:07.872]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:07.872]                         if (muffled) 
[15:31:07.872]                           invokeRestart("muffleWarning")
[15:31:07.872]                       }
[15:31:07.872]                       else if (inherits(cond, "condition")) {
[15:31:07.872]                         if (!is.null(pattern)) {
[15:31:07.872]                           computeRestarts <- base::computeRestarts
[15:31:07.872]                           grepl <- base::grepl
[15:31:07.872]                           restarts <- computeRestarts(cond)
[15:31:07.872]                           for (restart in restarts) {
[15:31:07.872]                             name <- restart$name
[15:31:07.872]                             if (is.null(name)) 
[15:31:07.872]                               next
[15:31:07.872]                             if (!grepl(pattern, name)) 
[15:31:07.872]                               next
[15:31:07.872]                             invokeRestart(restart)
[15:31:07.872]                             muffled <- TRUE
[15:31:07.872]                             break
[15:31:07.872]                           }
[15:31:07.872]                         }
[15:31:07.872]                       }
[15:31:07.872]                       invisible(muffled)
[15:31:07.872]                     }
[15:31:07.872]                     muffleCondition(cond, pattern = "^muffle")
[15:31:07.872]                   }
[15:31:07.872]                 }
[15:31:07.872]             }
[15:31:07.872]         }))
[15:31:07.872]     }, error = function(ex) {
[15:31:07.872]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:07.872]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:07.872]                 ...future.rng), started = ...future.startTime, 
[15:31:07.872]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:07.872]             version = "1.8"), class = "FutureResult")
[15:31:07.872]     }, finally = {
[15:31:07.872]         if (!identical(...future.workdir, getwd())) 
[15:31:07.872]             setwd(...future.workdir)
[15:31:07.872]         {
[15:31:07.872]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:07.872]                 ...future.oldOptions$nwarnings <- NULL
[15:31:07.872]             }
[15:31:07.872]             base::options(...future.oldOptions)
[15:31:07.872]             if (.Platform$OS.type == "windows") {
[15:31:07.872]                 old_names <- names(...future.oldEnvVars)
[15:31:07.872]                 envs <- base::Sys.getenv()
[15:31:07.872]                 names <- names(envs)
[15:31:07.872]                 common <- intersect(names, old_names)
[15:31:07.872]                 added <- setdiff(names, old_names)
[15:31:07.872]                 removed <- setdiff(old_names, names)
[15:31:07.872]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:07.872]                   envs[common]]
[15:31:07.872]                 NAMES <- toupper(changed)
[15:31:07.872]                 args <- list()
[15:31:07.872]                 for (kk in seq_along(NAMES)) {
[15:31:07.872]                   name <- changed[[kk]]
[15:31:07.872]                   NAME <- NAMES[[kk]]
[15:31:07.872]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:07.872]                     next
[15:31:07.872]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:07.872]                 }
[15:31:07.872]                 NAMES <- toupper(added)
[15:31:07.872]                 for (kk in seq_along(NAMES)) {
[15:31:07.872]                   name <- added[[kk]]
[15:31:07.872]                   NAME <- NAMES[[kk]]
[15:31:07.872]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:07.872]                     next
[15:31:07.872]                   args[[name]] <- ""
[15:31:07.872]                 }
[15:31:07.872]                 NAMES <- toupper(removed)
[15:31:07.872]                 for (kk in seq_along(NAMES)) {
[15:31:07.872]                   name <- removed[[kk]]
[15:31:07.872]                   NAME <- NAMES[[kk]]
[15:31:07.872]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:07.872]                     next
[15:31:07.872]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:07.872]                 }
[15:31:07.872]                 if (length(args) > 0) 
[15:31:07.872]                   base::do.call(base::Sys.setenv, args = args)
[15:31:07.872]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:07.872]             }
[15:31:07.872]             else {
[15:31:07.872]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:07.872]             }
[15:31:07.872]             {
[15:31:07.872]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:07.872]                   0L) {
[15:31:07.872]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:07.872]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:07.872]                   base::options(opts)
[15:31:07.872]                 }
[15:31:07.872]                 {
[15:31:07.872]                   {
[15:31:07.872]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:07.872]                     NULL
[15:31:07.872]                   }
[15:31:07.872]                   options(future.plan = NULL)
[15:31:07.872]                   if (is.na(NA_character_)) 
[15:31:07.872]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:07.872]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:07.872]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:07.872]                     .init = FALSE)
[15:31:07.872]                 }
[15:31:07.872]             }
[15:31:07.872]         }
[15:31:07.872]     })
[15:31:07.872]     if (TRUE) {
[15:31:07.872]         base::sink(type = "output", split = FALSE)
[15:31:07.872]         if (TRUE) {
[15:31:07.872]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:07.872]         }
[15:31:07.872]         else {
[15:31:07.872]             ...future.result["stdout"] <- base::list(NULL)
[15:31:07.872]         }
[15:31:07.872]         base::close(...future.stdout)
[15:31:07.872]         ...future.stdout <- NULL
[15:31:07.872]     }
[15:31:07.872]     ...future.result$conditions <- ...future.conditions
[15:31:07.872]     ...future.result$finished <- base::Sys.time()
[15:31:07.872]     ...future.result
[15:31:07.872] }
[15:31:07.878] Exporting 5 global objects (1.97 KiB) to cluster node #1 ...
[15:31:07.879] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:31:07.879] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:31:07.880] Exporting '...future.FUN' (1.73 KiB) to cluster node #1 ...
[15:31:07.880] Exporting '...future.FUN' (1.73 KiB) to cluster node #1 ... DONE
[15:31:07.881] Exporting '...future.elements_ii' (192 bytes) to cluster node #1 ...
[15:31:07.881] Exporting '...future.elements_ii' (192 bytes) to cluster node #1 ... DONE
[15:31:07.882] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:31:07.882] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:31:07.882] Exporting '...future.globals.maxSize' (56 bytes) to cluster node #1 ...
[15:31:07.883] Exporting '...future.globals.maxSize' (56 bytes) to cluster node #1 ... DONE
[15:31:07.883] Exporting 5 global objects (1.97 KiB) to cluster node #1 ... DONE
[15:31:07.884] MultisessionFuture started
[15:31:07.884] - Launch lazy future ... done
[15:31:07.884] run() for 'MultisessionFuture' ... done
[15:31:07.884] Created future:
[15:31:07.901] receiveMessageFromWorker() for ClusterFuture ...
[15:31:07.901] - Validating connection of MultisessionFuture
[15:31:07.901] - received message: FutureResult
[15:31:07.901] - Received FutureResult
[15:31:07.902] - Erased future from FutureRegistry
[15:31:07.902] result() for ClusterFuture ...
[15:31:07.902] - result already collected: FutureResult
[15:31:07.902] result() for ClusterFuture ... done
[15:31:07.902] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:07.884] MultisessionFuture:
[15:31:07.884] Label: 'future_apply-2'
[15:31:07.884] Expression:
[15:31:07.884] {
[15:31:07.884]     do.call(function(...) {
[15:31:07.884]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:07.884]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:07.884]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:07.884]             on.exit(options(oopts), add = TRUE)
[15:31:07.884]         }
[15:31:07.884]         {
[15:31:07.884]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:07.884]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:07.884]                 ...future.FUN(...future.X_jj, ...)
[15:31:07.884]             })
[15:31:07.884]         }
[15:31:07.884]     }, args = future.call.arguments)
[15:31:07.884] }
[15:31:07.884] Lazy evaluation: FALSE
[15:31:07.884] Asynchronous evaluation: TRUE
[15:31:07.884] Local evaluation: TRUE
[15:31:07.884] Environment: R_GlobalEnv
[15:31:07.884] Capture standard output: TRUE
[15:31:07.884] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:07.884] Globals: 5 objects totaling 1.97 KiB (DotDotDotList 'future.call.arguments' of 0 bytes, function '...future.FUN' of 1.73 KiB, list '...future.elements_ii' of 192 bytes, NULL '...future.seeds_ii' of 0 bytes, numeric '...future.globals.maxSize' of 56 bytes)
[15:31:07.884] Packages: <none>
[15:31:07.884] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:07.884] Resolved: TRUE
[15:31:07.884] Value: <not collected>
[15:31:07.884] Conditions captured: <none>
[15:31:07.884] Early signaling: FALSE
[15:31:07.884] Owner process: 6672a580-6d3c-e82f-380e-108c475ace70
[15:31:07.884] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:07.903] Chunk #2 of 2 ... DONE
[15:31:07.903] Launching 2 futures (chunks) ... DONE
[15:31:07.903] Resolving 2 futures (chunks) ...
[15:31:07.903] resolve() on list ...
[15:31:07.904]  recursive: 0
[15:31:07.904]  length: 2
[15:31:07.904] 
[15:31:07.904] Future #1
[15:31:07.904] result() for ClusterFuture ...
[15:31:07.905] - result already collected: FutureResult
[15:31:07.905] result() for ClusterFuture ... done
[15:31:07.905] result() for ClusterFuture ...
[15:31:07.906] - result already collected: FutureResult
[15:31:07.906] result() for ClusterFuture ... done
[15:31:07.907] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:31:07.907] - nx: 2
[15:31:07.907] - relay: TRUE
[15:31:07.907] - stdout: TRUE
[15:31:07.908] - signal: TRUE
[15:31:07.908] - resignal: FALSE
[15:31:07.908] - force: TRUE
[15:31:07.909] - relayed: [n=2] FALSE, FALSE
[15:31:07.909] - queued futures: [n=2] FALSE, FALSE
[15:31:07.909]  - until=1
[15:31:07.909]  - relaying element #1
[15:31:07.910] result() for ClusterFuture ...
[15:31:07.910] - result already collected: FutureResult
[15:31:07.910] result() for ClusterFuture ... done
[15:31:07.911] result() for ClusterFuture ...
[15:31:07.911] - result already collected: FutureResult
[15:31:07.911] result() for ClusterFuture ... done
[15:31:07.912] result() for ClusterFuture ...
[15:31:07.912] - result already collected: FutureResult
[15:31:07.912] result() for ClusterFuture ... done
[15:31:07.912] result() for ClusterFuture ...
[15:31:07.913] - result already collected: FutureResult
[15:31:07.913] result() for ClusterFuture ... done
[15:31:07.913] - relayed: [n=2] TRUE, FALSE
[15:31:07.914] - queued futures: [n=2] TRUE, FALSE
[15:31:07.914] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:31:07.914]  length: 1 (resolved future 1)
[15:31:07.915] Future #2
[15:31:07.915] result() for ClusterFuture ...
[15:31:07.915] - result already collected: FutureResult
[15:31:07.915] result() for ClusterFuture ... done
[15:31:07.916] result() for ClusterFuture ...
[15:31:07.916] - result already collected: FutureResult
[15:31:07.916] result() for ClusterFuture ... done
[15:31:07.917] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:31:07.917] - nx: 2
[15:31:07.917] - relay: TRUE
[15:31:07.918] - stdout: TRUE
[15:31:07.918] - signal: TRUE
[15:31:07.918] - resignal: FALSE
[15:31:07.918] - force: TRUE
[15:31:07.919] - relayed: [n=2] TRUE, FALSE
[15:31:07.919] - queued futures: [n=2] TRUE, FALSE
[15:31:07.919]  - until=2
[15:31:07.920]  - relaying element #2
[15:31:07.920] result() for ClusterFuture ...
[15:31:07.920] - result already collected: FutureResult
[15:31:07.920] result() for ClusterFuture ... done
[15:31:07.921] result() for ClusterFuture ...
[15:31:07.921] - result already collected: FutureResult
[15:31:07.921] result() for ClusterFuture ... done
[15:31:07.922] result() for ClusterFuture ...
[15:31:07.922] - result already collected: FutureResult
[15:31:07.922] result() for ClusterFuture ... done
[15:31:07.923] result() for ClusterFuture ...
[15:31:07.923] - result already collected: FutureResult
[15:31:07.923] result() for ClusterFuture ... done
[15:31:07.923] - relayed: [n=2] TRUE, TRUE
[15:31:07.924] - queued futures: [n=2] TRUE, TRUE
[15:31:07.924] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:31:07.924]  length: 0 (resolved future 2)
[15:31:07.925] Relaying remaining futures
[15:31:07.925] signalConditionsASAP(NULL, pos=0) ...
[15:31:07.925] - nx: 2
[15:31:07.925] - relay: TRUE
[15:31:07.926] - stdout: TRUE
[15:31:07.926] - signal: TRUE
[15:31:07.926] - resignal: FALSE
[15:31:07.927] - force: TRUE
[15:31:07.927] - relayed: [n=2] TRUE, TRUE
[15:31:07.927] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:31:07.928] - relayed: [n=2] TRUE, TRUE
[15:31:07.928] - queued futures: [n=2] TRUE, TRUE
[15:31:07.928] signalConditionsASAP(NULL, pos=0) ... done
[15:31:07.928] resolve() on list ... DONE
[15:31:07.929] result() for ClusterFuture ...
[15:31:07.929] - result already collected: FutureResult
[15:31:07.929] result() for ClusterFuture ... done
[15:31:07.930] result() for ClusterFuture ...
[15:31:07.930] - result already collected: FutureResult
[15:31:07.930] result() for ClusterFuture ... done
[15:31:07.931] result() for ClusterFuture ...
[15:31:07.931] - result already collected: FutureResult
[15:31:07.931] result() for ClusterFuture ... done
[15:31:07.931] result() for ClusterFuture ...
[15:31:07.932] - result already collected: FutureResult
[15:31:07.932] result() for ClusterFuture ... done
[15:31:07.932]  - Number of value chunks collected: 2
[15:31:07.933] Resolving 2 futures (chunks) ... DONE
[15:31:07.933] Reducing values from 2 chunks ...
[15:31:07.933]  - Number of values collected after concatenation: 6
[15:31:07.934]  - Number of values expected: 6
[15:31:07.934] Reducing values from 2 chunks ... DONE
[15:31:07.934] future_lapply() ... DONE
     [,1]       [,2]       [,3]      
[1,] integer,19 integer,21 integer,23
[2,] integer,20 integer,22 integer,24
- apply(X, MARGIN = <character>, ...) ...
[15:31:07.935] getGlobalsAndPackagesXApply() ...
[15:31:07.935]  - future.globals: TRUE
[15:31:07.936] getGlobalsAndPackages() ...
[15:31:07.936] Searching for globals...
[15:31:07.938] - globals found: [1] 'FUN'
[15:31:07.939] Searching for globals ... DONE
[15:31:07.939] Resolving globals: FALSE
[15:31:07.940] The total size of the 1 globals is 848 bytes (848 bytes)
[15:31:07.941] The total size of the 1 globals exported for future expression ('FUN(X = structure(1:2, dim = 2:1, dimnames = list(rows = c("a",; "b"), NULL)))') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:31:07.941] - globals: [1] 'FUN'
[15:31:07.941] 
[15:31:07.942] getGlobalsAndPackages() ... DONE
[15:31:07.942]  - globals found/used: [n=1] 'FUN'
[15:31:07.942]  - needed namespaces: [n=0] 
[15:31:07.942] Finding globals ... DONE
[15:31:07.943]  - use_args: TRUE
[15:31:07.943]  - Getting '...' globals ...
[15:31:07.944] resolve() on list ...
[15:31:07.944]  recursive: 0
[15:31:07.944]  length: 1
[15:31:07.945]  elements: '...'
[15:31:07.945]  length: 0 (resolved future 1)
[15:31:07.945] resolve() on list ... DONE
[15:31:07.946]    - '...' content: [n=0] 
[15:31:07.946] List of 1
[15:31:07.946]  $ ...: list()
[15:31:07.946]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:07.946]  - attr(*, "where")=List of 1
[15:31:07.946]   ..$ ...:<environment: 0x000001bcbef2a180> 
[15:31:07.946]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:07.946]  - attr(*, "resolved")= logi TRUE
[15:31:07.946]  - attr(*, "total_size")= num NA
[15:31:07.958]  - Getting '...' globals ... DONE
[15:31:07.958] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:07.959] List of 2
[15:31:07.959]  $ ...future.FUN:function (x)  
[15:31:07.959]  $ ...          : list()
[15:31:07.959]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:07.959]  - attr(*, "where")=List of 2
[15:31:07.959]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:07.959]   ..$ ...          :<environment: 0x000001bcbef2a180> 
[15:31:07.959]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:07.959]  - attr(*, "resolved")= logi FALSE
[15:31:07.959]  - attr(*, "total_size")= num 848
[15:31:07.965] Packages to be attached in all futures: [n=0] 
[15:31:07.965] getGlobalsAndPackagesXApply() ... DONE
[15:31:07.969] future_lapply() ...
[15:31:07.974] Number of chunks: 2
[15:31:07.974] getGlobalsAndPackagesXApply() ...
[15:31:07.975]  - future.globals: <name-value list> with names 'list()'
[15:31:07.975]  - use_args: TRUE
[15:31:07.976] Globals to be used in all futures (chunks): [n=2] '...', '...future.FUN'
[15:31:07.976] List of 2
[15:31:07.976]  $ ...          : list()
[15:31:07.976]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:07.976]  $ ...future.FUN:function (x)  
[15:31:07.976]  - attr(*, "where")=List of 2
[15:31:07.976]   ..$ ...          :<environment: 0x000001bcbef2a180> 
[15:31:07.976]   ..$ ...future.FUN:<environment: namespace:base> 
[15:31:07.976]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:07.976]  - attr(*, "resolved")= logi FALSE
[15:31:07.976]  - attr(*, "total_size")= num NA
[15:31:07.982] Packages to be attached in all futures: [n=0] 
[15:31:07.983] getGlobalsAndPackagesXApply() ... DONE
[15:31:07.983] Number of futures (= number of chunks): 2
[15:31:07.983] Launching 2 futures (chunks) ...
[15:31:07.983] Chunk #1 of 2 ...
[15:31:07.984]  - Adjusted option 'future.globals.maxSize': Inf -> 2 * Inf = Inf (bytes)
[15:31:07.984]  - seeds: <none>
[15:31:07.984]  - All globals exported: [n=5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:07.984] getGlobalsAndPackages() ...
[15:31:07.984] - globals passed as-is: [5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:07.985] Resolving globals: FALSE
[15:31:07.985] Tweak future expression to call with '...' arguments ...
[15:31:07.985] {
[15:31:07.985]     do.call(function(...) {
[15:31:07.985]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:07.985]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:07.985]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:07.985]             on.exit(options(oopts), add = TRUE)
[15:31:07.985]         }
[15:31:07.985]         {
[15:31:07.985]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:07.985]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:07.985]                 ...future.FUN(...future.X_jj, ...)
[15:31:07.985]             })
[15:31:07.985]         }
[15:31:07.985]     }, args = future.call.arguments)
[15:31:07.985] }
[15:31:07.985] Tweak future expression to call with '...' arguments ... DONE
[15:31:07.986] - globals: [5] 'future.call.arguments', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:07.987] 
[15:31:07.987] getGlobalsAndPackages() ... DONE
[15:31:07.987] run() for 'Future' ...
[15:31:07.988] - state: 'created'
[15:31:07.988] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:08.008] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:08.008] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:31:08.009]   - Field: 'node'
[15:31:08.009]   - Field: 'label'
[15:31:08.009]   - Field: 'local'
[15:31:08.009]   - Field: 'owner'
[15:31:08.009]   - Field: 'envir'
[15:31:08.010]   - Field: 'workers'
[15:31:08.010]   - Field: 'packages'
[15:31:08.010]   - Field: 'gc'
[15:31:08.010]   - Field: 'conditions'
[15:31:08.010]   - Field: 'persistent'
[15:31:08.011]   - Field: 'expr'
[15:31:08.011]   - Field: 'uuid'
[15:31:08.011]   - Field: 'seed'
[15:31:08.011]   - Field: 'version'
[15:31:08.011]   - Field: 'result'
[15:31:08.012]   - Field: 'asynchronous'
[15:31:08.012]   - Field: 'calls'
[15:31:08.012]   - Field: 'globals'
[15:31:08.012]   - Field: 'stdout'
[15:31:08.012]   - Field: 'earlySignal'
[15:31:08.012]   - Field: 'lazy'
[15:31:08.013]   - Field: 'state'
[15:31:08.013] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:31:08.013] - Launch lazy future ...
[15:31:08.013] Packages needed by the future expression (n = 0): <none>
[15:31:08.014] Packages needed by future strategies (n = 0): <none>
[15:31:08.015] {
[15:31:08.015]     {
[15:31:08.015]         {
[15:31:08.015]             ...future.startTime <- base::Sys.time()
[15:31:08.015]             {
[15:31:08.015]                 {
[15:31:08.015]                   {
[15:31:08.015]                     {
[15:31:08.015]                       base::local({
[15:31:08.015]                         has_future <- base::requireNamespace("future", 
[15:31:08.015]                           quietly = TRUE)
[15:31:08.015]                         if (has_future) {
[15:31:08.015]                           ns <- base::getNamespace("future")
[15:31:08.015]                           version <- ns[[".package"]][["version"]]
[15:31:08.015]                           if (is.null(version)) 
[15:31:08.015]                             version <- utils::packageVersion("future")
[15:31:08.015]                         }
[15:31:08.015]                         else {
[15:31:08.015]                           version <- NULL
[15:31:08.015]                         }
[15:31:08.015]                         if (!has_future || version < "1.8.0") {
[15:31:08.015]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:08.015]                             "", base::R.version$version.string), 
[15:31:08.015]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:08.015]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:08.015]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:08.015]                               "release", "version")], collapse = " "), 
[15:31:08.015]                             hostname = base::Sys.info()[["nodename"]])
[15:31:08.015]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:08.015]                             info)
[15:31:08.015]                           info <- base::paste(info, collapse = "; ")
[15:31:08.015]                           if (!has_future) {
[15:31:08.015]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:08.015]                               info)
[15:31:08.015]                           }
[15:31:08.015]                           else {
[15:31:08.015]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:08.015]                               info, version)
[15:31:08.015]                           }
[15:31:08.015]                           base::stop(msg)
[15:31:08.015]                         }
[15:31:08.015]                       })
[15:31:08.015]                     }
[15:31:08.015]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:08.015]                     base::options(mc.cores = 1L)
[15:31:08.015]                   }
[15:31:08.015]                   ...future.strategy.old <- future::plan("list")
[15:31:08.015]                   options(future.plan = NULL)
[15:31:08.015]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:08.015]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:08.015]                 }
[15:31:08.015]                 ...future.workdir <- getwd()
[15:31:08.015]             }
[15:31:08.015]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:08.015]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:08.015]         }
[15:31:08.015]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:08.015]             future.globals.maxSize = Inf, future.globals.method = NULL, 
[15:31:08.015]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:08.015]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:08.015]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:08.015]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:08.015]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:08.015]             base::names(...future.oldOptions))
[15:31:08.015]     }
[15:31:08.015]     if (FALSE) {
[15:31:08.015]     }
[15:31:08.015]     else {
[15:31:08.015]         if (TRUE) {
[15:31:08.015]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:08.015]                 open = "w")
[15:31:08.015]         }
[15:31:08.015]         else {
[15:31:08.015]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:08.015]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:08.015]         }
[15:31:08.015]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:08.015]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:08.015]             base::sink(type = "output", split = FALSE)
[15:31:08.015]             base::close(...future.stdout)
[15:31:08.015]         }, add = TRUE)
[15:31:08.015]     }
[15:31:08.015]     ...future.frame <- base::sys.nframe()
[15:31:08.015]     ...future.conditions <- base::list()
[15:31:08.015]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:08.015]     if (FALSE) {
[15:31:08.015]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:08.015]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:08.015]     }
[15:31:08.015]     ...future.result <- base::tryCatch({
[15:31:08.015]         base::withCallingHandlers({
[15:31:08.015]             ...future.value <- base::withVisible(base::local({
[15:31:08.015]                 ...future.makeSendCondition <- base::local({
[15:31:08.015]                   sendCondition <- NULL
[15:31:08.015]                   function(frame = 1L) {
[15:31:08.015]                     if (is.function(sendCondition)) 
[15:31:08.015]                       return(sendCondition)
[15:31:08.015]                     ns <- getNamespace("parallel")
[15:31:08.015]                     if (exists("sendData", mode = "function", 
[15:31:08.015]                       envir = ns)) {
[15:31:08.015]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:08.015]                         envir = ns)
[15:31:08.015]                       envir <- sys.frame(frame)
[15:31:08.015]                       master <- NULL
[15:31:08.015]                       while (!identical(envir, .GlobalEnv) && 
[15:31:08.015]                         !identical(envir, emptyenv())) {
[15:31:08.015]                         if (exists("master", mode = "list", envir = envir, 
[15:31:08.015]                           inherits = FALSE)) {
[15:31:08.015]                           master <- get("master", mode = "list", 
[15:31:08.015]                             envir = envir, inherits = FALSE)
[15:31:08.015]                           if (inherits(master, c("SOCKnode", 
[15:31:08.015]                             "SOCK0node"))) {
[15:31:08.015]                             sendCondition <<- function(cond) {
[15:31:08.015]                               data <- list(type = "VALUE", value = cond, 
[15:31:08.015]                                 success = TRUE)
[15:31:08.015]                               parallel_sendData(master, data)
[15:31:08.015]                             }
[15:31:08.015]                             return(sendCondition)
[15:31:08.015]                           }
[15:31:08.015]                         }
[15:31:08.015]                         frame <- frame + 1L
[15:31:08.015]                         envir <- sys.frame(frame)
[15:31:08.015]                       }
[15:31:08.015]                     }
[15:31:08.015]                     sendCondition <<- function(cond) NULL
[15:31:08.015]                   }
[15:31:08.015]                 })
[15:31:08.015]                 withCallingHandlers({
[15:31:08.015]                   {
[15:31:08.015]                     do.call(function(...) {
[15:31:08.015]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:08.015]                       if (!identical(...future.globals.maxSize.org, 
[15:31:08.015]                         ...future.globals.maxSize)) {
[15:31:08.015]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:08.015]                         on.exit(options(oopts), add = TRUE)
[15:31:08.015]                       }
[15:31:08.015]                       {
[15:31:08.015]                         lapply(seq_along(...future.elements_ii), 
[15:31:08.015]                           FUN = function(jj) {
[15:31:08.015]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:08.015]                             ...future.FUN(...future.X_jj, ...)
[15:31:08.015]                           })
[15:31:08.015]                       }
[15:31:08.015]                     }, args = future.call.arguments)
[15:31:08.015]                   }
[15:31:08.015]                 }, immediateCondition = function(cond) {
[15:31:08.015]                   sendCondition <- ...future.makeSendCondition()
[15:31:08.015]                   sendCondition(cond)
[15:31:08.015]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:08.015]                   {
[15:31:08.015]                     inherits <- base::inherits
[15:31:08.015]                     invokeRestart <- base::invokeRestart
[15:31:08.015]                     is.null <- base::is.null
[15:31:08.015]                     muffled <- FALSE
[15:31:08.015]                     if (inherits(cond, "message")) {
[15:31:08.015]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:08.015]                       if (muffled) 
[15:31:08.015]                         invokeRestart("muffleMessage")
[15:31:08.015]                     }
[15:31:08.015]                     else if (inherits(cond, "warning")) {
[15:31:08.015]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:08.015]                       if (muffled) 
[15:31:08.015]                         invokeRestart("muffleWarning")
[15:31:08.015]                     }
[15:31:08.015]                     else if (inherits(cond, "condition")) {
[15:31:08.015]                       if (!is.null(pattern)) {
[15:31:08.015]                         computeRestarts <- base::computeRestarts
[15:31:08.015]                         grepl <- base::grepl
[15:31:08.015]                         restarts <- computeRestarts(cond)
[15:31:08.015]                         for (restart in restarts) {
[15:31:08.015]                           name <- restart$name
[15:31:08.015]                           if (is.null(name)) 
[15:31:08.015]                             next
[15:31:08.015]                           if (!grepl(pattern, name)) 
[15:31:08.015]                             next
[15:31:08.015]                           invokeRestart(restart)
[15:31:08.015]                           muffled <- TRUE
[15:31:08.015]                           break
[15:31:08.015]                         }
[15:31:08.015]                       }
[15:31:08.015]                     }
[15:31:08.015]                     invisible(muffled)
[15:31:08.015]                   }
[15:31:08.015]                   muffleCondition(cond)
[15:31:08.015]                 })
[15:31:08.015]             }))
[15:31:08.015]             future::FutureResult(value = ...future.value$value, 
[15:31:08.015]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:08.015]                   ...future.rng), globalenv = if (FALSE) 
[15:31:08.015]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:08.015]                     ...future.globalenv.names))
[15:31:08.015]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:08.015]         }, condition = base::local({
[15:31:08.015]             c <- base::c
[15:31:08.015]             inherits <- base::inherits
[15:31:08.015]             invokeRestart <- base::invokeRestart
[15:31:08.015]             length <- base::length
[15:31:08.015]             list <- base::list
[15:31:08.015]             seq.int <- base::seq.int
[15:31:08.015]             signalCondition <- base::signalCondition
[15:31:08.015]             sys.calls <- base::sys.calls
[15:31:08.015]             `[[` <- base::`[[`
[15:31:08.015]             `+` <- base::`+`
[15:31:08.015]             `<<-` <- base::`<<-`
[15:31:08.015]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:08.015]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:08.015]                   3L)]
[15:31:08.015]             }
[15:31:08.015]             function(cond) {
[15:31:08.015]                 is_error <- inherits(cond, "error")
[15:31:08.015]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:08.015]                   NULL)
[15:31:08.015]                 if (is_error) {
[15:31:08.015]                   sessionInformation <- function() {
[15:31:08.015]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:08.015]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:08.015]                       search = base::search(), system = base::Sys.info())
[15:31:08.015]                   }
[15:31:08.015]                   ...future.conditions[[length(...future.conditions) + 
[15:31:08.015]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:08.015]                     cond$call), session = sessionInformation(), 
[15:31:08.015]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:08.015]                   signalCondition(cond)
[15:31:08.015]                 }
[15:31:08.015]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:08.015]                 "immediateCondition"))) {
[15:31:08.015]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:08.015]                   ...future.conditions[[length(...future.conditions) + 
[15:31:08.015]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:08.015]                   if (TRUE && !signal) {
[15:31:08.015]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:08.015]                     {
[15:31:08.015]                       inherits <- base::inherits
[15:31:08.015]                       invokeRestart <- base::invokeRestart
[15:31:08.015]                       is.null <- base::is.null
[15:31:08.015]                       muffled <- FALSE
[15:31:08.015]                       if (inherits(cond, "message")) {
[15:31:08.015]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:08.015]                         if (muffled) 
[15:31:08.015]                           invokeRestart("muffleMessage")
[15:31:08.015]                       }
[15:31:08.015]                       else if (inherits(cond, "warning")) {
[15:31:08.015]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:08.015]                         if (muffled) 
[15:31:08.015]                           invokeRestart("muffleWarning")
[15:31:08.015]                       }
[15:31:08.015]                       else if (inherits(cond, "condition")) {
[15:31:08.015]                         if (!is.null(pattern)) {
[15:31:08.015]                           computeRestarts <- base::computeRestarts
[15:31:08.015]                           grepl <- base::grepl
[15:31:08.015]                           restarts <- computeRestarts(cond)
[15:31:08.015]                           for (restart in restarts) {
[15:31:08.015]                             name <- restart$name
[15:31:08.015]                             if (is.null(name)) 
[15:31:08.015]                               next
[15:31:08.015]                             if (!grepl(pattern, name)) 
[15:31:08.015]                               next
[15:31:08.015]                             invokeRestart(restart)
[15:31:08.015]                             muffled <- TRUE
[15:31:08.015]                             break
[15:31:08.015]                           }
[15:31:08.015]                         }
[15:31:08.015]                       }
[15:31:08.015]                       invisible(muffled)
[15:31:08.015]                     }
[15:31:08.015]                     muffleCondition(cond, pattern = "^muffle")
[15:31:08.015]                   }
[15:31:08.015]                 }
[15:31:08.015]                 else {
[15:31:08.015]                   if (TRUE) {
[15:31:08.015]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:08.015]                     {
[15:31:08.015]                       inherits <- base::inherits
[15:31:08.015]                       invokeRestart <- base::invokeRestart
[15:31:08.015]                       is.null <- base::is.null
[15:31:08.015]                       muffled <- FALSE
[15:31:08.015]                       if (inherits(cond, "message")) {
[15:31:08.015]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:08.015]                         if (muffled) 
[15:31:08.015]                           invokeRestart("muffleMessage")
[15:31:08.015]                       }
[15:31:08.015]                       else if (inherits(cond, "warning")) {
[15:31:08.015]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:08.015]                         if (muffled) 
[15:31:08.015]                           invokeRestart("muffleWarning")
[15:31:08.015]                       }
[15:31:08.015]                       else if (inherits(cond, "condition")) {
[15:31:08.015]                         if (!is.null(pattern)) {
[15:31:08.015]                           computeRestarts <- base::computeRestarts
[15:31:08.015]                           grepl <- base::grepl
[15:31:08.015]                           restarts <- computeRestarts(cond)
[15:31:08.015]                           for (restart in restarts) {
[15:31:08.015]                             name <- restart$name
[15:31:08.015]                             if (is.null(name)) 
[15:31:08.015]                               next
[15:31:08.015]                             if (!grepl(pattern, name)) 
[15:31:08.015]                               next
[15:31:08.015]                             invokeRestart(restart)
[15:31:08.015]                             muffled <- TRUE
[15:31:08.015]                             break
[15:31:08.015]                           }
[15:31:08.015]                         }
[15:31:08.015]                       }
[15:31:08.015]                       invisible(muffled)
[15:31:08.015]                     }
[15:31:08.015]                     muffleCondition(cond, pattern = "^muffle")
[15:31:08.015]                   }
[15:31:08.015]                 }
[15:31:08.015]             }
[15:31:08.015]         }))
[15:31:08.015]     }, error = function(ex) {
[15:31:08.015]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:08.015]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:08.015]                 ...future.rng), started = ...future.startTime, 
[15:31:08.015]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:08.015]             version = "1.8"), class = "FutureResult")
[15:31:08.015]     }, finally = {
[15:31:08.015]         if (!identical(...future.workdir, getwd())) 
[15:31:08.015]             setwd(...future.workdir)
[15:31:08.015]         {
[15:31:08.015]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:08.015]                 ...future.oldOptions$nwarnings <- NULL
[15:31:08.015]             }
[15:31:08.015]             base::options(...future.oldOptions)
[15:31:08.015]             if (.Platform$OS.type == "windows") {
[15:31:08.015]                 old_names <- names(...future.oldEnvVars)
[15:31:08.015]                 envs <- base::Sys.getenv()
[15:31:08.015]                 names <- names(envs)
[15:31:08.015]                 common <- intersect(names, old_names)
[15:31:08.015]                 added <- setdiff(names, old_names)
[15:31:08.015]                 removed <- setdiff(old_names, names)
[15:31:08.015]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:08.015]                   envs[common]]
[15:31:08.015]                 NAMES <- toupper(changed)
[15:31:08.015]                 args <- list()
[15:31:08.015]                 for (kk in seq_along(NAMES)) {
[15:31:08.015]                   name <- changed[[kk]]
[15:31:08.015]                   NAME <- NAMES[[kk]]
[15:31:08.015]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:08.015]                     next
[15:31:08.015]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:08.015]                 }
[15:31:08.015]                 NAMES <- toupper(added)
[15:31:08.015]                 for (kk in seq_along(NAMES)) {
[15:31:08.015]                   name <- added[[kk]]
[15:31:08.015]                   NAME <- NAMES[[kk]]
[15:31:08.015]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:08.015]                     next
[15:31:08.015]                   args[[name]] <- ""
[15:31:08.015]                 }
[15:31:08.015]                 NAMES <- toupper(removed)
[15:31:08.015]                 for (kk in seq_along(NAMES)) {
[15:31:08.015]                   name <- removed[[kk]]
[15:31:08.015]                   NAME <- NAMES[[kk]]
[15:31:08.015]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:08.015]                     next
[15:31:08.015]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:08.015]                 }
[15:31:08.015]                 if (length(args) > 0) 
[15:31:08.015]                   base::do.call(base::Sys.setenv, args = args)
[15:31:08.015]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:08.015]             }
[15:31:08.015]             else {
[15:31:08.015]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:08.015]             }
[15:31:08.015]             {
[15:31:08.015]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:08.015]                   0L) {
[15:31:08.015]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:08.015]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:08.015]                   base::options(opts)
[15:31:08.015]                 }
[15:31:08.015]                 {
[15:31:08.015]                   {
[15:31:08.015]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:08.015]                     NULL
[15:31:08.015]                   }
[15:31:08.015]                   options(future.plan = NULL)
[15:31:08.015]                   if (is.na(NA_character_)) 
[15:31:08.015]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:08.015]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:08.015]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:08.015]                     .init = FALSE)
[15:31:08.015]                 }
[15:31:08.015]             }
[15:31:08.015]         }
[15:31:08.015]     })
[15:31:08.015]     if (TRUE) {
[15:31:08.015]         base::sink(type = "output", split = FALSE)
[15:31:08.015]         if (TRUE) {
[15:31:08.015]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:08.015]         }
[15:31:08.015]         else {
[15:31:08.015]             ...future.result["stdout"] <- base::list(NULL)
[15:31:08.015]         }
[15:31:08.015]         base::close(...future.stdout)
[15:31:08.015]         ...future.stdout <- NULL
[15:31:08.015]     }
[15:31:08.015]     ...future.result$conditions <- ...future.conditions
[15:31:08.015]     ...future.result$finished <- base::Sys.time()
[15:31:08.015]     ...future.result
[15:31:08.015] }
[15:31:08.025] Exporting 5 global objects (960 bytes) to cluster node #1 ...
[15:31:08.025] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:31:08.026] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:31:08.026] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:31:08.027] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:31:08.027] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[15:31:08.028] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[15:31:08.028] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:31:08.029] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:31:08.029] Exporting '...future.globals.maxSize' (56 bytes) to cluster node #1 ...
[15:31:08.030] Exporting '...future.globals.maxSize' (56 bytes) to cluster node #1 ... DONE
[15:31:08.030] Exporting 5 global objects (960 bytes) to cluster node #1 ... DONE
[15:31:08.031] MultisessionFuture started
[15:31:08.032] - Launch lazy future ... done
[15:31:08.032] run() for 'MultisessionFuture' ... done
[15:31:08.032] Created future:
[15:31:08.059] receiveMessageFromWorker() for ClusterFuture ...
[15:31:08.060] - Validating connection of MultisessionFuture
[15:31:08.060] - received message: FutureResult
[15:31:08.060] - Received FutureResult
[15:31:08.061] - Erased future from FutureRegistry
[15:31:08.061] result() for ClusterFuture ...
[15:31:08.061] - result already collected: FutureResult
[15:31:08.062] result() for ClusterFuture ... done
[15:31:08.062] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:08.033] MultisessionFuture:
[15:31:08.033] Label: 'future_apply-1'
[15:31:08.033] Expression:
[15:31:08.033] {
[15:31:08.033]     do.call(function(...) {
[15:31:08.033]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:08.033]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:08.033]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:08.033]             on.exit(options(oopts), add = TRUE)
[15:31:08.033]         }
[15:31:08.033]         {
[15:31:08.033]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:08.033]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:08.033]                 ...future.FUN(...future.X_jj, ...)
[15:31:08.033]             })
[15:31:08.033]         }
[15:31:08.033]     }, args = future.call.arguments)
[15:31:08.033] }
[15:31:08.033] Lazy evaluation: FALSE
[15:31:08.033] Asynchronous evaluation: TRUE
[15:31:08.033] Local evaluation: TRUE
[15:31:08.033] Environment: R_GlobalEnv
[15:31:08.033] Capture standard output: TRUE
[15:31:08.033] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:08.033] Globals: 5 objects totaling 960 bytes (DotDotDotList 'future.call.arguments' of 0 bytes, function '...future.FUN' of 848 bytes, list '...future.elements_ii' of 56 bytes, NULL '...future.seeds_ii' of 0 bytes, numeric '...future.globals.maxSize' of 56 bytes)
[15:31:08.033] Packages: <none>
[15:31:08.033] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:08.033] Resolved: TRUE
[15:31:08.033] Value: <not collected>
[15:31:08.033] Conditions captured: <none>
[15:31:08.033] Early signaling: FALSE
[15:31:08.033] Owner process: 6672a580-6d3c-e82f-380e-108c475ace70
[15:31:08.033] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:08.063] Chunk #1 of 2 ... DONE
[15:31:08.063] Chunk #2 of 2 ...
[15:31:08.063]  - Adjusted option 'future.globals.maxSize': Inf -> 2 * Inf = Inf (bytes)
[15:31:08.064]  - seeds: <none>
[15:31:08.064]  - All globals exported: [n=5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:08.064] getGlobalsAndPackages() ...
[15:31:08.064] - globals passed as-is: [5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:08.065] Resolving globals: FALSE
[15:31:08.065] Tweak future expression to call with '...' arguments ...
[15:31:08.065] {
[15:31:08.065]     do.call(function(...) {
[15:31:08.065]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:08.065]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:08.065]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:08.065]             on.exit(options(oopts), add = TRUE)
[15:31:08.065]         }
[15:31:08.065]         {
[15:31:08.065]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:08.065]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:08.065]                 ...future.FUN(...future.X_jj, ...)
[15:31:08.065]             })
[15:31:08.065]         }
[15:31:08.065]     }, args = future.call.arguments)
[15:31:08.065] }
[15:31:08.066] Tweak future expression to call with '...' arguments ... DONE
[15:31:08.067] - globals: [5] 'future.call.arguments', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:08.067] 
[15:31:08.068] getGlobalsAndPackages() ... DONE
[15:31:08.068] run() for 'Future' ...
[15:31:08.069] - state: 'created'
[15:31:08.069] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:08.087] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:08.087] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:31:08.088]   - Field: 'node'
[15:31:08.088]   - Field: 'label'
[15:31:08.088]   - Field: 'local'
[15:31:08.089]   - Field: 'owner'
[15:31:08.089]   - Field: 'envir'
[15:31:08.089]   - Field: 'workers'
[15:31:08.090]   - Field: 'packages'
[15:31:08.090]   - Field: 'gc'
[15:31:08.090]   - Field: 'conditions'
[15:31:08.091]   - Field: 'persistent'
[15:31:08.091]   - Field: 'expr'
[15:31:08.091]   - Field: 'uuid'
[15:31:08.092]   - Field: 'seed'
[15:31:08.092]   - Field: 'version'
[15:31:08.092]   - Field: 'result'
[15:31:08.093]   - Field: 'asynchronous'
[15:31:08.093]   - Field: 'calls'
[15:31:08.093]   - Field: 'globals'
[15:31:08.094]   - Field: 'stdout'
[15:31:08.094]   - Field: 'earlySignal'
[15:31:08.094]   - Field: 'lazy'
[15:31:08.094]   - Field: 'state'
[15:31:08.095] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:31:08.095] - Launch lazy future ...
[15:31:08.095] Packages needed by the future expression (n = 0): <none>
[15:31:08.096] Packages needed by future strategies (n = 0): <none>
[15:31:08.096] {
[15:31:08.096]     {
[15:31:08.096]         {
[15:31:08.096]             ...future.startTime <- base::Sys.time()
[15:31:08.096]             {
[15:31:08.096]                 {
[15:31:08.096]                   {
[15:31:08.096]                     {
[15:31:08.096]                       base::local({
[15:31:08.096]                         has_future <- base::requireNamespace("future", 
[15:31:08.096]                           quietly = TRUE)
[15:31:08.096]                         if (has_future) {
[15:31:08.096]                           ns <- base::getNamespace("future")
[15:31:08.096]                           version <- ns[[".package"]][["version"]]
[15:31:08.096]                           if (is.null(version)) 
[15:31:08.096]                             version <- utils::packageVersion("future")
[15:31:08.096]                         }
[15:31:08.096]                         else {
[15:31:08.096]                           version <- NULL
[15:31:08.096]                         }
[15:31:08.096]                         if (!has_future || version < "1.8.0") {
[15:31:08.096]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:08.096]                             "", base::R.version$version.string), 
[15:31:08.096]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:08.096]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:08.096]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:08.096]                               "release", "version")], collapse = " "), 
[15:31:08.096]                             hostname = base::Sys.info()[["nodename"]])
[15:31:08.096]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:08.096]                             info)
[15:31:08.096]                           info <- base::paste(info, collapse = "; ")
[15:31:08.096]                           if (!has_future) {
[15:31:08.096]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:08.096]                               info)
[15:31:08.096]                           }
[15:31:08.096]                           else {
[15:31:08.096]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:08.096]                               info, version)
[15:31:08.096]                           }
[15:31:08.096]                           base::stop(msg)
[15:31:08.096]                         }
[15:31:08.096]                       })
[15:31:08.096]                     }
[15:31:08.096]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:08.096]                     base::options(mc.cores = 1L)
[15:31:08.096]                   }
[15:31:08.096]                   ...future.strategy.old <- future::plan("list")
[15:31:08.096]                   options(future.plan = NULL)
[15:31:08.096]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:08.096]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:08.096]                 }
[15:31:08.096]                 ...future.workdir <- getwd()
[15:31:08.096]             }
[15:31:08.096]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:08.096]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:08.096]         }
[15:31:08.096]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:08.096]             future.globals.maxSize = Inf, future.globals.method = NULL, 
[15:31:08.096]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:08.096]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:08.096]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:08.096]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:08.096]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:08.096]             base::names(...future.oldOptions))
[15:31:08.096]     }
[15:31:08.096]     if (FALSE) {
[15:31:08.096]     }
[15:31:08.096]     else {
[15:31:08.096]         if (TRUE) {
[15:31:08.096]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:08.096]                 open = "w")
[15:31:08.096]         }
[15:31:08.096]         else {
[15:31:08.096]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:08.096]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:08.096]         }
[15:31:08.096]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:08.096]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:08.096]             base::sink(type = "output", split = FALSE)
[15:31:08.096]             base::close(...future.stdout)
[15:31:08.096]         }, add = TRUE)
[15:31:08.096]     }
[15:31:08.096]     ...future.frame <- base::sys.nframe()
[15:31:08.096]     ...future.conditions <- base::list()
[15:31:08.096]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:08.096]     if (FALSE) {
[15:31:08.096]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:08.096]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:08.096]     }
[15:31:08.096]     ...future.result <- base::tryCatch({
[15:31:08.096]         base::withCallingHandlers({
[15:31:08.096]             ...future.value <- base::withVisible(base::local({
[15:31:08.096]                 ...future.makeSendCondition <- base::local({
[15:31:08.096]                   sendCondition <- NULL
[15:31:08.096]                   function(frame = 1L) {
[15:31:08.096]                     if (is.function(sendCondition)) 
[15:31:08.096]                       return(sendCondition)
[15:31:08.096]                     ns <- getNamespace("parallel")
[15:31:08.096]                     if (exists("sendData", mode = "function", 
[15:31:08.096]                       envir = ns)) {
[15:31:08.096]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:08.096]                         envir = ns)
[15:31:08.096]                       envir <- sys.frame(frame)
[15:31:08.096]                       master <- NULL
[15:31:08.096]                       while (!identical(envir, .GlobalEnv) && 
[15:31:08.096]                         !identical(envir, emptyenv())) {
[15:31:08.096]                         if (exists("master", mode = "list", envir = envir, 
[15:31:08.096]                           inherits = FALSE)) {
[15:31:08.096]                           master <- get("master", mode = "list", 
[15:31:08.096]                             envir = envir, inherits = FALSE)
[15:31:08.096]                           if (inherits(master, c("SOCKnode", 
[15:31:08.096]                             "SOCK0node"))) {
[15:31:08.096]                             sendCondition <<- function(cond) {
[15:31:08.096]                               data <- list(type = "VALUE", value = cond, 
[15:31:08.096]                                 success = TRUE)
[15:31:08.096]                               parallel_sendData(master, data)
[15:31:08.096]                             }
[15:31:08.096]                             return(sendCondition)
[15:31:08.096]                           }
[15:31:08.096]                         }
[15:31:08.096]                         frame <- frame + 1L
[15:31:08.096]                         envir <- sys.frame(frame)
[15:31:08.096]                       }
[15:31:08.096]                     }
[15:31:08.096]                     sendCondition <<- function(cond) NULL
[15:31:08.096]                   }
[15:31:08.096]                 })
[15:31:08.096]                 withCallingHandlers({
[15:31:08.096]                   {
[15:31:08.096]                     do.call(function(...) {
[15:31:08.096]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:08.096]                       if (!identical(...future.globals.maxSize.org, 
[15:31:08.096]                         ...future.globals.maxSize)) {
[15:31:08.096]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:08.096]                         on.exit(options(oopts), add = TRUE)
[15:31:08.096]                       }
[15:31:08.096]                       {
[15:31:08.096]                         lapply(seq_along(...future.elements_ii), 
[15:31:08.096]                           FUN = function(jj) {
[15:31:08.096]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:08.096]                             ...future.FUN(...future.X_jj, ...)
[15:31:08.096]                           })
[15:31:08.096]                       }
[15:31:08.096]                     }, args = future.call.arguments)
[15:31:08.096]                   }
[15:31:08.096]                 }, immediateCondition = function(cond) {
[15:31:08.096]                   sendCondition <- ...future.makeSendCondition()
[15:31:08.096]                   sendCondition(cond)
[15:31:08.096]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:08.096]                   {
[15:31:08.096]                     inherits <- base::inherits
[15:31:08.096]                     invokeRestart <- base::invokeRestart
[15:31:08.096]                     is.null <- base::is.null
[15:31:08.096]                     muffled <- FALSE
[15:31:08.096]                     if (inherits(cond, "message")) {
[15:31:08.096]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:08.096]                       if (muffled) 
[15:31:08.096]                         invokeRestart("muffleMessage")
[15:31:08.096]                     }
[15:31:08.096]                     else if (inherits(cond, "warning")) {
[15:31:08.096]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:08.096]                       if (muffled) 
[15:31:08.096]                         invokeRestart("muffleWarning")
[15:31:08.096]                     }
[15:31:08.096]                     else if (inherits(cond, "condition")) {
[15:31:08.096]                       if (!is.null(pattern)) {
[15:31:08.096]                         computeRestarts <- base::computeRestarts
[15:31:08.096]                         grepl <- base::grepl
[15:31:08.096]                         restarts <- computeRestarts(cond)
[15:31:08.096]                         for (restart in restarts) {
[15:31:08.096]                           name <- restart$name
[15:31:08.096]                           if (is.null(name)) 
[15:31:08.096]                             next
[15:31:08.096]                           if (!grepl(pattern, name)) 
[15:31:08.096]                             next
[15:31:08.096]                           invokeRestart(restart)
[15:31:08.096]                           muffled <- TRUE
[15:31:08.096]                           break
[15:31:08.096]                         }
[15:31:08.096]                       }
[15:31:08.096]                     }
[15:31:08.096]                     invisible(muffled)
[15:31:08.096]                   }
[15:31:08.096]                   muffleCondition(cond)
[15:31:08.096]                 })
[15:31:08.096]             }))
[15:31:08.096]             future::FutureResult(value = ...future.value$value, 
[15:31:08.096]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:08.096]                   ...future.rng), globalenv = if (FALSE) 
[15:31:08.096]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:08.096]                     ...future.globalenv.names))
[15:31:08.096]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:08.096]         }, condition = base::local({
[15:31:08.096]             c <- base::c
[15:31:08.096]             inherits <- base::inherits
[15:31:08.096]             invokeRestart <- base::invokeRestart
[15:31:08.096]             length <- base::length
[15:31:08.096]             list <- base::list
[15:31:08.096]             seq.int <- base::seq.int
[15:31:08.096]             signalCondition <- base::signalCondition
[15:31:08.096]             sys.calls <- base::sys.calls
[15:31:08.096]             `[[` <- base::`[[`
[15:31:08.096]             `+` <- base::`+`
[15:31:08.096]             `<<-` <- base::`<<-`
[15:31:08.096]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:08.096]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:08.096]                   3L)]
[15:31:08.096]             }
[15:31:08.096]             function(cond) {
[15:31:08.096]                 is_error <- inherits(cond, "error")
[15:31:08.096]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:08.096]                   NULL)
[15:31:08.096]                 if (is_error) {
[15:31:08.096]                   sessionInformation <- function() {
[15:31:08.096]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:08.096]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:08.096]                       search = base::search(), system = base::Sys.info())
[15:31:08.096]                   }
[15:31:08.096]                   ...future.conditions[[length(...future.conditions) + 
[15:31:08.096]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:08.096]                     cond$call), session = sessionInformation(), 
[15:31:08.096]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:08.096]                   signalCondition(cond)
[15:31:08.096]                 }
[15:31:08.096]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:08.096]                 "immediateCondition"))) {
[15:31:08.096]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:08.096]                   ...future.conditions[[length(...future.conditions) + 
[15:31:08.096]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:08.096]                   if (TRUE && !signal) {
[15:31:08.096]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:08.096]                     {
[15:31:08.096]                       inherits <- base::inherits
[15:31:08.096]                       invokeRestart <- base::invokeRestart
[15:31:08.096]                       is.null <- base::is.null
[15:31:08.096]                       muffled <- FALSE
[15:31:08.096]                       if (inherits(cond, "message")) {
[15:31:08.096]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:08.096]                         if (muffled) 
[15:31:08.096]                           invokeRestart("muffleMessage")
[15:31:08.096]                       }
[15:31:08.096]                       else if (inherits(cond, "warning")) {
[15:31:08.096]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:08.096]                         if (muffled) 
[15:31:08.096]                           invokeRestart("muffleWarning")
[15:31:08.096]                       }
[15:31:08.096]                       else if (inherits(cond, "condition")) {
[15:31:08.096]                         if (!is.null(pattern)) {
[15:31:08.096]                           computeRestarts <- base::computeRestarts
[15:31:08.096]                           grepl <- base::grepl
[15:31:08.096]                           restarts <- computeRestarts(cond)
[15:31:08.096]                           for (restart in restarts) {
[15:31:08.096]                             name <- restart$name
[15:31:08.096]                             if (is.null(name)) 
[15:31:08.096]                               next
[15:31:08.096]                             if (!grepl(pattern, name)) 
[15:31:08.096]                               next
[15:31:08.096]                             invokeRestart(restart)
[15:31:08.096]                             muffled <- TRUE
[15:31:08.096]                             break
[15:31:08.096]                           }
[15:31:08.096]                         }
[15:31:08.096]                       }
[15:31:08.096]                       invisible(muffled)
[15:31:08.096]                     }
[15:31:08.096]                     muffleCondition(cond, pattern = "^muffle")
[15:31:08.096]                   }
[15:31:08.096]                 }
[15:31:08.096]                 else {
[15:31:08.096]                   if (TRUE) {
[15:31:08.096]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:08.096]                     {
[15:31:08.096]                       inherits <- base::inherits
[15:31:08.096]                       invokeRestart <- base::invokeRestart
[15:31:08.096]                       is.null <- base::is.null
[15:31:08.096]                       muffled <- FALSE
[15:31:08.096]                       if (inherits(cond, "message")) {
[15:31:08.096]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:08.096]                         if (muffled) 
[15:31:08.096]                           invokeRestart("muffleMessage")
[15:31:08.096]                       }
[15:31:08.096]                       else if (inherits(cond, "warning")) {
[15:31:08.096]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:08.096]                         if (muffled) 
[15:31:08.096]                           invokeRestart("muffleWarning")
[15:31:08.096]                       }
[15:31:08.096]                       else if (inherits(cond, "condition")) {
[15:31:08.096]                         if (!is.null(pattern)) {
[15:31:08.096]                           computeRestarts <- base::computeRestarts
[15:31:08.096]                           grepl <- base::grepl
[15:31:08.096]                           restarts <- computeRestarts(cond)
[15:31:08.096]                           for (restart in restarts) {
[15:31:08.096]                             name <- restart$name
[15:31:08.096]                             if (is.null(name)) 
[15:31:08.096]                               next
[15:31:08.096]                             if (!grepl(pattern, name)) 
[15:31:08.096]                               next
[15:31:08.096]                             invokeRestart(restart)
[15:31:08.096]                             muffled <- TRUE
[15:31:08.096]                             break
[15:31:08.096]                           }
[15:31:08.096]                         }
[15:31:08.096]                       }
[15:31:08.096]                       invisible(muffled)
[15:31:08.096]                     }
[15:31:08.096]                     muffleCondition(cond, pattern = "^muffle")
[15:31:08.096]                   }
[15:31:08.096]                 }
[15:31:08.096]             }
[15:31:08.096]         }))
[15:31:08.096]     }, error = function(ex) {
[15:31:08.096]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:08.096]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:08.096]                 ...future.rng), started = ...future.startTime, 
[15:31:08.096]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:08.096]             version = "1.8"), class = "FutureResult")
[15:31:08.096]     }, finally = {
[15:31:08.096]         if (!identical(...future.workdir, getwd())) 
[15:31:08.096]             setwd(...future.workdir)
[15:31:08.096]         {
[15:31:08.096]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:08.096]                 ...future.oldOptions$nwarnings <- NULL
[15:31:08.096]             }
[15:31:08.096]             base::options(...future.oldOptions)
[15:31:08.096]             if (.Platform$OS.type == "windows") {
[15:31:08.096]                 old_names <- names(...future.oldEnvVars)
[15:31:08.096]                 envs <- base::Sys.getenv()
[15:31:08.096]                 names <- names(envs)
[15:31:08.096]                 common <- intersect(names, old_names)
[15:31:08.096]                 added <- setdiff(names, old_names)
[15:31:08.096]                 removed <- setdiff(old_names, names)
[15:31:08.096]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:08.096]                   envs[common]]
[15:31:08.096]                 NAMES <- toupper(changed)
[15:31:08.096]                 args <- list()
[15:31:08.096]                 for (kk in seq_along(NAMES)) {
[15:31:08.096]                   name <- changed[[kk]]
[15:31:08.096]                   NAME <- NAMES[[kk]]
[15:31:08.096]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:08.096]                     next
[15:31:08.096]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:08.096]                 }
[15:31:08.096]                 NAMES <- toupper(added)
[15:31:08.096]                 for (kk in seq_along(NAMES)) {
[15:31:08.096]                   name <- added[[kk]]
[15:31:08.096]                   NAME <- NAMES[[kk]]
[15:31:08.096]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:08.096]                     next
[15:31:08.096]                   args[[name]] <- ""
[15:31:08.096]                 }
[15:31:08.096]                 NAMES <- toupper(removed)
[15:31:08.096]                 for (kk in seq_along(NAMES)) {
[15:31:08.096]                   name <- removed[[kk]]
[15:31:08.096]                   NAME <- NAMES[[kk]]
[15:31:08.096]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:08.096]                     next
[15:31:08.096]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:08.096]                 }
[15:31:08.096]                 if (length(args) > 0) 
[15:31:08.096]                   base::do.call(base::Sys.setenv, args = args)
[15:31:08.096]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:08.096]             }
[15:31:08.096]             else {
[15:31:08.096]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:08.096]             }
[15:31:08.096]             {
[15:31:08.096]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:08.096]                   0L) {
[15:31:08.096]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:08.096]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:08.096]                   base::options(opts)
[15:31:08.096]                 }
[15:31:08.096]                 {
[15:31:08.096]                   {
[15:31:08.096]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:08.096]                     NULL
[15:31:08.096]                   }
[15:31:08.096]                   options(future.plan = NULL)
[15:31:08.096]                   if (is.na(NA_character_)) 
[15:31:08.096]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:08.096]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:08.096]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:08.096]                     .init = FALSE)
[15:31:08.096]                 }
[15:31:08.096]             }
[15:31:08.096]         }
[15:31:08.096]     })
[15:31:08.096]     if (TRUE) {
[15:31:08.096]         base::sink(type = "output", split = FALSE)
[15:31:08.096]         if (TRUE) {
[15:31:08.096]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:08.096]         }
[15:31:08.096]         else {
[15:31:08.096]             ...future.result["stdout"] <- base::list(NULL)
[15:31:08.096]         }
[15:31:08.096]         base::close(...future.stdout)
[15:31:08.096]         ...future.stdout <- NULL
[15:31:08.096]     }
[15:31:08.096]     ...future.result$conditions <- ...future.conditions
[15:31:08.096]     ...future.result$finished <- base::Sys.time()
[15:31:08.096]     ...future.result
[15:31:08.096] }
[15:31:08.106] Exporting 5 global objects (960 bytes) to cluster node #1 ...
[15:31:08.107] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:31:08.107] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:31:08.108] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:31:08.109] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:31:08.109] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[15:31:08.110] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[15:31:08.110] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:31:08.112] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:31:08.113] Exporting '...future.globals.maxSize' (56 bytes) to cluster node #1 ...
[15:31:08.113] Exporting '...future.globals.maxSize' (56 bytes) to cluster node #1 ... DONE
[15:31:08.114] Exporting 5 global objects (960 bytes) to cluster node #1 ... DONE
[15:31:08.115] MultisessionFuture started
[15:31:08.115] - Launch lazy future ... done
[15:31:08.115] run() for 'MultisessionFuture' ... done
[15:31:08.116] Created future:
[15:31:08.140] receiveMessageFromWorker() for ClusterFuture ...
[15:31:08.141] - Validating connection of MultisessionFuture
[15:31:08.141] - received message: FutureResult
[15:31:08.142] - Received FutureResult
[15:31:08.142] - Erased future from FutureRegistry
[15:31:08.142] result() for ClusterFuture ...
[15:31:08.143] - result already collected: FutureResult
[15:31:08.143] result() for ClusterFuture ... done
[15:31:08.143] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:08.116] MultisessionFuture:
[15:31:08.116] Label: 'future_apply-2'
[15:31:08.116] Expression:
[15:31:08.116] {
[15:31:08.116]     do.call(function(...) {
[15:31:08.116]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:08.116]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:08.116]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:08.116]             on.exit(options(oopts), add = TRUE)
[15:31:08.116]         }
[15:31:08.116]         {
[15:31:08.116]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:08.116]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:08.116]                 ...future.FUN(...future.X_jj, ...)
[15:31:08.116]             })
[15:31:08.116]         }
[15:31:08.116]     }, args = future.call.arguments)
[15:31:08.116] }
[15:31:08.116] Lazy evaluation: FALSE
[15:31:08.116] Asynchronous evaluation: TRUE
[15:31:08.116] Local evaluation: TRUE
[15:31:08.116] Environment: R_GlobalEnv
[15:31:08.116] Capture standard output: TRUE
[15:31:08.116] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:08.116] Globals: 5 objects totaling 960 bytes (DotDotDotList 'future.call.arguments' of 0 bytes, function '...future.FUN' of 848 bytes, list '...future.elements_ii' of 56 bytes, NULL '...future.seeds_ii' of 0 bytes, numeric '...future.globals.maxSize' of 56 bytes)
[15:31:08.116] Packages: <none>
[15:31:08.116] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:08.116] Resolved: TRUE
[15:31:08.116] Value: <not collected>
[15:31:08.116] Conditions captured: <none>
[15:31:08.116] Early signaling: FALSE
[15:31:08.116] Owner process: 6672a580-6d3c-e82f-380e-108c475ace70
[15:31:08.116] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:08.144] Chunk #2 of 2 ... DONE
[15:31:08.144] Launching 2 futures (chunks) ... DONE
[15:31:08.144] Resolving 2 futures (chunks) ...
[15:31:08.145] resolve() on list ...
[15:31:08.145]  recursive: 0
[15:31:08.145]  length: 2
[15:31:08.146] 
[15:31:08.146] Future #1
[15:31:08.146] result() for ClusterFuture ...
[15:31:08.146] - result already collected: FutureResult
[15:31:08.147] result() for ClusterFuture ... done
[15:31:08.147] result() for ClusterFuture ...
[15:31:08.147] - result already collected: FutureResult
[15:31:08.147] result() for ClusterFuture ... done
[15:31:08.148] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:31:08.148] - nx: 2
[15:31:08.148] - relay: TRUE
[15:31:08.148] - stdout: TRUE
[15:31:08.149] - signal: TRUE
[15:31:08.149] - resignal: FALSE
[15:31:08.149] - force: TRUE
[15:31:08.149] - relayed: [n=2] FALSE, FALSE
[15:31:08.150] - queued futures: [n=2] FALSE, FALSE
[15:31:08.150]  - until=1
[15:31:08.150]  - relaying element #1
[15:31:08.150] result() for ClusterFuture ...
[15:31:08.151] - result already collected: FutureResult
[15:31:08.151] result() for ClusterFuture ... done
[15:31:08.151] result() for ClusterFuture ...
[15:31:08.151] - result already collected: FutureResult
[15:31:08.152] result() for ClusterFuture ... done
[15:31:08.152] result() for ClusterFuture ...
[15:31:08.152] - result already collected: FutureResult
[15:31:08.152] result() for ClusterFuture ... done
[15:31:08.153] result() for ClusterFuture ...
[15:31:08.153] - result already collected: FutureResult
[15:31:08.153] result() for ClusterFuture ... done
[15:31:08.153] - relayed: [n=2] TRUE, FALSE
[15:31:08.154] - queued futures: [n=2] TRUE, FALSE
[15:31:08.154] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:31:08.154]  length: 1 (resolved future 1)
[15:31:08.155] Future #2
[15:31:08.155] result() for ClusterFuture ...
[15:31:08.155] - result already collected: FutureResult
[15:31:08.155] result() for ClusterFuture ... done
[15:31:08.156] result() for ClusterFuture ...
[15:31:08.156] - result already collected: FutureResult
[15:31:08.156] result() for ClusterFuture ... done
[15:31:08.156] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:31:08.157] - nx: 2
[15:31:08.157] - relay: TRUE
[15:31:08.157] - stdout: TRUE
[15:31:08.158] - signal: TRUE
[15:31:08.158] - resignal: FALSE
[15:31:08.158] - force: TRUE
[15:31:08.158] - relayed: [n=2] TRUE, FALSE
[15:31:08.159] - queued futures: [n=2] TRUE, FALSE
[15:31:08.159]  - until=2
[15:31:08.159]  - relaying element #2
[15:31:08.160] result() for ClusterFuture ...
[15:31:08.160] - result already collected: FutureResult
[15:31:08.160] result() for ClusterFuture ... done
[15:31:08.161] result() for ClusterFuture ...
[15:31:08.161] - result already collected: FutureResult
[15:31:08.161] result() for ClusterFuture ... done
[15:31:08.162] result() for ClusterFuture ...
[15:31:08.162] - result already collected: FutureResult
[15:31:08.162] result() for ClusterFuture ... done
[15:31:08.162] result() for ClusterFuture ...
[15:31:08.163] - result already collected: FutureResult
[15:31:08.163] result() for ClusterFuture ... done
[15:31:08.163] - relayed: [n=2] TRUE, TRUE
[15:31:08.164] - queued futures: [n=2] TRUE, TRUE
[15:31:08.164] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:31:08.164]  length: 0 (resolved future 2)
[15:31:08.165] Relaying remaining futures
[15:31:08.165] signalConditionsASAP(NULL, pos=0) ...
[15:31:08.165] - nx: 2
[15:31:08.165] - relay: TRUE
[15:31:08.166] - stdout: TRUE
[15:31:08.166] - signal: TRUE
[15:31:08.166] - resignal: FALSE
[15:31:08.167] - force: TRUE
[15:31:08.167] - relayed: [n=2] TRUE, TRUE
[15:31:08.167] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:31:08.168] - relayed: [n=2] TRUE, TRUE
[15:31:08.168] - queued futures: [n=2] TRUE, TRUE
[15:31:08.168] signalConditionsASAP(NULL, pos=0) ... done
[15:31:08.169] resolve() on list ... DONE
[15:31:08.169] result() for ClusterFuture ...
[15:31:08.169] - result already collected: FutureResult
[15:31:08.169] result() for ClusterFuture ... done
[15:31:08.170] result() for ClusterFuture ...
[15:31:08.170] - result already collected: FutureResult
[15:31:08.170] result() for ClusterFuture ... done
[15:31:08.171] result() for ClusterFuture ...
[15:31:08.171] - result already collected: FutureResult
[15:31:08.171] result() for ClusterFuture ... done
[15:31:08.172] result() for ClusterFuture ...
[15:31:08.172] - result already collected: FutureResult
[15:31:08.172] result() for ClusterFuture ... done
[15:31:08.173]  - Number of value chunks collected: 2
[15:31:08.173] Resolving 2 futures (chunks) ... DONE
[15:31:08.173] Reducing values from 2 chunks ...
[15:31:08.174]  - Number of values collected after concatenation: 2
[15:31:08.174]  - Number of values expected: 2
[15:31:08.174] Reducing values from 2 chunks ... DONE
[15:31:08.174] future_lapply() ... DONE
a b 
1 2 
- apply(X, ...) - dim(X) > 2 ...
[15:31:08.175] getGlobalsAndPackagesXApply() ...
[15:31:08.175]  - future.globals: TRUE
[15:31:08.176] getGlobalsAndPackages() ...
[15:31:08.176] Searching for globals...
[15:31:08.179] - globals found: [1] 'FUN'
[15:31:08.179] Searching for globals ... DONE
[15:31:08.179] Resolving globals: FALSE
[15:31:08.180] The total size of the 1 globals is 848 bytes (848 bytes)
[15:31:08.181] The total size of the 1 globals exported for future expression ('FUN(X = structure(1:12, dim = c(2L, 2L, 3L)))') is 848 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (848 bytes of class 'function')
[15:31:08.181] - globals: [1] 'FUN'
[15:31:08.182] 
[15:31:08.182] getGlobalsAndPackages() ... DONE
[15:31:08.182]  - globals found/used: [n=1] 'FUN'
[15:31:08.182]  - needed namespaces: [n=0] 
[15:31:08.183] Finding globals ... DONE
[15:31:08.183]  - use_args: TRUE
[15:31:08.183]  - Getting '...' globals ...
[15:31:08.184] resolve() on list ...
[15:31:08.185]  recursive: 0
[15:31:08.185]  length: 1
[15:31:08.185]  elements: '...'
[15:31:08.186]  length: 0 (resolved future 1)
[15:31:08.186] resolve() on list ... DONE
[15:31:08.186]    - '...' content: [n=0] 
[15:31:08.187] List of 1
[15:31:08.187]  $ ...: list()
[15:31:08.187]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:08.187]  - attr(*, "where")=List of 1
[15:31:08.187]   ..$ ...:<environment: 0x000001bcbe262028> 
[15:31:08.187]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:08.187]  - attr(*, "resolved")= logi TRUE
[15:31:08.187]  - attr(*, "total_size")= num NA
[15:31:08.192]  - Getting '...' globals ... DONE
[15:31:08.193] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:08.193] List of 2
[15:31:08.193]  $ ...future.FUN:function (x)  
[15:31:08.193]  $ ...          : list()
[15:31:08.193]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:08.193]  - attr(*, "where")=List of 2
[15:31:08.193]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:08.193]   ..$ ...          :<environment: 0x000001bcbe262028> 
[15:31:08.193]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:08.193]  - attr(*, "resolved")= logi FALSE
[15:31:08.193]  - attr(*, "total_size")= num 848
[15:31:08.199] Packages to be attached in all futures: [n=0] 
[15:31:08.200] getGlobalsAndPackagesXApply() ... DONE
[15:31:08.204] future_lapply() ...
[15:31:08.210] Number of chunks: 2
[15:31:08.210] getGlobalsAndPackagesXApply() ...
[15:31:08.210]  - future.globals: <name-value list> with names 'list()'
[15:31:08.211]  - use_args: TRUE
[15:31:08.211] Globals to be used in all futures (chunks): [n=2] '...', '...future.FUN'
[15:31:08.211] List of 2
[15:31:08.211]  $ ...          : list()
[15:31:08.211]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:08.211]  $ ...future.FUN:function (x)  
[15:31:08.211]  - attr(*, "where")=List of 2
[15:31:08.211]   ..$ ...          :<environment: 0x000001bcbe262028> 
[15:31:08.211]   ..$ ...future.FUN:<environment: namespace:base> 
[15:31:08.211]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:08.211]  - attr(*, "resolved")= logi FALSE
[15:31:08.211]  - attr(*, "total_size")= num NA
[15:31:08.219] Packages to be attached in all futures: [n=0] 
[15:31:08.219] getGlobalsAndPackagesXApply() ... DONE
[15:31:08.219] Number of futures (= number of chunks): 2
[15:31:08.220] Launching 2 futures (chunks) ...
[15:31:08.220] Chunk #1 of 2 ...
[15:31:08.220]  - Adjusted option 'future.globals.maxSize': Inf -> 2 * Inf = Inf (bytes)
[15:31:08.221]  - seeds: <none>
[15:31:08.221]  - All globals exported: [n=5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:08.221] getGlobalsAndPackages() ...
[15:31:08.221] - globals passed as-is: [5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:08.222] Resolving globals: FALSE
[15:31:08.222] Tweak future expression to call with '...' arguments ...
[15:31:08.222] {
[15:31:08.222]     do.call(function(...) {
[15:31:08.222]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:08.222]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:08.222]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:08.222]             on.exit(options(oopts), add = TRUE)
[15:31:08.222]         }
[15:31:08.222]         {
[15:31:08.222]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:08.222]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:08.222]                 ...future.FUN(...future.X_jj, ...)
[15:31:08.222]             })
[15:31:08.222]         }
[15:31:08.222]     }, args = future.call.arguments)
[15:31:08.222] }
[15:31:08.223] Tweak future expression to call with '...' arguments ... DONE
[15:31:08.223] - globals: [5] 'future.call.arguments', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:08.223] 
[15:31:08.224] getGlobalsAndPackages() ... DONE
[15:31:08.224] run() for 'Future' ...
[15:31:08.224] - state: 'created'
[15:31:08.225] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:08.242] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:08.242] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:31:08.243]   - Field: 'node'
[15:31:08.243]   - Field: 'label'
[15:31:08.243]   - Field: 'local'
[15:31:08.243]   - Field: 'owner'
[15:31:08.244]   - Field: 'envir'
[15:31:08.244]   - Field: 'workers'
[15:31:08.244]   - Field: 'packages'
[15:31:08.244]   - Field: 'gc'
[15:31:08.244]   - Field: 'conditions'
[15:31:08.245]   - Field: 'persistent'
[15:31:08.245]   - Field: 'expr'
[15:31:08.245]   - Field: 'uuid'
[15:31:08.245]   - Field: 'seed'
[15:31:08.246]   - Field: 'version'
[15:31:08.246]   - Field: 'result'
[15:31:08.246]   - Field: 'asynchronous'
[15:31:08.246]   - Field: 'calls'
[15:31:08.247]   - Field: 'globals'
[15:31:08.247]   - Field: 'stdout'
[15:31:08.247]   - Field: 'earlySignal'
[15:31:08.248]   - Field: 'lazy'
[15:31:08.248]   - Field: 'state'
[15:31:08.248] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:31:08.249] - Launch lazy future ...
[15:31:08.250] Packages needed by the future expression (n = 0): <none>
[15:31:08.250] Packages needed by future strategies (n = 0): <none>
[15:31:08.251] {
[15:31:08.251]     {
[15:31:08.251]         {
[15:31:08.251]             ...future.startTime <- base::Sys.time()
[15:31:08.251]             {
[15:31:08.251]                 {
[15:31:08.251]                   {
[15:31:08.251]                     {
[15:31:08.251]                       base::local({
[15:31:08.251]                         has_future <- base::requireNamespace("future", 
[15:31:08.251]                           quietly = TRUE)
[15:31:08.251]                         if (has_future) {
[15:31:08.251]                           ns <- base::getNamespace("future")
[15:31:08.251]                           version <- ns[[".package"]][["version"]]
[15:31:08.251]                           if (is.null(version)) 
[15:31:08.251]                             version <- utils::packageVersion("future")
[15:31:08.251]                         }
[15:31:08.251]                         else {
[15:31:08.251]                           version <- NULL
[15:31:08.251]                         }
[15:31:08.251]                         if (!has_future || version < "1.8.0") {
[15:31:08.251]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:08.251]                             "", base::R.version$version.string), 
[15:31:08.251]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:08.251]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:08.251]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:08.251]                               "release", "version")], collapse = " "), 
[15:31:08.251]                             hostname = base::Sys.info()[["nodename"]])
[15:31:08.251]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:08.251]                             info)
[15:31:08.251]                           info <- base::paste(info, collapse = "; ")
[15:31:08.251]                           if (!has_future) {
[15:31:08.251]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:08.251]                               info)
[15:31:08.251]                           }
[15:31:08.251]                           else {
[15:31:08.251]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:08.251]                               info, version)
[15:31:08.251]                           }
[15:31:08.251]                           base::stop(msg)
[15:31:08.251]                         }
[15:31:08.251]                       })
[15:31:08.251]                     }
[15:31:08.251]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:08.251]                     base::options(mc.cores = 1L)
[15:31:08.251]                   }
[15:31:08.251]                   ...future.strategy.old <- future::plan("list")
[15:31:08.251]                   options(future.plan = NULL)
[15:31:08.251]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:08.251]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:08.251]                 }
[15:31:08.251]                 ...future.workdir <- getwd()
[15:31:08.251]             }
[15:31:08.251]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:08.251]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:08.251]         }
[15:31:08.251]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:08.251]             future.globals.maxSize = Inf, future.globals.method = NULL, 
[15:31:08.251]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:08.251]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:08.251]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:08.251]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:08.251]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:08.251]             base::names(...future.oldOptions))
[15:31:08.251]     }
[15:31:08.251]     if (FALSE) {
[15:31:08.251]     }
[15:31:08.251]     else {
[15:31:08.251]         if (TRUE) {
[15:31:08.251]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:08.251]                 open = "w")
[15:31:08.251]         }
[15:31:08.251]         else {
[15:31:08.251]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:08.251]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:08.251]         }
[15:31:08.251]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:08.251]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:08.251]             base::sink(type = "output", split = FALSE)
[15:31:08.251]             base::close(...future.stdout)
[15:31:08.251]         }, add = TRUE)
[15:31:08.251]     }
[15:31:08.251]     ...future.frame <- base::sys.nframe()
[15:31:08.251]     ...future.conditions <- base::list()
[15:31:08.251]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:08.251]     if (FALSE) {
[15:31:08.251]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:08.251]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:08.251]     }
[15:31:08.251]     ...future.result <- base::tryCatch({
[15:31:08.251]         base::withCallingHandlers({
[15:31:08.251]             ...future.value <- base::withVisible(base::local({
[15:31:08.251]                 ...future.makeSendCondition <- base::local({
[15:31:08.251]                   sendCondition <- NULL
[15:31:08.251]                   function(frame = 1L) {
[15:31:08.251]                     if (is.function(sendCondition)) 
[15:31:08.251]                       return(sendCondition)
[15:31:08.251]                     ns <- getNamespace("parallel")
[15:31:08.251]                     if (exists("sendData", mode = "function", 
[15:31:08.251]                       envir = ns)) {
[15:31:08.251]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:08.251]                         envir = ns)
[15:31:08.251]                       envir <- sys.frame(frame)
[15:31:08.251]                       master <- NULL
[15:31:08.251]                       while (!identical(envir, .GlobalEnv) && 
[15:31:08.251]                         !identical(envir, emptyenv())) {
[15:31:08.251]                         if (exists("master", mode = "list", envir = envir, 
[15:31:08.251]                           inherits = FALSE)) {
[15:31:08.251]                           master <- get("master", mode = "list", 
[15:31:08.251]                             envir = envir, inherits = FALSE)
[15:31:08.251]                           if (inherits(master, c("SOCKnode", 
[15:31:08.251]                             "SOCK0node"))) {
[15:31:08.251]                             sendCondition <<- function(cond) {
[15:31:08.251]                               data <- list(type = "VALUE", value = cond, 
[15:31:08.251]                                 success = TRUE)
[15:31:08.251]                               parallel_sendData(master, data)
[15:31:08.251]                             }
[15:31:08.251]                             return(sendCondition)
[15:31:08.251]                           }
[15:31:08.251]                         }
[15:31:08.251]                         frame <- frame + 1L
[15:31:08.251]                         envir <- sys.frame(frame)
[15:31:08.251]                       }
[15:31:08.251]                     }
[15:31:08.251]                     sendCondition <<- function(cond) NULL
[15:31:08.251]                   }
[15:31:08.251]                 })
[15:31:08.251]                 withCallingHandlers({
[15:31:08.251]                   {
[15:31:08.251]                     do.call(function(...) {
[15:31:08.251]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:08.251]                       if (!identical(...future.globals.maxSize.org, 
[15:31:08.251]                         ...future.globals.maxSize)) {
[15:31:08.251]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:08.251]                         on.exit(options(oopts), add = TRUE)
[15:31:08.251]                       }
[15:31:08.251]                       {
[15:31:08.251]                         lapply(seq_along(...future.elements_ii), 
[15:31:08.251]                           FUN = function(jj) {
[15:31:08.251]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:08.251]                             ...future.FUN(...future.X_jj, ...)
[15:31:08.251]                           })
[15:31:08.251]                       }
[15:31:08.251]                     }, args = future.call.arguments)
[15:31:08.251]                   }
[15:31:08.251]                 }, immediateCondition = function(cond) {
[15:31:08.251]                   sendCondition <- ...future.makeSendCondition()
[15:31:08.251]                   sendCondition(cond)
[15:31:08.251]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:08.251]                   {
[15:31:08.251]                     inherits <- base::inherits
[15:31:08.251]                     invokeRestart <- base::invokeRestart
[15:31:08.251]                     is.null <- base::is.null
[15:31:08.251]                     muffled <- FALSE
[15:31:08.251]                     if (inherits(cond, "message")) {
[15:31:08.251]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:08.251]                       if (muffled) 
[15:31:08.251]                         invokeRestart("muffleMessage")
[15:31:08.251]                     }
[15:31:08.251]                     else if (inherits(cond, "warning")) {
[15:31:08.251]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:08.251]                       if (muffled) 
[15:31:08.251]                         invokeRestart("muffleWarning")
[15:31:08.251]                     }
[15:31:08.251]                     else if (inherits(cond, "condition")) {
[15:31:08.251]                       if (!is.null(pattern)) {
[15:31:08.251]                         computeRestarts <- base::computeRestarts
[15:31:08.251]                         grepl <- base::grepl
[15:31:08.251]                         restarts <- computeRestarts(cond)
[15:31:08.251]                         for (restart in restarts) {
[15:31:08.251]                           name <- restart$name
[15:31:08.251]                           if (is.null(name)) 
[15:31:08.251]                             next
[15:31:08.251]                           if (!grepl(pattern, name)) 
[15:31:08.251]                             next
[15:31:08.251]                           invokeRestart(restart)
[15:31:08.251]                           muffled <- TRUE
[15:31:08.251]                           break
[15:31:08.251]                         }
[15:31:08.251]                       }
[15:31:08.251]                     }
[15:31:08.251]                     invisible(muffled)
[15:31:08.251]                   }
[15:31:08.251]                   muffleCondition(cond)
[15:31:08.251]                 })
[15:31:08.251]             }))
[15:31:08.251]             future::FutureResult(value = ...future.value$value, 
[15:31:08.251]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:08.251]                   ...future.rng), globalenv = if (FALSE) 
[15:31:08.251]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:08.251]                     ...future.globalenv.names))
[15:31:08.251]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:08.251]         }, condition = base::local({
[15:31:08.251]             c <- base::c
[15:31:08.251]             inherits <- base::inherits
[15:31:08.251]             invokeRestart <- base::invokeRestart
[15:31:08.251]             length <- base::length
[15:31:08.251]             list <- base::list
[15:31:08.251]             seq.int <- base::seq.int
[15:31:08.251]             signalCondition <- base::signalCondition
[15:31:08.251]             sys.calls <- base::sys.calls
[15:31:08.251]             `[[` <- base::`[[`
[15:31:08.251]             `+` <- base::`+`
[15:31:08.251]             `<<-` <- base::`<<-`
[15:31:08.251]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:08.251]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:08.251]                   3L)]
[15:31:08.251]             }
[15:31:08.251]             function(cond) {
[15:31:08.251]                 is_error <- inherits(cond, "error")
[15:31:08.251]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:08.251]                   NULL)
[15:31:08.251]                 if (is_error) {
[15:31:08.251]                   sessionInformation <- function() {
[15:31:08.251]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:08.251]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:08.251]                       search = base::search(), system = base::Sys.info())
[15:31:08.251]                   }
[15:31:08.251]                   ...future.conditions[[length(...future.conditions) + 
[15:31:08.251]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:08.251]                     cond$call), session = sessionInformation(), 
[15:31:08.251]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:08.251]                   signalCondition(cond)
[15:31:08.251]                 }
[15:31:08.251]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:08.251]                 "immediateCondition"))) {
[15:31:08.251]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:08.251]                   ...future.conditions[[length(...future.conditions) + 
[15:31:08.251]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:08.251]                   if (TRUE && !signal) {
[15:31:08.251]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:08.251]                     {
[15:31:08.251]                       inherits <- base::inherits
[15:31:08.251]                       invokeRestart <- base::invokeRestart
[15:31:08.251]                       is.null <- base::is.null
[15:31:08.251]                       muffled <- FALSE
[15:31:08.251]                       if (inherits(cond, "message")) {
[15:31:08.251]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:08.251]                         if (muffled) 
[15:31:08.251]                           invokeRestart("muffleMessage")
[15:31:08.251]                       }
[15:31:08.251]                       else if (inherits(cond, "warning")) {
[15:31:08.251]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:08.251]                         if (muffled) 
[15:31:08.251]                           invokeRestart("muffleWarning")
[15:31:08.251]                       }
[15:31:08.251]                       else if (inherits(cond, "condition")) {
[15:31:08.251]                         if (!is.null(pattern)) {
[15:31:08.251]                           computeRestarts <- base::computeRestarts
[15:31:08.251]                           grepl <- base::grepl
[15:31:08.251]                           restarts <- computeRestarts(cond)
[15:31:08.251]                           for (restart in restarts) {
[15:31:08.251]                             name <- restart$name
[15:31:08.251]                             if (is.null(name)) 
[15:31:08.251]                               next
[15:31:08.251]                             if (!grepl(pattern, name)) 
[15:31:08.251]                               next
[15:31:08.251]                             invokeRestart(restart)
[15:31:08.251]                             muffled <- TRUE
[15:31:08.251]                             break
[15:31:08.251]                           }
[15:31:08.251]                         }
[15:31:08.251]                       }
[15:31:08.251]                       invisible(muffled)
[15:31:08.251]                     }
[15:31:08.251]                     muffleCondition(cond, pattern = "^muffle")
[15:31:08.251]                   }
[15:31:08.251]                 }
[15:31:08.251]                 else {
[15:31:08.251]                   if (TRUE) {
[15:31:08.251]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:08.251]                     {
[15:31:08.251]                       inherits <- base::inherits
[15:31:08.251]                       invokeRestart <- base::invokeRestart
[15:31:08.251]                       is.null <- base::is.null
[15:31:08.251]                       muffled <- FALSE
[15:31:08.251]                       if (inherits(cond, "message")) {
[15:31:08.251]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:08.251]                         if (muffled) 
[15:31:08.251]                           invokeRestart("muffleMessage")
[15:31:08.251]                       }
[15:31:08.251]                       else if (inherits(cond, "warning")) {
[15:31:08.251]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:08.251]                         if (muffled) 
[15:31:08.251]                           invokeRestart("muffleWarning")
[15:31:08.251]                       }
[15:31:08.251]                       else if (inherits(cond, "condition")) {
[15:31:08.251]                         if (!is.null(pattern)) {
[15:31:08.251]                           computeRestarts <- base::computeRestarts
[15:31:08.251]                           grepl <- base::grepl
[15:31:08.251]                           restarts <- computeRestarts(cond)
[15:31:08.251]                           for (restart in restarts) {
[15:31:08.251]                             name <- restart$name
[15:31:08.251]                             if (is.null(name)) 
[15:31:08.251]                               next
[15:31:08.251]                             if (!grepl(pattern, name)) 
[15:31:08.251]                               next
[15:31:08.251]                             invokeRestart(restart)
[15:31:08.251]                             muffled <- TRUE
[15:31:08.251]                             break
[15:31:08.251]                           }
[15:31:08.251]                         }
[15:31:08.251]                       }
[15:31:08.251]                       invisible(muffled)
[15:31:08.251]                     }
[15:31:08.251]                     muffleCondition(cond, pattern = "^muffle")
[15:31:08.251]                   }
[15:31:08.251]                 }
[15:31:08.251]             }
[15:31:08.251]         }))
[15:31:08.251]     }, error = function(ex) {
[15:31:08.251]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:08.251]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:08.251]                 ...future.rng), started = ...future.startTime, 
[15:31:08.251]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:08.251]             version = "1.8"), class = "FutureResult")
[15:31:08.251]     }, finally = {
[15:31:08.251]         if (!identical(...future.workdir, getwd())) 
[15:31:08.251]             setwd(...future.workdir)
[15:31:08.251]         {
[15:31:08.251]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:08.251]                 ...future.oldOptions$nwarnings <- NULL
[15:31:08.251]             }
[15:31:08.251]             base::options(...future.oldOptions)
[15:31:08.251]             if (.Platform$OS.type == "windows") {
[15:31:08.251]                 old_names <- names(...future.oldEnvVars)
[15:31:08.251]                 envs <- base::Sys.getenv()
[15:31:08.251]                 names <- names(envs)
[15:31:08.251]                 common <- intersect(names, old_names)
[15:31:08.251]                 added <- setdiff(names, old_names)
[15:31:08.251]                 removed <- setdiff(old_names, names)
[15:31:08.251]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:08.251]                   envs[common]]
[15:31:08.251]                 NAMES <- toupper(changed)
[15:31:08.251]                 args <- list()
[15:31:08.251]                 for (kk in seq_along(NAMES)) {
[15:31:08.251]                   name <- changed[[kk]]
[15:31:08.251]                   NAME <- NAMES[[kk]]
[15:31:08.251]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:08.251]                     next
[15:31:08.251]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:08.251]                 }
[15:31:08.251]                 NAMES <- toupper(added)
[15:31:08.251]                 for (kk in seq_along(NAMES)) {
[15:31:08.251]                   name <- added[[kk]]
[15:31:08.251]                   NAME <- NAMES[[kk]]
[15:31:08.251]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:08.251]                     next
[15:31:08.251]                   args[[name]] <- ""
[15:31:08.251]                 }
[15:31:08.251]                 NAMES <- toupper(removed)
[15:31:08.251]                 for (kk in seq_along(NAMES)) {
[15:31:08.251]                   name <- removed[[kk]]
[15:31:08.251]                   NAME <- NAMES[[kk]]
[15:31:08.251]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:08.251]                     next
[15:31:08.251]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:08.251]                 }
[15:31:08.251]                 if (length(args) > 0) 
[15:31:08.251]                   base::do.call(base::Sys.setenv, args = args)
[15:31:08.251]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:08.251]             }
[15:31:08.251]             else {
[15:31:08.251]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:08.251]             }
[15:31:08.251]             {
[15:31:08.251]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:08.251]                   0L) {
[15:31:08.251]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:08.251]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:08.251]                   base::options(opts)
[15:31:08.251]                 }
[15:31:08.251]                 {
[15:31:08.251]                   {
[15:31:08.251]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:08.251]                     NULL
[15:31:08.251]                   }
[15:31:08.251]                   options(future.plan = NULL)
[15:31:08.251]                   if (is.na(NA_character_)) 
[15:31:08.251]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:08.251]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:08.251]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:08.251]                     .init = FALSE)
[15:31:08.251]                 }
[15:31:08.251]             }
[15:31:08.251]         }
[15:31:08.251]     })
[15:31:08.251]     if (TRUE) {
[15:31:08.251]         base::sink(type = "output", split = FALSE)
[15:31:08.251]         if (TRUE) {
[15:31:08.251]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:08.251]         }
[15:31:08.251]         else {
[15:31:08.251]             ...future.result["stdout"] <- base::list(NULL)
[15:31:08.251]         }
[15:31:08.251]         base::close(...future.stdout)
[15:31:08.251]         ...future.stdout <- NULL
[15:31:08.251]     }
[15:31:08.251]     ...future.result$conditions <- ...future.conditions
[15:31:08.251]     ...future.result$finished <- base::Sys.time()
[15:31:08.251]     ...future.result
[15:31:08.251] }
[15:31:08.260] Exporting 5 global objects (1.12 KiB) to cluster node #1 ...
[15:31:08.261] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:31:08.261] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:31:08.262] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:31:08.263] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:31:08.263] Exporting '...future.elements_ii' (248 bytes) to cluster node #1 ...
[15:31:08.264] Exporting '...future.elements_ii' (248 bytes) to cluster node #1 ... DONE
[15:31:08.264] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:31:08.267] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:31:08.267] Exporting '...future.globals.maxSize' (56 bytes) to cluster node #1 ...
[15:31:08.268] Exporting '...future.globals.maxSize' (56 bytes) to cluster node #1 ... DONE
[15:31:08.269] Exporting 5 global objects (1.12 KiB) to cluster node #1 ... DONE
[15:31:08.270] MultisessionFuture started
[15:31:08.270] - Launch lazy future ... done
[15:31:08.270] run() for 'MultisessionFuture' ... done
[15:31:08.273] Created future:
[15:31:08.296] receiveMessageFromWorker() for ClusterFuture ...
[15:31:08.297] - Validating connection of MultisessionFuture
[15:31:08.297] - received message: FutureResult
[15:31:08.298] - Received FutureResult
[15:31:08.298] - Erased future from FutureRegistry
[15:31:08.298] result() for ClusterFuture ...
[15:31:08.298] - result already collected: FutureResult
[15:31:08.299] result() for ClusterFuture ... done
[15:31:08.299] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:08.274] MultisessionFuture:
[15:31:08.274] Label: 'future_apply-1'
[15:31:08.274] Expression:
[15:31:08.274] {
[15:31:08.274]     do.call(function(...) {
[15:31:08.274]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:08.274]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:08.274]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:08.274]             on.exit(options(oopts), add = TRUE)
[15:31:08.274]         }
[15:31:08.274]         {
[15:31:08.274]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:08.274]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:08.274]                 ...future.FUN(...future.X_jj, ...)
[15:31:08.274]             })
[15:31:08.274]         }
[15:31:08.274]     }, args = future.call.arguments)
[15:31:08.274] }
[15:31:08.274] Lazy evaluation: FALSE
[15:31:08.274] Asynchronous evaluation: TRUE
[15:31:08.274] Local evaluation: TRUE
[15:31:08.274] Environment: R_GlobalEnv
[15:31:08.274] Capture standard output: TRUE
[15:31:08.274] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:08.274] Globals: 5 objects totaling 1.12 KiB (DotDotDotList 'future.call.arguments' of 0 bytes, function '...future.FUN' of 848 bytes, list '...future.elements_ii' of 248 bytes, NULL '...future.seeds_ii' of 0 bytes, numeric '...future.globals.maxSize' of 56 bytes)
[15:31:08.274] Packages: <none>
[15:31:08.274] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:08.274] Resolved: TRUE
[15:31:08.274] Value: <not collected>
[15:31:08.274] Conditions captured: <none>
[15:31:08.274] Early signaling: FALSE
[15:31:08.274] Owner process: 6672a580-6d3c-e82f-380e-108c475ace70
[15:31:08.274] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:08.300] Chunk #1 of 2 ... DONE
[15:31:08.300] Chunk #2 of 2 ...
[15:31:08.300]  - Adjusted option 'future.globals.maxSize': Inf -> 2 * Inf = Inf (bytes)
[15:31:08.301]  - seeds: <none>
[15:31:08.301]  - All globals exported: [n=5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:08.301] getGlobalsAndPackages() ...
[15:31:08.301] - globals passed as-is: [5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:08.302] Resolving globals: FALSE
[15:31:08.302] Tweak future expression to call with '...' arguments ...
[15:31:08.302] {
[15:31:08.302]     do.call(function(...) {
[15:31:08.302]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:08.302]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:08.302]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:08.302]             on.exit(options(oopts), add = TRUE)
[15:31:08.302]         }
[15:31:08.302]         {
[15:31:08.302]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:08.302]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:08.302]                 ...future.FUN(...future.X_jj, ...)
[15:31:08.302]             })
[15:31:08.302]         }
[15:31:08.302]     }, args = future.call.arguments)
[15:31:08.302] }
[15:31:08.303] Tweak future expression to call with '...' arguments ... DONE
[15:31:08.303] - globals: [5] 'future.call.arguments', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:08.304] 
[15:31:08.304] getGlobalsAndPackages() ... DONE
[15:31:08.304] run() for 'Future' ...
[15:31:08.305] - state: 'created'
[15:31:08.305] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:08.323] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:08.323] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:31:08.324]   - Field: 'node'
[15:31:08.324]   - Field: 'label'
[15:31:08.324]   - Field: 'local'
[15:31:08.324]   - Field: 'owner'
[15:31:08.325]   - Field: 'envir'
[15:31:08.325]   - Field: 'workers'
[15:31:08.325]   - Field: 'packages'
[15:31:08.326]   - Field: 'gc'
[15:31:08.326]   - Field: 'conditions'
[15:31:08.326]   - Field: 'persistent'
[15:31:08.327]   - Field: 'expr'
[15:31:08.327]   - Field: 'uuid'
[15:31:08.327]   - Field: 'seed'
[15:31:08.327]   - Field: 'version'
[15:31:08.328]   - Field: 'result'
[15:31:08.328]   - Field: 'asynchronous'
[15:31:08.328]   - Field: 'calls'
[15:31:08.329]   - Field: 'globals'
[15:31:08.329]   - Field: 'stdout'
[15:31:08.329]   - Field: 'earlySignal'
[15:31:08.330]   - Field: 'lazy'
[15:31:08.330]   - Field: 'state'
[15:31:08.330] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:31:08.330] - Launch lazy future ...
[15:31:08.331] Packages needed by the future expression (n = 0): <none>
[15:31:08.331] Packages needed by future strategies (n = 0): <none>
[15:31:08.332] {
[15:31:08.332]     {
[15:31:08.332]         {
[15:31:08.332]             ...future.startTime <- base::Sys.time()
[15:31:08.332]             {
[15:31:08.332]                 {
[15:31:08.332]                   {
[15:31:08.332]                     {
[15:31:08.332]                       base::local({
[15:31:08.332]                         has_future <- base::requireNamespace("future", 
[15:31:08.332]                           quietly = TRUE)
[15:31:08.332]                         if (has_future) {
[15:31:08.332]                           ns <- base::getNamespace("future")
[15:31:08.332]                           version <- ns[[".package"]][["version"]]
[15:31:08.332]                           if (is.null(version)) 
[15:31:08.332]                             version <- utils::packageVersion("future")
[15:31:08.332]                         }
[15:31:08.332]                         else {
[15:31:08.332]                           version <- NULL
[15:31:08.332]                         }
[15:31:08.332]                         if (!has_future || version < "1.8.0") {
[15:31:08.332]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:08.332]                             "", base::R.version$version.string), 
[15:31:08.332]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:08.332]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:08.332]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:08.332]                               "release", "version")], collapse = " "), 
[15:31:08.332]                             hostname = base::Sys.info()[["nodename"]])
[15:31:08.332]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:08.332]                             info)
[15:31:08.332]                           info <- base::paste(info, collapse = "; ")
[15:31:08.332]                           if (!has_future) {
[15:31:08.332]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:08.332]                               info)
[15:31:08.332]                           }
[15:31:08.332]                           else {
[15:31:08.332]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:08.332]                               info, version)
[15:31:08.332]                           }
[15:31:08.332]                           base::stop(msg)
[15:31:08.332]                         }
[15:31:08.332]                       })
[15:31:08.332]                     }
[15:31:08.332]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:08.332]                     base::options(mc.cores = 1L)
[15:31:08.332]                   }
[15:31:08.332]                   ...future.strategy.old <- future::plan("list")
[15:31:08.332]                   options(future.plan = NULL)
[15:31:08.332]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:08.332]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:08.332]                 }
[15:31:08.332]                 ...future.workdir <- getwd()
[15:31:08.332]             }
[15:31:08.332]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:08.332]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:08.332]         }
[15:31:08.332]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:08.332]             future.globals.maxSize = Inf, future.globals.method = NULL, 
[15:31:08.332]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:08.332]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:08.332]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:08.332]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:08.332]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:08.332]             base::names(...future.oldOptions))
[15:31:08.332]     }
[15:31:08.332]     if (FALSE) {
[15:31:08.332]     }
[15:31:08.332]     else {
[15:31:08.332]         if (TRUE) {
[15:31:08.332]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:08.332]                 open = "w")
[15:31:08.332]         }
[15:31:08.332]         else {
[15:31:08.332]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:08.332]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:08.332]         }
[15:31:08.332]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:08.332]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:08.332]             base::sink(type = "output", split = FALSE)
[15:31:08.332]             base::close(...future.stdout)
[15:31:08.332]         }, add = TRUE)
[15:31:08.332]     }
[15:31:08.332]     ...future.frame <- base::sys.nframe()
[15:31:08.332]     ...future.conditions <- base::list()
[15:31:08.332]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:08.332]     if (FALSE) {
[15:31:08.332]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:08.332]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:08.332]     }
[15:31:08.332]     ...future.result <- base::tryCatch({
[15:31:08.332]         base::withCallingHandlers({
[15:31:08.332]             ...future.value <- base::withVisible(base::local({
[15:31:08.332]                 ...future.makeSendCondition <- base::local({
[15:31:08.332]                   sendCondition <- NULL
[15:31:08.332]                   function(frame = 1L) {
[15:31:08.332]                     if (is.function(sendCondition)) 
[15:31:08.332]                       return(sendCondition)
[15:31:08.332]                     ns <- getNamespace("parallel")
[15:31:08.332]                     if (exists("sendData", mode = "function", 
[15:31:08.332]                       envir = ns)) {
[15:31:08.332]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:08.332]                         envir = ns)
[15:31:08.332]                       envir <- sys.frame(frame)
[15:31:08.332]                       master <- NULL
[15:31:08.332]                       while (!identical(envir, .GlobalEnv) && 
[15:31:08.332]                         !identical(envir, emptyenv())) {
[15:31:08.332]                         if (exists("master", mode = "list", envir = envir, 
[15:31:08.332]                           inherits = FALSE)) {
[15:31:08.332]                           master <- get("master", mode = "list", 
[15:31:08.332]                             envir = envir, inherits = FALSE)
[15:31:08.332]                           if (inherits(master, c("SOCKnode", 
[15:31:08.332]                             "SOCK0node"))) {
[15:31:08.332]                             sendCondition <<- function(cond) {
[15:31:08.332]                               data <- list(type = "VALUE", value = cond, 
[15:31:08.332]                                 success = TRUE)
[15:31:08.332]                               parallel_sendData(master, data)
[15:31:08.332]                             }
[15:31:08.332]                             return(sendCondition)
[15:31:08.332]                           }
[15:31:08.332]                         }
[15:31:08.332]                         frame <- frame + 1L
[15:31:08.332]                         envir <- sys.frame(frame)
[15:31:08.332]                       }
[15:31:08.332]                     }
[15:31:08.332]                     sendCondition <<- function(cond) NULL
[15:31:08.332]                   }
[15:31:08.332]                 })
[15:31:08.332]                 withCallingHandlers({
[15:31:08.332]                   {
[15:31:08.332]                     do.call(function(...) {
[15:31:08.332]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:08.332]                       if (!identical(...future.globals.maxSize.org, 
[15:31:08.332]                         ...future.globals.maxSize)) {
[15:31:08.332]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:08.332]                         on.exit(options(oopts), add = TRUE)
[15:31:08.332]                       }
[15:31:08.332]                       {
[15:31:08.332]                         lapply(seq_along(...future.elements_ii), 
[15:31:08.332]                           FUN = function(jj) {
[15:31:08.332]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:08.332]                             ...future.FUN(...future.X_jj, ...)
[15:31:08.332]                           })
[15:31:08.332]                       }
[15:31:08.332]                     }, args = future.call.arguments)
[15:31:08.332]                   }
[15:31:08.332]                 }, immediateCondition = function(cond) {
[15:31:08.332]                   sendCondition <- ...future.makeSendCondition()
[15:31:08.332]                   sendCondition(cond)
[15:31:08.332]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:08.332]                   {
[15:31:08.332]                     inherits <- base::inherits
[15:31:08.332]                     invokeRestart <- base::invokeRestart
[15:31:08.332]                     is.null <- base::is.null
[15:31:08.332]                     muffled <- FALSE
[15:31:08.332]                     if (inherits(cond, "message")) {
[15:31:08.332]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:08.332]                       if (muffled) 
[15:31:08.332]                         invokeRestart("muffleMessage")
[15:31:08.332]                     }
[15:31:08.332]                     else if (inherits(cond, "warning")) {
[15:31:08.332]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:08.332]                       if (muffled) 
[15:31:08.332]                         invokeRestart("muffleWarning")
[15:31:08.332]                     }
[15:31:08.332]                     else if (inherits(cond, "condition")) {
[15:31:08.332]                       if (!is.null(pattern)) {
[15:31:08.332]                         computeRestarts <- base::computeRestarts
[15:31:08.332]                         grepl <- base::grepl
[15:31:08.332]                         restarts <- computeRestarts(cond)
[15:31:08.332]                         for (restart in restarts) {
[15:31:08.332]                           name <- restart$name
[15:31:08.332]                           if (is.null(name)) 
[15:31:08.332]                             next
[15:31:08.332]                           if (!grepl(pattern, name)) 
[15:31:08.332]                             next
[15:31:08.332]                           invokeRestart(restart)
[15:31:08.332]                           muffled <- TRUE
[15:31:08.332]                           break
[15:31:08.332]                         }
[15:31:08.332]                       }
[15:31:08.332]                     }
[15:31:08.332]                     invisible(muffled)
[15:31:08.332]                   }
[15:31:08.332]                   muffleCondition(cond)
[15:31:08.332]                 })
[15:31:08.332]             }))
[15:31:08.332]             future::FutureResult(value = ...future.value$value, 
[15:31:08.332]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:08.332]                   ...future.rng), globalenv = if (FALSE) 
[15:31:08.332]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:08.332]                     ...future.globalenv.names))
[15:31:08.332]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:08.332]         }, condition = base::local({
[15:31:08.332]             c <- base::c
[15:31:08.332]             inherits <- base::inherits
[15:31:08.332]             invokeRestart <- base::invokeRestart
[15:31:08.332]             length <- base::length
[15:31:08.332]             list <- base::list
[15:31:08.332]             seq.int <- base::seq.int
[15:31:08.332]             signalCondition <- base::signalCondition
[15:31:08.332]             sys.calls <- base::sys.calls
[15:31:08.332]             `[[` <- base::`[[`
[15:31:08.332]             `+` <- base::`+`
[15:31:08.332]             `<<-` <- base::`<<-`
[15:31:08.332]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:08.332]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:08.332]                   3L)]
[15:31:08.332]             }
[15:31:08.332]             function(cond) {
[15:31:08.332]                 is_error <- inherits(cond, "error")
[15:31:08.332]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:08.332]                   NULL)
[15:31:08.332]                 if (is_error) {
[15:31:08.332]                   sessionInformation <- function() {
[15:31:08.332]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:08.332]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:08.332]                       search = base::search(), system = base::Sys.info())
[15:31:08.332]                   }
[15:31:08.332]                   ...future.conditions[[length(...future.conditions) + 
[15:31:08.332]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:08.332]                     cond$call), session = sessionInformation(), 
[15:31:08.332]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:08.332]                   signalCondition(cond)
[15:31:08.332]                 }
[15:31:08.332]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:08.332]                 "immediateCondition"))) {
[15:31:08.332]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:08.332]                   ...future.conditions[[length(...future.conditions) + 
[15:31:08.332]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:08.332]                   if (TRUE && !signal) {
[15:31:08.332]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:08.332]                     {
[15:31:08.332]                       inherits <- base::inherits
[15:31:08.332]                       invokeRestart <- base::invokeRestart
[15:31:08.332]                       is.null <- base::is.null
[15:31:08.332]                       muffled <- FALSE
[15:31:08.332]                       if (inherits(cond, "message")) {
[15:31:08.332]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:08.332]                         if (muffled) 
[15:31:08.332]                           invokeRestart("muffleMessage")
[15:31:08.332]                       }
[15:31:08.332]                       else if (inherits(cond, "warning")) {
[15:31:08.332]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:08.332]                         if (muffled) 
[15:31:08.332]                           invokeRestart("muffleWarning")
[15:31:08.332]                       }
[15:31:08.332]                       else if (inherits(cond, "condition")) {
[15:31:08.332]                         if (!is.null(pattern)) {
[15:31:08.332]                           computeRestarts <- base::computeRestarts
[15:31:08.332]                           grepl <- base::grepl
[15:31:08.332]                           restarts <- computeRestarts(cond)
[15:31:08.332]                           for (restart in restarts) {
[15:31:08.332]                             name <- restart$name
[15:31:08.332]                             if (is.null(name)) 
[15:31:08.332]                               next
[15:31:08.332]                             if (!grepl(pattern, name)) 
[15:31:08.332]                               next
[15:31:08.332]                             invokeRestart(restart)
[15:31:08.332]                             muffled <- TRUE
[15:31:08.332]                             break
[15:31:08.332]                           }
[15:31:08.332]                         }
[15:31:08.332]                       }
[15:31:08.332]                       invisible(muffled)
[15:31:08.332]                     }
[15:31:08.332]                     muffleCondition(cond, pattern = "^muffle")
[15:31:08.332]                   }
[15:31:08.332]                 }
[15:31:08.332]                 else {
[15:31:08.332]                   if (TRUE) {
[15:31:08.332]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:08.332]                     {
[15:31:08.332]                       inherits <- base::inherits
[15:31:08.332]                       invokeRestart <- base::invokeRestart
[15:31:08.332]                       is.null <- base::is.null
[15:31:08.332]                       muffled <- FALSE
[15:31:08.332]                       if (inherits(cond, "message")) {
[15:31:08.332]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:08.332]                         if (muffled) 
[15:31:08.332]                           invokeRestart("muffleMessage")
[15:31:08.332]                       }
[15:31:08.332]                       else if (inherits(cond, "warning")) {
[15:31:08.332]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:08.332]                         if (muffled) 
[15:31:08.332]                           invokeRestart("muffleWarning")
[15:31:08.332]                       }
[15:31:08.332]                       else if (inherits(cond, "condition")) {
[15:31:08.332]                         if (!is.null(pattern)) {
[15:31:08.332]                           computeRestarts <- base::computeRestarts
[15:31:08.332]                           grepl <- base::grepl
[15:31:08.332]                           restarts <- computeRestarts(cond)
[15:31:08.332]                           for (restart in restarts) {
[15:31:08.332]                             name <- restart$name
[15:31:08.332]                             if (is.null(name)) 
[15:31:08.332]                               next
[15:31:08.332]                             if (!grepl(pattern, name)) 
[15:31:08.332]                               next
[15:31:08.332]                             invokeRestart(restart)
[15:31:08.332]                             muffled <- TRUE
[15:31:08.332]                             break
[15:31:08.332]                           }
[15:31:08.332]                         }
[15:31:08.332]                       }
[15:31:08.332]                       invisible(muffled)
[15:31:08.332]                     }
[15:31:08.332]                     muffleCondition(cond, pattern = "^muffle")
[15:31:08.332]                   }
[15:31:08.332]                 }
[15:31:08.332]             }
[15:31:08.332]         }))
[15:31:08.332]     }, error = function(ex) {
[15:31:08.332]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:08.332]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:08.332]                 ...future.rng), started = ...future.startTime, 
[15:31:08.332]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:08.332]             version = "1.8"), class = "FutureResult")
[15:31:08.332]     }, finally = {
[15:31:08.332]         if (!identical(...future.workdir, getwd())) 
[15:31:08.332]             setwd(...future.workdir)
[15:31:08.332]         {
[15:31:08.332]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:08.332]                 ...future.oldOptions$nwarnings <- NULL
[15:31:08.332]             }
[15:31:08.332]             base::options(...future.oldOptions)
[15:31:08.332]             if (.Platform$OS.type == "windows") {
[15:31:08.332]                 old_names <- names(...future.oldEnvVars)
[15:31:08.332]                 envs <- base::Sys.getenv()
[15:31:08.332]                 names <- names(envs)
[15:31:08.332]                 common <- intersect(names, old_names)
[15:31:08.332]                 added <- setdiff(names, old_names)
[15:31:08.332]                 removed <- setdiff(old_names, names)
[15:31:08.332]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:08.332]                   envs[common]]
[15:31:08.332]                 NAMES <- toupper(changed)
[15:31:08.332]                 args <- list()
[15:31:08.332]                 for (kk in seq_along(NAMES)) {
[15:31:08.332]                   name <- changed[[kk]]
[15:31:08.332]                   NAME <- NAMES[[kk]]
[15:31:08.332]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:08.332]                     next
[15:31:08.332]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:08.332]                 }
[15:31:08.332]                 NAMES <- toupper(added)
[15:31:08.332]                 for (kk in seq_along(NAMES)) {
[15:31:08.332]                   name <- added[[kk]]
[15:31:08.332]                   NAME <- NAMES[[kk]]
[15:31:08.332]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:08.332]                     next
[15:31:08.332]                   args[[name]] <- ""
[15:31:08.332]                 }
[15:31:08.332]                 NAMES <- toupper(removed)
[15:31:08.332]                 for (kk in seq_along(NAMES)) {
[15:31:08.332]                   name <- removed[[kk]]
[15:31:08.332]                   NAME <- NAMES[[kk]]
[15:31:08.332]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:08.332]                     next
[15:31:08.332]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:08.332]                 }
[15:31:08.332]                 if (length(args) > 0) 
[15:31:08.332]                   base::do.call(base::Sys.setenv, args = args)
[15:31:08.332]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:08.332]             }
[15:31:08.332]             else {
[15:31:08.332]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:08.332]             }
[15:31:08.332]             {
[15:31:08.332]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:08.332]                   0L) {
[15:31:08.332]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:08.332]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:08.332]                   base::options(opts)
[15:31:08.332]                 }
[15:31:08.332]                 {
[15:31:08.332]                   {
[15:31:08.332]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:08.332]                     NULL
[15:31:08.332]                   }
[15:31:08.332]                   options(future.plan = NULL)
[15:31:08.332]                   if (is.na(NA_character_)) 
[15:31:08.332]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:08.332]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:08.332]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:08.332]                     .init = FALSE)
[15:31:08.332]                 }
[15:31:08.332]             }
[15:31:08.332]         }
[15:31:08.332]     })
[15:31:08.332]     if (TRUE) {
[15:31:08.332]         base::sink(type = "output", split = FALSE)
[15:31:08.332]         if (TRUE) {
[15:31:08.332]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:08.332]         }
[15:31:08.332]         else {
[15:31:08.332]             ...future.result["stdout"] <- base::list(NULL)
[15:31:08.332]         }
[15:31:08.332]         base::close(...future.stdout)
[15:31:08.332]         ...future.stdout <- NULL
[15:31:08.332]     }
[15:31:08.332]     ...future.result$conditions <- ...future.conditions
[15:31:08.332]     ...future.result$finished <- base::Sys.time()
[15:31:08.332]     ...future.result
[15:31:08.332] }
[15:31:08.341] Exporting 5 global objects (1.12 KiB) to cluster node #1 ...
[15:31:08.342] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:31:08.342] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:31:08.343] Exporting '...future.FUN' (848 bytes) to cluster node #1 ...
[15:31:08.343] Exporting '...future.FUN' (848 bytes) to cluster node #1 ... DONE
[15:31:08.344] Exporting '...future.elements_ii' (248 bytes) to cluster node #1 ...
[15:31:08.344] Exporting '...future.elements_ii' (248 bytes) to cluster node #1 ... DONE
[15:31:08.345] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:31:08.346] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:31:08.346] Exporting '...future.globals.maxSize' (56 bytes) to cluster node #1 ...
[15:31:08.347] Exporting '...future.globals.maxSize' (56 bytes) to cluster node #1 ... DONE
[15:31:08.348] Exporting 5 global objects (1.12 KiB) to cluster node #1 ... DONE
[15:31:08.349] MultisessionFuture started
[15:31:08.349] - Launch lazy future ... done
[15:31:08.350] run() for 'MultisessionFuture' ... done
[15:31:08.350] Created future:
[15:31:08.378] receiveMessageFromWorker() for ClusterFuture ...
[15:31:08.379] - Validating connection of MultisessionFuture
[15:31:08.379] - received message: FutureResult
[15:31:08.380] - Received FutureResult
[15:31:08.380] - Erased future from FutureRegistry
[15:31:08.380] result() for ClusterFuture ...
[15:31:08.381] - result already collected: FutureResult
[15:31:08.381] result() for ClusterFuture ... done
[15:31:08.381] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:08.351] MultisessionFuture:
[15:31:08.351] Label: 'future_apply-2'
[15:31:08.351] Expression:
[15:31:08.351] {
[15:31:08.351]     do.call(function(...) {
[15:31:08.351]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:08.351]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:08.351]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:08.351]             on.exit(options(oopts), add = TRUE)
[15:31:08.351]         }
[15:31:08.351]         {
[15:31:08.351]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:08.351]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:08.351]                 ...future.FUN(...future.X_jj, ...)
[15:31:08.351]             })
[15:31:08.351]         }
[15:31:08.351]     }, args = future.call.arguments)
[15:31:08.351] }
[15:31:08.351] Lazy evaluation: FALSE
[15:31:08.351] Asynchronous evaluation: TRUE
[15:31:08.351] Local evaluation: TRUE
[15:31:08.351] Environment: R_GlobalEnv
[15:31:08.351] Capture standard output: TRUE
[15:31:08.351] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:08.351] Globals: 5 objects totaling 1.12 KiB (DotDotDotList 'future.call.arguments' of 0 bytes, function '...future.FUN' of 848 bytes, list '...future.elements_ii' of 248 bytes, NULL '...future.seeds_ii' of 0 bytes, numeric '...future.globals.maxSize' of 56 bytes)
[15:31:08.351] Packages: <none>
[15:31:08.351] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:08.351] Resolved: TRUE
[15:31:08.351] Value: <not collected>
[15:31:08.351] Conditions captured: <none>
[15:31:08.351] Early signaling: FALSE
[15:31:08.351] Owner process: 6672a580-6d3c-e82f-380e-108c475ace70
[15:31:08.351] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:08.382] Chunk #2 of 2 ... DONE
[15:31:08.382] Launching 2 futures (chunks) ... DONE
[15:31:08.383] Resolving 2 futures (chunks) ...
[15:31:08.383] resolve() on list ...
[15:31:08.383]  recursive: 0
[15:31:08.383]  length: 2
[15:31:08.384] 
[15:31:08.384] Future #1
[15:31:08.384] result() for ClusterFuture ...
[15:31:08.385] - result already collected: FutureResult
[15:31:08.385] result() for ClusterFuture ... done
[15:31:08.385] result() for ClusterFuture ...
[15:31:08.385] - result already collected: FutureResult
[15:31:08.386] result() for ClusterFuture ... done
[15:31:08.386] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:31:08.386] - nx: 2
[15:31:08.386] - relay: TRUE
[15:31:08.387] - stdout: TRUE
[15:31:08.387] - signal: TRUE
[15:31:08.387] - resignal: FALSE
[15:31:08.387] - force: TRUE
[15:31:08.388] - relayed: [n=2] FALSE, FALSE
[15:31:08.388] - queued futures: [n=2] FALSE, FALSE
[15:31:08.388]  - until=1
[15:31:08.389]  - relaying element #1
[15:31:08.389] result() for ClusterFuture ...
[15:31:08.389] - result already collected: FutureResult
[15:31:08.389] result() for ClusterFuture ... done
[15:31:08.390] result() for ClusterFuture ...
[15:31:08.390] - result already collected: FutureResult
[15:31:08.390] result() for ClusterFuture ... done
[15:31:08.391] result() for ClusterFuture ...
[15:31:08.391] - result already collected: FutureResult
[15:31:08.391] result() for ClusterFuture ... done
[15:31:08.391] result() for ClusterFuture ...
[15:31:08.392] - result already collected: FutureResult
[15:31:08.392] result() for ClusterFuture ... done
[15:31:08.392] - relayed: [n=2] TRUE, FALSE
[15:31:08.392] - queued futures: [n=2] TRUE, FALSE
[15:31:08.393] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:31:08.393]  length: 1 (resolved future 1)
[15:31:08.393] Future #2
[15:31:08.394] result() for ClusterFuture ...
[15:31:08.394] - result already collected: FutureResult
[15:31:08.394] result() for ClusterFuture ... done
[15:31:08.394] result() for ClusterFuture ...
[15:31:08.395] - result already collected: FutureResult
[15:31:08.395] result() for ClusterFuture ... done
[15:31:08.395] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:31:08.396] - nx: 2
[15:31:08.396] - relay: TRUE
[15:31:08.396] - stdout: TRUE
[15:31:08.396] - signal: TRUE
[15:31:08.397] - resignal: FALSE
[15:31:08.397] - force: TRUE
[15:31:08.397] - relayed: [n=2] TRUE, FALSE
[15:31:08.397] - queued futures: [n=2] TRUE, FALSE
[15:31:08.398]  - until=2
[15:31:08.398]  - relaying element #2
[15:31:08.398] result() for ClusterFuture ...
[15:31:08.398] - result already collected: FutureResult
[15:31:08.399] result() for ClusterFuture ... done
[15:31:08.399] result() for ClusterFuture ...
[15:31:08.399] - result already collected: FutureResult
[15:31:08.400] result() for ClusterFuture ... done
[15:31:08.400] result() for ClusterFuture ...
[15:31:08.400] - result already collected: FutureResult
[15:31:08.400] result() for ClusterFuture ... done
[15:31:08.401] result() for ClusterFuture ...
[15:31:08.401] - result already collected: FutureResult
[15:31:08.401] result() for ClusterFuture ... done
[15:31:08.401] - relayed: [n=2] TRUE, TRUE
[15:31:08.402] - queued futures: [n=2] TRUE, TRUE
[15:31:08.402] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:31:08.402]  length: 0 (resolved future 2)
[15:31:08.402] Relaying remaining futures
[15:31:08.403] signalConditionsASAP(NULL, pos=0) ...
[15:31:08.403] - nx: 2
[15:31:08.403] - relay: TRUE
[15:31:08.403] - stdout: TRUE
[15:31:08.404] - signal: TRUE
[15:31:08.404] - resignal: FALSE
[15:31:08.404] - force: TRUE
[15:31:08.405] - relayed: [n=2] TRUE, TRUE
[15:31:08.405] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:31:08.406] - relayed: [n=2] TRUE, TRUE
[15:31:08.406] - queued futures: [n=2] TRUE, TRUE
[15:31:08.406] signalConditionsASAP(NULL, pos=0) ... done
[15:31:08.407] resolve() on list ... DONE
[15:31:08.407] result() for ClusterFuture ...
[15:31:08.407] - result already collected: FutureResult
[15:31:08.408] result() for ClusterFuture ... done
[15:31:08.408] result() for ClusterFuture ...
[15:31:08.408] - result already collected: FutureResult
[15:31:08.409] result() for ClusterFuture ... done
[15:31:08.409] result() for ClusterFuture ...
[15:31:08.409] - result already collected: FutureResult
[15:31:08.410] result() for ClusterFuture ... done
[15:31:08.410] result() for ClusterFuture ...
[15:31:08.410] - result already collected: FutureResult
[15:31:08.411] result() for ClusterFuture ... done
[15:31:08.411]  - Number of value chunks collected: 2
[15:31:08.411] Resolving 2 futures (chunks) ... DONE
[15:31:08.412] Reducing values from 2 chunks ...
[15:31:08.412]  - Number of values collected after concatenation: 2
[15:31:08.412]  - Number of values expected: 2
[15:31:08.413] Reducing values from 2 chunks ... DONE
[15:31:08.413] future_lapply() ... DONE
     [,1] [,2]
[1,]    1    2
[2,]    3    4
[3,]    5    6
[4,]    7    8
[5,]    9   10
[6,]   11   12
- apply(X, ...) - not all same names ...
[15:31:08.414] getGlobalsAndPackagesXApply() ...
[15:31:08.414]  - future.globals: TRUE
[15:31:08.414] getGlobalsAndPackages() ...
[15:31:08.415] Searching for globals...
[15:31:08.421] - globals found: [10] 'FUN', '{', 'if', '==', '[', '<-', 'names', 'names<-', 'letters', 'seq_along'
[15:31:08.422] Searching for globals ... DONE
[15:31:08.422] Resolving globals: FALSE
[15:31:08.423] The total size of the 1 globals is 9.66 KiB (9888 bytes)
[15:31:08.424] The total size of the 1 globals exported for future expression ('FUN(X = structure(1:4, dim = c(2L, 2L)))') is 9.66 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (9.66 KiB of class 'function')
[15:31:08.425] - globals: [1] 'FUN'
[15:31:08.425] 
[15:31:08.425] getGlobalsAndPackages() ... DONE
[15:31:08.426]  - globals found/used: [n=1] 'FUN'
[15:31:08.426]  - needed namespaces: [n=0] 
[15:31:08.426] Finding globals ... DONE
[15:31:08.427]  - use_args: TRUE
[15:31:08.427]  - Getting '...' globals ...
[15:31:08.428] resolve() on list ...
[15:31:08.428]  recursive: 0
[15:31:08.429]  length: 1
[15:31:08.429]  elements: '...'
[15:31:08.429]  length: 0 (resolved future 1)
[15:31:08.430] resolve() on list ... DONE
[15:31:08.430]    - '...' content: [n=0] 
[15:31:08.430] List of 1
[15:31:08.430]  $ ...: list()
[15:31:08.430]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:08.430]  - attr(*, "where")=List of 1
[15:31:08.430]   ..$ ...:<environment: 0x000001bcbd456aa8> 
[15:31:08.430]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:08.430]  - attr(*, "resolved")= logi TRUE
[15:31:08.430]  - attr(*, "total_size")= num NA
[15:31:08.437]  - Getting '...' globals ... DONE
[15:31:08.437] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:08.438] List of 2
[15:31:08.438]  $ ...future.FUN:function (x)  
[15:31:08.438]  $ ...          : list()
[15:31:08.438]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:08.438]  - attr(*, "where")=List of 2
[15:31:08.438]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:08.438]   ..$ ...          :<environment: 0x000001bcbd456aa8> 
[15:31:08.438]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:08.438]  - attr(*, "resolved")= logi FALSE
[15:31:08.438]  - attr(*, "total_size")= num 9888
[15:31:08.444] Packages to be attached in all futures: [n=0] 
[15:31:08.444] getGlobalsAndPackagesXApply() ... DONE
[15:31:08.449] future_lapply() ...
[15:31:08.459] Number of chunks: 2
[15:31:08.459] getGlobalsAndPackagesXApply() ...
[15:31:08.459]  - future.globals: <name-value list> with names 'list()'
[15:31:08.460]  - use_args: TRUE
[15:31:08.460] Globals to be used in all futures (chunks): [n=2] '...', '...future.FUN'
[15:31:08.461] List of 2
[15:31:08.461]  $ ...          : list()
[15:31:08.461]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:08.461]  $ ...future.FUN:function (x)  
[15:31:08.461]  - attr(*, "where")=List of 2
[15:31:08.461]   ..$ ...          :<environment: 0x000001bcbd456aa8> 
[15:31:08.461]   ..$ ...future.FUN:<environment: R_GlobalEnv> 
[15:31:08.461]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:08.461]  - attr(*, "resolved")= logi FALSE
[15:31:08.461]  - attr(*, "total_size")= num NA
[15:31:08.467] Packages to be attached in all futures: [n=0] 
[15:31:08.468] getGlobalsAndPackagesXApply() ... DONE
[15:31:08.468] Number of futures (= number of chunks): 2
[15:31:08.469] Launching 2 futures (chunks) ...
[15:31:08.469] Chunk #1 of 2 ...
[15:31:08.469]  - Adjusted option 'future.globals.maxSize': Inf -> 2 * Inf = Inf (bytes)
[15:31:08.470]  - seeds: <none>
[15:31:08.470]  - All globals exported: [n=5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:08.470] getGlobalsAndPackages() ...
[15:31:08.470] - globals passed as-is: [5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:08.471] Resolving globals: FALSE
[15:31:08.471] Tweak future expression to call with '...' arguments ...
[15:31:08.471] {
[15:31:08.471]     do.call(function(...) {
[15:31:08.471]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:08.471]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:08.471]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:08.471]             on.exit(options(oopts), add = TRUE)
[15:31:08.471]         }
[15:31:08.471]         {
[15:31:08.471]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:08.471]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:08.471]                 ...future.FUN(...future.X_jj, ...)
[15:31:08.471]             })
[15:31:08.471]         }
[15:31:08.471]     }, args = future.call.arguments)
[15:31:08.471] }
[15:31:08.472] Tweak future expression to call with '...' arguments ... DONE
[15:31:08.473] - globals: [5] 'future.call.arguments', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:08.474] 
[15:31:08.474] getGlobalsAndPackages() ... DONE
[15:31:08.475] run() for 'Future' ...
[15:31:08.475] - state: 'created'
[15:31:08.475] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:08.498] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:08.498] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:31:08.498]   - Field: 'node'
[15:31:08.499]   - Field: 'label'
[15:31:08.499]   - Field: 'local'
[15:31:08.499]   - Field: 'owner'
[15:31:08.499]   - Field: 'envir'
[15:31:08.500]   - Field: 'workers'
[15:31:08.500]   - Field: 'packages'
[15:31:08.500]   - Field: 'gc'
[15:31:08.500]   - Field: 'conditions'
[15:31:08.500]   - Field: 'persistent'
[15:31:08.500]   - Field: 'expr'
[15:31:08.501]   - Field: 'uuid'
[15:31:08.501]   - Field: 'seed'
[15:31:08.501]   - Field: 'version'
[15:31:08.501]   - Field: 'result'
[15:31:08.501]   - Field: 'asynchronous'
[15:31:08.502]   - Field: 'calls'
[15:31:08.502]   - Field: 'globals'
[15:31:08.502]   - Field: 'stdout'
[15:31:08.502]   - Field: 'earlySignal'
[15:31:08.502]   - Field: 'lazy'
[15:31:08.503]   - Field: 'state'
[15:31:08.503] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:31:08.503] - Launch lazy future ...
[15:31:08.503] Packages needed by the future expression (n = 0): <none>
[15:31:08.504] Packages needed by future strategies (n = 0): <none>
[15:31:08.504] {
[15:31:08.504]     {
[15:31:08.504]         {
[15:31:08.504]             ...future.startTime <- base::Sys.time()
[15:31:08.504]             {
[15:31:08.504]                 {
[15:31:08.504]                   {
[15:31:08.504]                     {
[15:31:08.504]                       base::local({
[15:31:08.504]                         has_future <- base::requireNamespace("future", 
[15:31:08.504]                           quietly = TRUE)
[15:31:08.504]                         if (has_future) {
[15:31:08.504]                           ns <- base::getNamespace("future")
[15:31:08.504]                           version <- ns[[".package"]][["version"]]
[15:31:08.504]                           if (is.null(version)) 
[15:31:08.504]                             version <- utils::packageVersion("future")
[15:31:08.504]                         }
[15:31:08.504]                         else {
[15:31:08.504]                           version <- NULL
[15:31:08.504]                         }
[15:31:08.504]                         if (!has_future || version < "1.8.0") {
[15:31:08.504]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:08.504]                             "", base::R.version$version.string), 
[15:31:08.504]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:08.504]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:08.504]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:08.504]                               "release", "version")], collapse = " "), 
[15:31:08.504]                             hostname = base::Sys.info()[["nodename"]])
[15:31:08.504]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:08.504]                             info)
[15:31:08.504]                           info <- base::paste(info, collapse = "; ")
[15:31:08.504]                           if (!has_future) {
[15:31:08.504]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:08.504]                               info)
[15:31:08.504]                           }
[15:31:08.504]                           else {
[15:31:08.504]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:08.504]                               info, version)
[15:31:08.504]                           }
[15:31:08.504]                           base::stop(msg)
[15:31:08.504]                         }
[15:31:08.504]                       })
[15:31:08.504]                     }
[15:31:08.504]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:08.504]                     base::options(mc.cores = 1L)
[15:31:08.504]                   }
[15:31:08.504]                   ...future.strategy.old <- future::plan("list")
[15:31:08.504]                   options(future.plan = NULL)
[15:31:08.504]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:08.504]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:08.504]                 }
[15:31:08.504]                 ...future.workdir <- getwd()
[15:31:08.504]             }
[15:31:08.504]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:08.504]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:08.504]         }
[15:31:08.504]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:08.504]             future.globals.maxSize = Inf, future.globals.method = NULL, 
[15:31:08.504]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:08.504]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:08.504]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:08.504]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:08.504]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:08.504]             base::names(...future.oldOptions))
[15:31:08.504]     }
[15:31:08.504]     if (FALSE) {
[15:31:08.504]     }
[15:31:08.504]     else {
[15:31:08.504]         if (TRUE) {
[15:31:08.504]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:08.504]                 open = "w")
[15:31:08.504]         }
[15:31:08.504]         else {
[15:31:08.504]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:08.504]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:08.504]         }
[15:31:08.504]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:08.504]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:08.504]             base::sink(type = "output", split = FALSE)
[15:31:08.504]             base::close(...future.stdout)
[15:31:08.504]         }, add = TRUE)
[15:31:08.504]     }
[15:31:08.504]     ...future.frame <- base::sys.nframe()
[15:31:08.504]     ...future.conditions <- base::list()
[15:31:08.504]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:08.504]     if (FALSE) {
[15:31:08.504]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:08.504]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:08.504]     }
[15:31:08.504]     ...future.result <- base::tryCatch({
[15:31:08.504]         base::withCallingHandlers({
[15:31:08.504]             ...future.value <- base::withVisible(base::local({
[15:31:08.504]                 ...future.makeSendCondition <- base::local({
[15:31:08.504]                   sendCondition <- NULL
[15:31:08.504]                   function(frame = 1L) {
[15:31:08.504]                     if (is.function(sendCondition)) 
[15:31:08.504]                       return(sendCondition)
[15:31:08.504]                     ns <- getNamespace("parallel")
[15:31:08.504]                     if (exists("sendData", mode = "function", 
[15:31:08.504]                       envir = ns)) {
[15:31:08.504]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:08.504]                         envir = ns)
[15:31:08.504]                       envir <- sys.frame(frame)
[15:31:08.504]                       master <- NULL
[15:31:08.504]                       while (!identical(envir, .GlobalEnv) && 
[15:31:08.504]                         !identical(envir, emptyenv())) {
[15:31:08.504]                         if (exists("master", mode = "list", envir = envir, 
[15:31:08.504]                           inherits = FALSE)) {
[15:31:08.504]                           master <- get("master", mode = "list", 
[15:31:08.504]                             envir = envir, inherits = FALSE)
[15:31:08.504]                           if (inherits(master, c("SOCKnode", 
[15:31:08.504]                             "SOCK0node"))) {
[15:31:08.504]                             sendCondition <<- function(cond) {
[15:31:08.504]                               data <- list(type = "VALUE", value = cond, 
[15:31:08.504]                                 success = TRUE)
[15:31:08.504]                               parallel_sendData(master, data)
[15:31:08.504]                             }
[15:31:08.504]                             return(sendCondition)
[15:31:08.504]                           }
[15:31:08.504]                         }
[15:31:08.504]                         frame <- frame + 1L
[15:31:08.504]                         envir <- sys.frame(frame)
[15:31:08.504]                       }
[15:31:08.504]                     }
[15:31:08.504]                     sendCondition <<- function(cond) NULL
[15:31:08.504]                   }
[15:31:08.504]                 })
[15:31:08.504]                 withCallingHandlers({
[15:31:08.504]                   {
[15:31:08.504]                     do.call(function(...) {
[15:31:08.504]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:08.504]                       if (!identical(...future.globals.maxSize.org, 
[15:31:08.504]                         ...future.globals.maxSize)) {
[15:31:08.504]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:08.504]                         on.exit(options(oopts), add = TRUE)
[15:31:08.504]                       }
[15:31:08.504]                       {
[15:31:08.504]                         lapply(seq_along(...future.elements_ii), 
[15:31:08.504]                           FUN = function(jj) {
[15:31:08.504]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:08.504]                             ...future.FUN(...future.X_jj, ...)
[15:31:08.504]                           })
[15:31:08.504]                       }
[15:31:08.504]                     }, args = future.call.arguments)
[15:31:08.504]                   }
[15:31:08.504]                 }, immediateCondition = function(cond) {
[15:31:08.504]                   sendCondition <- ...future.makeSendCondition()
[15:31:08.504]                   sendCondition(cond)
[15:31:08.504]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:08.504]                   {
[15:31:08.504]                     inherits <- base::inherits
[15:31:08.504]                     invokeRestart <- base::invokeRestart
[15:31:08.504]                     is.null <- base::is.null
[15:31:08.504]                     muffled <- FALSE
[15:31:08.504]                     if (inherits(cond, "message")) {
[15:31:08.504]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:08.504]                       if (muffled) 
[15:31:08.504]                         invokeRestart("muffleMessage")
[15:31:08.504]                     }
[15:31:08.504]                     else if (inherits(cond, "warning")) {
[15:31:08.504]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:08.504]                       if (muffled) 
[15:31:08.504]                         invokeRestart("muffleWarning")
[15:31:08.504]                     }
[15:31:08.504]                     else if (inherits(cond, "condition")) {
[15:31:08.504]                       if (!is.null(pattern)) {
[15:31:08.504]                         computeRestarts <- base::computeRestarts
[15:31:08.504]                         grepl <- base::grepl
[15:31:08.504]                         restarts <- computeRestarts(cond)
[15:31:08.504]                         for (restart in restarts) {
[15:31:08.504]                           name <- restart$name
[15:31:08.504]                           if (is.null(name)) 
[15:31:08.504]                             next
[15:31:08.504]                           if (!grepl(pattern, name)) 
[15:31:08.504]                             next
[15:31:08.504]                           invokeRestart(restart)
[15:31:08.504]                           muffled <- TRUE
[15:31:08.504]                           break
[15:31:08.504]                         }
[15:31:08.504]                       }
[15:31:08.504]                     }
[15:31:08.504]                     invisible(muffled)
[15:31:08.504]                   }
[15:31:08.504]                   muffleCondition(cond)
[15:31:08.504]                 })
[15:31:08.504]             }))
[15:31:08.504]             future::FutureResult(value = ...future.value$value, 
[15:31:08.504]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:08.504]                   ...future.rng), globalenv = if (FALSE) 
[15:31:08.504]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:08.504]                     ...future.globalenv.names))
[15:31:08.504]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:08.504]         }, condition = base::local({
[15:31:08.504]             c <- base::c
[15:31:08.504]             inherits <- base::inherits
[15:31:08.504]             invokeRestart <- base::invokeRestart
[15:31:08.504]             length <- base::length
[15:31:08.504]             list <- base::list
[15:31:08.504]             seq.int <- base::seq.int
[15:31:08.504]             signalCondition <- base::signalCondition
[15:31:08.504]             sys.calls <- base::sys.calls
[15:31:08.504]             `[[` <- base::`[[`
[15:31:08.504]             `+` <- base::`+`
[15:31:08.504]             `<<-` <- base::`<<-`
[15:31:08.504]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:08.504]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:08.504]                   3L)]
[15:31:08.504]             }
[15:31:08.504]             function(cond) {
[15:31:08.504]                 is_error <- inherits(cond, "error")
[15:31:08.504]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:08.504]                   NULL)
[15:31:08.504]                 if (is_error) {
[15:31:08.504]                   sessionInformation <- function() {
[15:31:08.504]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:08.504]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:08.504]                       search = base::search(), system = base::Sys.info())
[15:31:08.504]                   }
[15:31:08.504]                   ...future.conditions[[length(...future.conditions) + 
[15:31:08.504]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:08.504]                     cond$call), session = sessionInformation(), 
[15:31:08.504]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:08.504]                   signalCondition(cond)
[15:31:08.504]                 }
[15:31:08.504]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:08.504]                 "immediateCondition"))) {
[15:31:08.504]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:08.504]                   ...future.conditions[[length(...future.conditions) + 
[15:31:08.504]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:08.504]                   if (TRUE && !signal) {
[15:31:08.504]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:08.504]                     {
[15:31:08.504]                       inherits <- base::inherits
[15:31:08.504]                       invokeRestart <- base::invokeRestart
[15:31:08.504]                       is.null <- base::is.null
[15:31:08.504]                       muffled <- FALSE
[15:31:08.504]                       if (inherits(cond, "message")) {
[15:31:08.504]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:08.504]                         if (muffled) 
[15:31:08.504]                           invokeRestart("muffleMessage")
[15:31:08.504]                       }
[15:31:08.504]                       else if (inherits(cond, "warning")) {
[15:31:08.504]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:08.504]                         if (muffled) 
[15:31:08.504]                           invokeRestart("muffleWarning")
[15:31:08.504]                       }
[15:31:08.504]                       else if (inherits(cond, "condition")) {
[15:31:08.504]                         if (!is.null(pattern)) {
[15:31:08.504]                           computeRestarts <- base::computeRestarts
[15:31:08.504]                           grepl <- base::grepl
[15:31:08.504]                           restarts <- computeRestarts(cond)
[15:31:08.504]                           for (restart in restarts) {
[15:31:08.504]                             name <- restart$name
[15:31:08.504]                             if (is.null(name)) 
[15:31:08.504]                               next
[15:31:08.504]                             if (!grepl(pattern, name)) 
[15:31:08.504]                               next
[15:31:08.504]                             invokeRestart(restart)
[15:31:08.504]                             muffled <- TRUE
[15:31:08.504]                             break
[15:31:08.504]                           }
[15:31:08.504]                         }
[15:31:08.504]                       }
[15:31:08.504]                       invisible(muffled)
[15:31:08.504]                     }
[15:31:08.504]                     muffleCondition(cond, pattern = "^muffle")
[15:31:08.504]                   }
[15:31:08.504]                 }
[15:31:08.504]                 else {
[15:31:08.504]                   if (TRUE) {
[15:31:08.504]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:08.504]                     {
[15:31:08.504]                       inherits <- base::inherits
[15:31:08.504]                       invokeRestart <- base::invokeRestart
[15:31:08.504]                       is.null <- base::is.null
[15:31:08.504]                       muffled <- FALSE
[15:31:08.504]                       if (inherits(cond, "message")) {
[15:31:08.504]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:08.504]                         if (muffled) 
[15:31:08.504]                           invokeRestart("muffleMessage")
[15:31:08.504]                       }
[15:31:08.504]                       else if (inherits(cond, "warning")) {
[15:31:08.504]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:08.504]                         if (muffled) 
[15:31:08.504]                           invokeRestart("muffleWarning")
[15:31:08.504]                       }
[15:31:08.504]                       else if (inherits(cond, "condition")) {
[15:31:08.504]                         if (!is.null(pattern)) {
[15:31:08.504]                           computeRestarts <- base::computeRestarts
[15:31:08.504]                           grepl <- base::grepl
[15:31:08.504]                           restarts <- computeRestarts(cond)
[15:31:08.504]                           for (restart in restarts) {
[15:31:08.504]                             name <- restart$name
[15:31:08.504]                             if (is.null(name)) 
[15:31:08.504]                               next
[15:31:08.504]                             if (!grepl(pattern, name)) 
[15:31:08.504]                               next
[15:31:08.504]                             invokeRestart(restart)
[15:31:08.504]                             muffled <- TRUE
[15:31:08.504]                             break
[15:31:08.504]                           }
[15:31:08.504]                         }
[15:31:08.504]                       }
[15:31:08.504]                       invisible(muffled)
[15:31:08.504]                     }
[15:31:08.504]                     muffleCondition(cond, pattern = "^muffle")
[15:31:08.504]                   }
[15:31:08.504]                 }
[15:31:08.504]             }
[15:31:08.504]         }))
[15:31:08.504]     }, error = function(ex) {
[15:31:08.504]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:08.504]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:08.504]                 ...future.rng), started = ...future.startTime, 
[15:31:08.504]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:08.504]             version = "1.8"), class = "FutureResult")
[15:31:08.504]     }, finally = {
[15:31:08.504]         if (!identical(...future.workdir, getwd())) 
[15:31:08.504]             setwd(...future.workdir)
[15:31:08.504]         {
[15:31:08.504]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:08.504]                 ...future.oldOptions$nwarnings <- NULL
[15:31:08.504]             }
[15:31:08.504]             base::options(...future.oldOptions)
[15:31:08.504]             if (.Platform$OS.type == "windows") {
[15:31:08.504]                 old_names <- names(...future.oldEnvVars)
[15:31:08.504]                 envs <- base::Sys.getenv()
[15:31:08.504]                 names <- names(envs)
[15:31:08.504]                 common <- intersect(names, old_names)
[15:31:08.504]                 added <- setdiff(names, old_names)
[15:31:08.504]                 removed <- setdiff(old_names, names)
[15:31:08.504]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:08.504]                   envs[common]]
[15:31:08.504]                 NAMES <- toupper(changed)
[15:31:08.504]                 args <- list()
[15:31:08.504]                 for (kk in seq_along(NAMES)) {
[15:31:08.504]                   name <- changed[[kk]]
[15:31:08.504]                   NAME <- NAMES[[kk]]
[15:31:08.504]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:08.504]                     next
[15:31:08.504]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:08.504]                 }
[15:31:08.504]                 NAMES <- toupper(added)
[15:31:08.504]                 for (kk in seq_along(NAMES)) {
[15:31:08.504]                   name <- added[[kk]]
[15:31:08.504]                   NAME <- NAMES[[kk]]
[15:31:08.504]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:08.504]                     next
[15:31:08.504]                   args[[name]] <- ""
[15:31:08.504]                 }
[15:31:08.504]                 NAMES <- toupper(removed)
[15:31:08.504]                 for (kk in seq_along(NAMES)) {
[15:31:08.504]                   name <- removed[[kk]]
[15:31:08.504]                   NAME <- NAMES[[kk]]
[15:31:08.504]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:08.504]                     next
[15:31:08.504]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:08.504]                 }
[15:31:08.504]                 if (length(args) > 0) 
[15:31:08.504]                   base::do.call(base::Sys.setenv, args = args)
[15:31:08.504]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:08.504]             }
[15:31:08.504]             else {
[15:31:08.504]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:08.504]             }
[15:31:08.504]             {
[15:31:08.504]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:08.504]                   0L) {
[15:31:08.504]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:08.504]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:08.504]                   base::options(opts)
[15:31:08.504]                 }
[15:31:08.504]                 {
[15:31:08.504]                   {
[15:31:08.504]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:08.504]                     NULL
[15:31:08.504]                   }
[15:31:08.504]                   options(future.plan = NULL)
[15:31:08.504]                   if (is.na(NA_character_)) 
[15:31:08.504]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:08.504]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:08.504]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:08.504]                     .init = FALSE)
[15:31:08.504]                 }
[15:31:08.504]             }
[15:31:08.504]         }
[15:31:08.504]     })
[15:31:08.504]     if (TRUE) {
[15:31:08.504]         base::sink(type = "output", split = FALSE)
[15:31:08.504]         if (TRUE) {
[15:31:08.504]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:08.504]         }
[15:31:08.504]         else {
[15:31:08.504]             ...future.result["stdout"] <- base::list(NULL)
[15:31:08.504]         }
[15:31:08.504]         base::close(...future.stdout)
[15:31:08.504]         ...future.stdout <- NULL
[15:31:08.504]     }
[15:31:08.504]     ...future.result$conditions <- ...future.conditions
[15:31:08.504]     ...future.result$finished <- base::Sys.time()
[15:31:08.504]     ...future.result
[15:31:08.504] }
[15:31:08.511] Exporting 5 global objects (9.77 KiB) to cluster node #1 ...
[15:31:08.512] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:31:08.513] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:31:08.513] Exporting '...future.FUN' (9.66 KiB) to cluster node #1 ...
[15:31:08.514] Exporting '...future.FUN' (9.66 KiB) to cluster node #1 ... DONE
[15:31:08.514] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[15:31:08.515] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[15:31:08.515] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:31:08.516] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:31:08.516] Exporting '...future.globals.maxSize' (56 bytes) to cluster node #1 ...
[15:31:08.517] Exporting '...future.globals.maxSize' (56 bytes) to cluster node #1 ... DONE
[15:31:08.517] Exporting 5 global objects (9.77 KiB) to cluster node #1 ... DONE
[15:31:08.518] MultisessionFuture started
[15:31:08.518] - Launch lazy future ... done
[15:31:08.518] run() for 'MultisessionFuture' ... done
[15:31:08.519] Created future:
[15:31:08.547] receiveMessageFromWorker() for ClusterFuture ...
[15:31:08.547] - Validating connection of MultisessionFuture
[15:31:08.548] - received message: FutureResult
[15:31:08.548] - Received FutureResult
[15:31:08.549] - Erased future from FutureRegistry
[15:31:08.549] result() for ClusterFuture ...
[15:31:08.549] - result already collected: FutureResult
[15:31:08.549] result() for ClusterFuture ... done
[15:31:08.550] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:08.519] MultisessionFuture:
[15:31:08.519] Label: 'future_apply-1'
[15:31:08.519] Expression:
[15:31:08.519] {
[15:31:08.519]     do.call(function(...) {
[15:31:08.519]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:08.519]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:08.519]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:08.519]             on.exit(options(oopts), add = TRUE)
[15:31:08.519]         }
[15:31:08.519]         {
[15:31:08.519]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:08.519]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:08.519]                 ...future.FUN(...future.X_jj, ...)
[15:31:08.519]             })
[15:31:08.519]         }
[15:31:08.519]     }, args = future.call.arguments)
[15:31:08.519] }
[15:31:08.519] Lazy evaluation: FALSE
[15:31:08.519] Asynchronous evaluation: TRUE
[15:31:08.519] Local evaluation: TRUE
[15:31:08.519] Environment: R_GlobalEnv
[15:31:08.519] Capture standard output: TRUE
[15:31:08.519] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:08.519] Globals: 5 objects totaling 9.77 KiB (DotDotDotList 'future.call.arguments' of 0 bytes, function '...future.FUN' of 9.66 KiB, list '...future.elements_ii' of 56 bytes, NULL '...future.seeds_ii' of 0 bytes, numeric '...future.globals.maxSize' of 56 bytes)
[15:31:08.519] Packages: <none>
[15:31:08.519] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:08.519] Resolved: TRUE
[15:31:08.519] Value: <not collected>
[15:31:08.519] Conditions captured: <none>
[15:31:08.519] Early signaling: FALSE
[15:31:08.519] Owner process: 6672a580-6d3c-e82f-380e-108c475ace70
[15:31:08.519] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:08.551] Chunk #1 of 2 ... DONE
[15:31:08.551] Chunk #2 of 2 ...
[15:31:08.552]  - Adjusted option 'future.globals.maxSize': Inf -> 2 * Inf = Inf (bytes)
[15:31:08.552]  - seeds: <none>
[15:31:08.552]  - All globals exported: [n=5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:08.552] getGlobalsAndPackages() ...
[15:31:08.553] - globals passed as-is: [5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:08.553] Resolving globals: FALSE
[15:31:08.553] Tweak future expression to call with '...' arguments ...
[15:31:08.554] {
[15:31:08.554]     do.call(function(...) {
[15:31:08.554]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:08.554]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:08.554]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:08.554]             on.exit(options(oopts), add = TRUE)
[15:31:08.554]         }
[15:31:08.554]         {
[15:31:08.554]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:08.554]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:08.554]                 ...future.FUN(...future.X_jj, ...)
[15:31:08.554]             })
[15:31:08.554]         }
[15:31:08.554]     }, args = future.call.arguments)
[15:31:08.554] }
[15:31:08.555] Tweak future expression to call with '...' arguments ... DONE
[15:31:08.556] - globals: [5] 'future.call.arguments', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:08.556] 
[15:31:08.556] getGlobalsAndPackages() ... DONE
[15:31:08.557] run() for 'Future' ...
[15:31:08.557] - state: 'created'
[15:31:08.557] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:08.574] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:08.575] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:31:08.575]   - Field: 'node'
[15:31:08.575]   - Field: 'label'
[15:31:08.575]   - Field: 'local'
[15:31:08.576]   - Field: 'owner'
[15:31:08.576]   - Field: 'envir'
[15:31:08.576]   - Field: 'workers'
[15:31:08.577]   - Field: 'packages'
[15:31:08.577]   - Field: 'gc'
[15:31:08.577]   - Field: 'conditions'
[15:31:08.578]   - Field: 'persistent'
[15:31:08.578]   - Field: 'expr'
[15:31:08.578]   - Field: 'uuid'
[15:31:08.578]   - Field: 'seed'
[15:31:08.579]   - Field: 'version'
[15:31:08.579]   - Field: 'result'
[15:31:08.579]   - Field: 'asynchronous'
[15:31:08.580]   - Field: 'calls'
[15:31:08.580]   - Field: 'globals'
[15:31:08.580]   - Field: 'stdout'
[15:31:08.581]   - Field: 'earlySignal'
[15:31:08.581]   - Field: 'lazy'
[15:31:08.581]   - Field: 'state'
[15:31:08.581] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:31:08.582] - Launch lazy future ...
[15:31:08.582] Packages needed by the future expression (n = 0): <none>
[15:31:08.583] Packages needed by future strategies (n = 0): <none>
[15:31:08.584] {
[15:31:08.584]     {
[15:31:08.584]         {
[15:31:08.584]             ...future.startTime <- base::Sys.time()
[15:31:08.584]             {
[15:31:08.584]                 {
[15:31:08.584]                   {
[15:31:08.584]                     {
[15:31:08.584]                       base::local({
[15:31:08.584]                         has_future <- base::requireNamespace("future", 
[15:31:08.584]                           quietly = TRUE)
[15:31:08.584]                         if (has_future) {
[15:31:08.584]                           ns <- base::getNamespace("future")
[15:31:08.584]                           version <- ns[[".package"]][["version"]]
[15:31:08.584]                           if (is.null(version)) 
[15:31:08.584]                             version <- utils::packageVersion("future")
[15:31:08.584]                         }
[15:31:08.584]                         else {
[15:31:08.584]                           version <- NULL
[15:31:08.584]                         }
[15:31:08.584]                         if (!has_future || version < "1.8.0") {
[15:31:08.584]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:08.584]                             "", base::R.version$version.string), 
[15:31:08.584]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:08.584]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:08.584]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:08.584]                               "release", "version")], collapse = " "), 
[15:31:08.584]                             hostname = base::Sys.info()[["nodename"]])
[15:31:08.584]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:08.584]                             info)
[15:31:08.584]                           info <- base::paste(info, collapse = "; ")
[15:31:08.584]                           if (!has_future) {
[15:31:08.584]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:08.584]                               info)
[15:31:08.584]                           }
[15:31:08.584]                           else {
[15:31:08.584]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:08.584]                               info, version)
[15:31:08.584]                           }
[15:31:08.584]                           base::stop(msg)
[15:31:08.584]                         }
[15:31:08.584]                       })
[15:31:08.584]                     }
[15:31:08.584]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:08.584]                     base::options(mc.cores = 1L)
[15:31:08.584]                   }
[15:31:08.584]                   ...future.strategy.old <- future::plan("list")
[15:31:08.584]                   options(future.plan = NULL)
[15:31:08.584]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:08.584]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:08.584]                 }
[15:31:08.584]                 ...future.workdir <- getwd()
[15:31:08.584]             }
[15:31:08.584]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:08.584]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:08.584]         }
[15:31:08.584]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:08.584]             future.globals.maxSize = Inf, future.globals.method = NULL, 
[15:31:08.584]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:08.584]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:08.584]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:08.584]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:08.584]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:08.584]             base::names(...future.oldOptions))
[15:31:08.584]     }
[15:31:08.584]     if (FALSE) {
[15:31:08.584]     }
[15:31:08.584]     else {
[15:31:08.584]         if (TRUE) {
[15:31:08.584]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:08.584]                 open = "w")
[15:31:08.584]         }
[15:31:08.584]         else {
[15:31:08.584]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:08.584]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:08.584]         }
[15:31:08.584]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:08.584]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:08.584]             base::sink(type = "output", split = FALSE)
[15:31:08.584]             base::close(...future.stdout)
[15:31:08.584]         }, add = TRUE)
[15:31:08.584]     }
[15:31:08.584]     ...future.frame <- base::sys.nframe()
[15:31:08.584]     ...future.conditions <- base::list()
[15:31:08.584]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:08.584]     if (FALSE) {
[15:31:08.584]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:08.584]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:08.584]     }
[15:31:08.584]     ...future.result <- base::tryCatch({
[15:31:08.584]         base::withCallingHandlers({
[15:31:08.584]             ...future.value <- base::withVisible(base::local({
[15:31:08.584]                 ...future.makeSendCondition <- base::local({
[15:31:08.584]                   sendCondition <- NULL
[15:31:08.584]                   function(frame = 1L) {
[15:31:08.584]                     if (is.function(sendCondition)) 
[15:31:08.584]                       return(sendCondition)
[15:31:08.584]                     ns <- getNamespace("parallel")
[15:31:08.584]                     if (exists("sendData", mode = "function", 
[15:31:08.584]                       envir = ns)) {
[15:31:08.584]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:08.584]                         envir = ns)
[15:31:08.584]                       envir <- sys.frame(frame)
[15:31:08.584]                       master <- NULL
[15:31:08.584]                       while (!identical(envir, .GlobalEnv) && 
[15:31:08.584]                         !identical(envir, emptyenv())) {
[15:31:08.584]                         if (exists("master", mode = "list", envir = envir, 
[15:31:08.584]                           inherits = FALSE)) {
[15:31:08.584]                           master <- get("master", mode = "list", 
[15:31:08.584]                             envir = envir, inherits = FALSE)
[15:31:08.584]                           if (inherits(master, c("SOCKnode", 
[15:31:08.584]                             "SOCK0node"))) {
[15:31:08.584]                             sendCondition <<- function(cond) {
[15:31:08.584]                               data <- list(type = "VALUE", value = cond, 
[15:31:08.584]                                 success = TRUE)
[15:31:08.584]                               parallel_sendData(master, data)
[15:31:08.584]                             }
[15:31:08.584]                             return(sendCondition)
[15:31:08.584]                           }
[15:31:08.584]                         }
[15:31:08.584]                         frame <- frame + 1L
[15:31:08.584]                         envir <- sys.frame(frame)
[15:31:08.584]                       }
[15:31:08.584]                     }
[15:31:08.584]                     sendCondition <<- function(cond) NULL
[15:31:08.584]                   }
[15:31:08.584]                 })
[15:31:08.584]                 withCallingHandlers({
[15:31:08.584]                   {
[15:31:08.584]                     do.call(function(...) {
[15:31:08.584]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:08.584]                       if (!identical(...future.globals.maxSize.org, 
[15:31:08.584]                         ...future.globals.maxSize)) {
[15:31:08.584]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:08.584]                         on.exit(options(oopts), add = TRUE)
[15:31:08.584]                       }
[15:31:08.584]                       {
[15:31:08.584]                         lapply(seq_along(...future.elements_ii), 
[15:31:08.584]                           FUN = function(jj) {
[15:31:08.584]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:08.584]                             ...future.FUN(...future.X_jj, ...)
[15:31:08.584]                           })
[15:31:08.584]                       }
[15:31:08.584]                     }, args = future.call.arguments)
[15:31:08.584]                   }
[15:31:08.584]                 }, immediateCondition = function(cond) {
[15:31:08.584]                   sendCondition <- ...future.makeSendCondition()
[15:31:08.584]                   sendCondition(cond)
[15:31:08.584]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:08.584]                   {
[15:31:08.584]                     inherits <- base::inherits
[15:31:08.584]                     invokeRestart <- base::invokeRestart
[15:31:08.584]                     is.null <- base::is.null
[15:31:08.584]                     muffled <- FALSE
[15:31:08.584]                     if (inherits(cond, "message")) {
[15:31:08.584]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:08.584]                       if (muffled) 
[15:31:08.584]                         invokeRestart("muffleMessage")
[15:31:08.584]                     }
[15:31:08.584]                     else if (inherits(cond, "warning")) {
[15:31:08.584]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:08.584]                       if (muffled) 
[15:31:08.584]                         invokeRestart("muffleWarning")
[15:31:08.584]                     }
[15:31:08.584]                     else if (inherits(cond, "condition")) {
[15:31:08.584]                       if (!is.null(pattern)) {
[15:31:08.584]                         computeRestarts <- base::computeRestarts
[15:31:08.584]                         grepl <- base::grepl
[15:31:08.584]                         restarts <- computeRestarts(cond)
[15:31:08.584]                         for (restart in restarts) {
[15:31:08.584]                           name <- restart$name
[15:31:08.584]                           if (is.null(name)) 
[15:31:08.584]                             next
[15:31:08.584]                           if (!grepl(pattern, name)) 
[15:31:08.584]                             next
[15:31:08.584]                           invokeRestart(restart)
[15:31:08.584]                           muffled <- TRUE
[15:31:08.584]                           break
[15:31:08.584]                         }
[15:31:08.584]                       }
[15:31:08.584]                     }
[15:31:08.584]                     invisible(muffled)
[15:31:08.584]                   }
[15:31:08.584]                   muffleCondition(cond)
[15:31:08.584]                 })
[15:31:08.584]             }))
[15:31:08.584]             future::FutureResult(value = ...future.value$value, 
[15:31:08.584]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:08.584]                   ...future.rng), globalenv = if (FALSE) 
[15:31:08.584]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:08.584]                     ...future.globalenv.names))
[15:31:08.584]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:08.584]         }, condition = base::local({
[15:31:08.584]             c <- base::c
[15:31:08.584]             inherits <- base::inherits
[15:31:08.584]             invokeRestart <- base::invokeRestart
[15:31:08.584]             length <- base::length
[15:31:08.584]             list <- base::list
[15:31:08.584]             seq.int <- base::seq.int
[15:31:08.584]             signalCondition <- base::signalCondition
[15:31:08.584]             sys.calls <- base::sys.calls
[15:31:08.584]             `[[` <- base::`[[`
[15:31:08.584]             `+` <- base::`+`
[15:31:08.584]             `<<-` <- base::`<<-`
[15:31:08.584]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:08.584]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:08.584]                   3L)]
[15:31:08.584]             }
[15:31:08.584]             function(cond) {
[15:31:08.584]                 is_error <- inherits(cond, "error")
[15:31:08.584]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:08.584]                   NULL)
[15:31:08.584]                 if (is_error) {
[15:31:08.584]                   sessionInformation <- function() {
[15:31:08.584]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:08.584]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:08.584]                       search = base::search(), system = base::Sys.info())
[15:31:08.584]                   }
[15:31:08.584]                   ...future.conditions[[length(...future.conditions) + 
[15:31:08.584]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:08.584]                     cond$call), session = sessionInformation(), 
[15:31:08.584]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:08.584]                   signalCondition(cond)
[15:31:08.584]                 }
[15:31:08.584]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:08.584]                 "immediateCondition"))) {
[15:31:08.584]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:08.584]                   ...future.conditions[[length(...future.conditions) + 
[15:31:08.584]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:08.584]                   if (TRUE && !signal) {
[15:31:08.584]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:08.584]                     {
[15:31:08.584]                       inherits <- base::inherits
[15:31:08.584]                       invokeRestart <- base::invokeRestart
[15:31:08.584]                       is.null <- base::is.null
[15:31:08.584]                       muffled <- FALSE
[15:31:08.584]                       if (inherits(cond, "message")) {
[15:31:08.584]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:08.584]                         if (muffled) 
[15:31:08.584]                           invokeRestart("muffleMessage")
[15:31:08.584]                       }
[15:31:08.584]                       else if (inherits(cond, "warning")) {
[15:31:08.584]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:08.584]                         if (muffled) 
[15:31:08.584]                           invokeRestart("muffleWarning")
[15:31:08.584]                       }
[15:31:08.584]                       else if (inherits(cond, "condition")) {
[15:31:08.584]                         if (!is.null(pattern)) {
[15:31:08.584]                           computeRestarts <- base::computeRestarts
[15:31:08.584]                           grepl <- base::grepl
[15:31:08.584]                           restarts <- computeRestarts(cond)
[15:31:08.584]                           for (restart in restarts) {
[15:31:08.584]                             name <- restart$name
[15:31:08.584]                             if (is.null(name)) 
[15:31:08.584]                               next
[15:31:08.584]                             if (!grepl(pattern, name)) 
[15:31:08.584]                               next
[15:31:08.584]                             invokeRestart(restart)
[15:31:08.584]                             muffled <- TRUE
[15:31:08.584]                             break
[15:31:08.584]                           }
[15:31:08.584]                         }
[15:31:08.584]                       }
[15:31:08.584]                       invisible(muffled)
[15:31:08.584]                     }
[15:31:08.584]                     muffleCondition(cond, pattern = "^muffle")
[15:31:08.584]                   }
[15:31:08.584]                 }
[15:31:08.584]                 else {
[15:31:08.584]                   if (TRUE) {
[15:31:08.584]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:08.584]                     {
[15:31:08.584]                       inherits <- base::inherits
[15:31:08.584]                       invokeRestart <- base::invokeRestart
[15:31:08.584]                       is.null <- base::is.null
[15:31:08.584]                       muffled <- FALSE
[15:31:08.584]                       if (inherits(cond, "message")) {
[15:31:08.584]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:08.584]                         if (muffled) 
[15:31:08.584]                           invokeRestart("muffleMessage")
[15:31:08.584]                       }
[15:31:08.584]                       else if (inherits(cond, "warning")) {
[15:31:08.584]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:08.584]                         if (muffled) 
[15:31:08.584]                           invokeRestart("muffleWarning")
[15:31:08.584]                       }
[15:31:08.584]                       else if (inherits(cond, "condition")) {
[15:31:08.584]                         if (!is.null(pattern)) {
[15:31:08.584]                           computeRestarts <- base::computeRestarts
[15:31:08.584]                           grepl <- base::grepl
[15:31:08.584]                           restarts <- computeRestarts(cond)
[15:31:08.584]                           for (restart in restarts) {
[15:31:08.584]                             name <- restart$name
[15:31:08.584]                             if (is.null(name)) 
[15:31:08.584]                               next
[15:31:08.584]                             if (!grepl(pattern, name)) 
[15:31:08.584]                               next
[15:31:08.584]                             invokeRestart(restart)
[15:31:08.584]                             muffled <- TRUE
[15:31:08.584]                             break
[15:31:08.584]                           }
[15:31:08.584]                         }
[15:31:08.584]                       }
[15:31:08.584]                       invisible(muffled)
[15:31:08.584]                     }
[15:31:08.584]                     muffleCondition(cond, pattern = "^muffle")
[15:31:08.584]                   }
[15:31:08.584]                 }
[15:31:08.584]             }
[15:31:08.584]         }))
[15:31:08.584]     }, error = function(ex) {
[15:31:08.584]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:08.584]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:08.584]                 ...future.rng), started = ...future.startTime, 
[15:31:08.584]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:08.584]             version = "1.8"), class = "FutureResult")
[15:31:08.584]     }, finally = {
[15:31:08.584]         if (!identical(...future.workdir, getwd())) 
[15:31:08.584]             setwd(...future.workdir)
[15:31:08.584]         {
[15:31:08.584]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:08.584]                 ...future.oldOptions$nwarnings <- NULL
[15:31:08.584]             }
[15:31:08.584]             base::options(...future.oldOptions)
[15:31:08.584]             if (.Platform$OS.type == "windows") {
[15:31:08.584]                 old_names <- names(...future.oldEnvVars)
[15:31:08.584]                 envs <- base::Sys.getenv()
[15:31:08.584]                 names <- names(envs)
[15:31:08.584]                 common <- intersect(names, old_names)
[15:31:08.584]                 added <- setdiff(names, old_names)
[15:31:08.584]                 removed <- setdiff(old_names, names)
[15:31:08.584]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:08.584]                   envs[common]]
[15:31:08.584]                 NAMES <- toupper(changed)
[15:31:08.584]                 args <- list()
[15:31:08.584]                 for (kk in seq_along(NAMES)) {
[15:31:08.584]                   name <- changed[[kk]]
[15:31:08.584]                   NAME <- NAMES[[kk]]
[15:31:08.584]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:08.584]                     next
[15:31:08.584]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:08.584]                 }
[15:31:08.584]                 NAMES <- toupper(added)
[15:31:08.584]                 for (kk in seq_along(NAMES)) {
[15:31:08.584]                   name <- added[[kk]]
[15:31:08.584]                   NAME <- NAMES[[kk]]
[15:31:08.584]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:08.584]                     next
[15:31:08.584]                   args[[name]] <- ""
[15:31:08.584]                 }
[15:31:08.584]                 NAMES <- toupper(removed)
[15:31:08.584]                 for (kk in seq_along(NAMES)) {
[15:31:08.584]                   name <- removed[[kk]]
[15:31:08.584]                   NAME <- NAMES[[kk]]
[15:31:08.584]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:08.584]                     next
[15:31:08.584]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:08.584]                 }
[15:31:08.584]                 if (length(args) > 0) 
[15:31:08.584]                   base::do.call(base::Sys.setenv, args = args)
[15:31:08.584]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:08.584]             }
[15:31:08.584]             else {
[15:31:08.584]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:08.584]             }
[15:31:08.584]             {
[15:31:08.584]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:08.584]                   0L) {
[15:31:08.584]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:08.584]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:08.584]                   base::options(opts)
[15:31:08.584]                 }
[15:31:08.584]                 {
[15:31:08.584]                   {
[15:31:08.584]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:08.584]                     NULL
[15:31:08.584]                   }
[15:31:08.584]                   options(future.plan = NULL)
[15:31:08.584]                   if (is.na(NA_character_)) 
[15:31:08.584]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:08.584]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:08.584]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:08.584]                     .init = FALSE)
[15:31:08.584]                 }
[15:31:08.584]             }
[15:31:08.584]         }
[15:31:08.584]     })
[15:31:08.584]     if (TRUE) {
[15:31:08.584]         base::sink(type = "output", split = FALSE)
[15:31:08.584]         if (TRUE) {
[15:31:08.584]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:08.584]         }
[15:31:08.584]         else {
[15:31:08.584]             ...future.result["stdout"] <- base::list(NULL)
[15:31:08.584]         }
[15:31:08.584]         base::close(...future.stdout)
[15:31:08.584]         ...future.stdout <- NULL
[15:31:08.584]     }
[15:31:08.584]     ...future.result$conditions <- ...future.conditions
[15:31:08.584]     ...future.result$finished <- base::Sys.time()
[15:31:08.584]     ...future.result
[15:31:08.584] }
[15:31:08.593] Exporting 5 global objects (9.77 KiB) to cluster node #1 ...
[15:31:08.593] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:31:08.594] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:31:08.595] Exporting '...future.FUN' (9.66 KiB) to cluster node #1 ...
[15:31:08.596] Exporting '...future.FUN' (9.66 KiB) to cluster node #1 ... DONE
[15:31:08.596] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[15:31:08.597] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[15:31:08.597] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:31:08.598] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:31:08.599] Exporting '...future.globals.maxSize' (56 bytes) to cluster node #1 ...
[15:31:08.600] Exporting '...future.globals.maxSize' (56 bytes) to cluster node #1 ... DONE
[15:31:08.600] Exporting 5 global objects (9.77 KiB) to cluster node #1 ... DONE
[15:31:08.601] MultisessionFuture started
[15:31:08.602] - Launch lazy future ... done
[15:31:08.602] run() for 'MultisessionFuture' ... done
[15:31:08.603] Created future:
[15:31:08.629] receiveMessageFromWorker() for ClusterFuture ...
[15:31:08.630] - Validating connection of MultisessionFuture
[15:31:08.630] - received message: FutureResult
[15:31:08.630] - Received FutureResult
[15:31:08.631] - Erased future from FutureRegistry
[15:31:08.631] result() for ClusterFuture ...
[15:31:08.631] - result already collected: FutureResult
[15:31:08.632] result() for ClusterFuture ... done
[15:31:08.632] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:08.603] MultisessionFuture:
[15:31:08.603] Label: 'future_apply-2'
[15:31:08.603] Expression:
[15:31:08.603] {
[15:31:08.603]     do.call(function(...) {
[15:31:08.603]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:08.603]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:08.603]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:08.603]             on.exit(options(oopts), add = TRUE)
[15:31:08.603]         }
[15:31:08.603]         {
[15:31:08.603]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:08.603]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:08.603]                 ...future.FUN(...future.X_jj, ...)
[15:31:08.603]             })
[15:31:08.603]         }
[15:31:08.603]     }, args = future.call.arguments)
[15:31:08.603] }
[15:31:08.603] Lazy evaluation: FALSE
[15:31:08.603] Asynchronous evaluation: TRUE
[15:31:08.603] Local evaluation: TRUE
[15:31:08.603] Environment: R_GlobalEnv
[15:31:08.603] Capture standard output: TRUE
[15:31:08.603] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:08.603] Globals: 5 objects totaling 9.77 KiB (DotDotDotList 'future.call.arguments' of 0 bytes, function '...future.FUN' of 9.66 KiB, list '...future.elements_ii' of 56 bytes, NULL '...future.seeds_ii' of 0 bytes, numeric '...future.globals.maxSize' of 56 bytes)
[15:31:08.603] Packages: <none>
[15:31:08.603] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:08.603] Resolved: TRUE
[15:31:08.603] Value: <not collected>
[15:31:08.603] Conditions captured: <none>
[15:31:08.603] Early signaling: FALSE
[15:31:08.603] Owner process: 6672a580-6d3c-e82f-380e-108c475ace70
[15:31:08.603] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:08.633] Chunk #2 of 2 ... DONE
[15:31:08.633] Launching 2 futures (chunks) ... DONE
[15:31:08.633] Resolving 2 futures (chunks) ...
[15:31:08.634] resolve() on list ...
[15:31:08.634]  recursive: 0
[15:31:08.634]  length: 2
[15:31:08.634] 
[15:31:08.635] Future #1
[15:31:08.635] result() for ClusterFuture ...
[15:31:08.635] - result already collected: FutureResult
[15:31:08.636] result() for ClusterFuture ... done
[15:31:08.636] result() for ClusterFuture ...
[15:31:08.636] - result already collected: FutureResult
[15:31:08.636] result() for ClusterFuture ... done
[15:31:08.637] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:31:08.637] - nx: 2
[15:31:08.637] - relay: TRUE
[15:31:08.637] - stdout: TRUE
[15:31:08.638] - signal: TRUE
[15:31:08.638] - resignal: FALSE
[15:31:08.638] - force: TRUE
[15:31:08.638] - relayed: [n=2] FALSE, FALSE
[15:31:08.639] - queued futures: [n=2] FALSE, FALSE
[15:31:08.639]  - until=1
[15:31:08.639]  - relaying element #1
[15:31:08.639] result() for ClusterFuture ...
[15:31:08.640] - result already collected: FutureResult
[15:31:08.640] result() for ClusterFuture ... done
[15:31:08.640] result() for ClusterFuture ...
[15:31:08.641] - result already collected: FutureResult
[15:31:08.646] result() for ClusterFuture ... done
[15:31:08.647] result() for ClusterFuture ...
[15:31:08.647] - result already collected: FutureResult
[15:31:08.647] result() for ClusterFuture ... done
[15:31:08.648] result() for ClusterFuture ...
[15:31:08.648] - result already collected: FutureResult
[15:31:08.649] result() for ClusterFuture ... done
[15:31:08.649] - relayed: [n=2] TRUE, FALSE
[15:31:08.649] - queued futures: [n=2] TRUE, FALSE
[15:31:08.649] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:31:08.650]  length: 1 (resolved future 1)
[15:31:08.650] Future #2
[15:31:08.650] result() for ClusterFuture ...
[15:31:08.651] - result already collected: FutureResult
[15:31:08.651] result() for ClusterFuture ... done
[15:31:08.651] result() for ClusterFuture ...
[15:31:08.651] - result already collected: FutureResult
[15:31:08.652] result() for ClusterFuture ... done
[15:31:08.652] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:31:08.652] - nx: 2
[15:31:08.652] - relay: TRUE
[15:31:08.652] - stdout: TRUE
[15:31:08.653] - signal: TRUE
[15:31:08.653] - resignal: FALSE
[15:31:08.653] - force: TRUE
[15:31:08.653] - relayed: [n=2] TRUE, FALSE
[15:31:08.654] - queued futures: [n=2] TRUE, FALSE
[15:31:08.654]  - until=2
[15:31:08.654]  - relaying element #2
[15:31:08.655] result() for ClusterFuture ...
[15:31:08.655] - result already collected: FutureResult
[15:31:08.655] result() for ClusterFuture ... done
[15:31:08.656] result() for ClusterFuture ...
[15:31:08.656] - result already collected: FutureResult
[15:31:08.656] result() for ClusterFuture ... done
[15:31:08.657] result() for ClusterFuture ...
[15:31:08.657] - result already collected: FutureResult
[15:31:08.657] result() for ClusterFuture ... done
[15:31:08.658] result() for ClusterFuture ...
[15:31:08.658] - result already collected: FutureResult
[15:31:08.658] result() for ClusterFuture ... done
[15:31:08.658] - relayed: [n=2] TRUE, TRUE
[15:31:08.659] - queued futures: [n=2] TRUE, TRUE
[15:31:08.659] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:31:08.659]  length: 0 (resolved future 2)
[15:31:08.660] Relaying remaining futures
[15:31:08.660] signalConditionsASAP(NULL, pos=0) ...
[15:31:08.660] - nx: 2
[15:31:08.661] - relay: TRUE
[15:31:08.661] - stdout: TRUE
[15:31:08.661] - signal: TRUE
[15:31:08.661] - resignal: FALSE
[15:31:08.662] - force: TRUE
[15:31:08.662] - relayed: [n=2] TRUE, TRUE
[15:31:08.662] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:31:08.663] - relayed: [n=2] TRUE, TRUE
[15:31:08.663] - queued futures: [n=2] TRUE, TRUE
[15:31:08.663] signalConditionsASAP(NULL, pos=0) ... done
[15:31:08.664] resolve() on list ... DONE
[15:31:08.664] result() for ClusterFuture ...
[15:31:08.664] - result already collected: FutureResult
[15:31:08.664] result() for ClusterFuture ... done
[15:31:08.665] result() for ClusterFuture ...
[15:31:08.665] - result already collected: FutureResult
[15:31:08.665] result() for ClusterFuture ... done
[15:31:08.666] result() for ClusterFuture ...
[15:31:08.666] - result already collected: FutureResult
[15:31:08.666] result() for ClusterFuture ... done
[15:31:08.666] result() for ClusterFuture ...
[15:31:08.667] - result already collected: FutureResult
[15:31:08.667] result() for ClusterFuture ... done
[15:31:08.667]  - Number of value chunks collected: 2
[15:31:08.668] Resolving 2 futures (chunks) ... DONE
[15:31:08.668] Reducing values from 2 chunks ...
[15:31:08.668]  - Number of values collected after concatenation: 2
[15:31:08.669]  - Number of values expected: 2
[15:31:08.669] Reducing values from 2 chunks ... DONE
[15:31:08.669] future_lapply() ... DONE
     [,1] [,2]
[1,]    1    2
[2,]    3    4
- example(future_apply) - reproducible RNG ...
[15:31:08.670] getGlobalsAndPackagesXApply() ...
[15:31:08.670]  - future.globals: TRUE
[15:31:08.671] getGlobalsAndPackages() ...
[15:31:08.671] Searching for globals...
[15:31:08.678] - globals found: [13] 'FUN', '{', 'if', '&&', '==', 'length', 'is.numeric', 'is.finite', '>=', 'missing', '<-', 'sample.int', '['
[15:31:08.678] Searching for globals ... DONE
[15:31:08.678] Resolving globals: FALSE
[15:31:08.679] The total size of the 1 globals is 35.45 KiB (36296 bytes)
[15:31:08.680] The total size of the 1 globals exported for future expression ('FUN(X = structure(1:4, dim = c(2L, 2L)))') is 35.45 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (35.45 KiB of class 'function')
[15:31:08.680] - globals: [1] 'FUN'
[15:31:08.680] 
[15:31:08.680] getGlobalsAndPackages() ... DONE
[15:31:08.680]  - globals found/used: [n=1] 'FUN'
[15:31:08.681]  - needed namespaces: [n=0] 
[15:31:08.681] Finding globals ... DONE
[15:31:08.681]  - use_args: TRUE
[15:31:08.681]  - Getting '...' globals ...
[15:31:08.682] resolve() on list ...
[15:31:08.682]  recursive: 0
[15:31:08.682]  length: 1
[15:31:08.682]  elements: '...'
[15:31:08.682]  length: 0 (resolved future 1)
[15:31:08.683] resolve() on list ... DONE
[15:31:08.683]    - '...' content: [n=0] 
[15:31:08.683] List of 1
[15:31:08.683]  $ ...: list()
[15:31:08.683]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:08.683]  - attr(*, "where")=List of 1
[15:31:08.683]   ..$ ...:<environment: 0x000001bcbb54fa78> 
[15:31:08.683]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:08.683]  - attr(*, "resolved")= logi TRUE
[15:31:08.683]  - attr(*, "total_size")= num NA
[15:31:08.687]  - Getting '...' globals ... DONE
[15:31:08.687] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:08.688] List of 2
[15:31:08.688]  $ ...future.FUN:function (x, size, replace = FALSE, prob = NULL)  
[15:31:08.688]  $ ...          : list()
[15:31:08.688]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:08.688]  - attr(*, "where")=List of 2
[15:31:08.688]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:08.688]   ..$ ...          :<environment: 0x000001bcbb54fa78> 
[15:31:08.688]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:08.688]  - attr(*, "resolved")= logi FALSE
[15:31:08.688]  - attr(*, "total_size")= num 36296
[15:31:08.692] Packages to be attached in all futures: [n=0] 
[15:31:08.692] getGlobalsAndPackagesXApply() ... DONE
[15:31:08.695] future_lapply() ...
[15:31:08.698] Generating random seeds ...
[15:31:08.698] Generating random seed streams for 2 elements ...
[15:31:08.699] Generating random seed streams for 2 elements ... DONE
[15:31:08.699] Generating random seeds ... DONE
[15:31:08.699] Will set RNG state on exit: 10407, 1505531436, -1714211644, -2107924524, 1386288591, -1096266685, 1028710482
[15:31:08.702] Number of chunks: 2
[15:31:08.702] getGlobalsAndPackagesXApply() ...
[15:31:08.702]  - future.globals: <name-value list> with names 'list()'
[15:31:08.703]  - use_args: TRUE
[15:31:08.703] Globals to be used in all futures (chunks): [n=2] '...', '...future.FUN'
[15:31:08.703] List of 2
[15:31:08.703]  $ ...          : list()
[15:31:08.703]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:08.703]  $ ...future.FUN:function (x, size, replace = FALSE, prob = NULL)  
[15:31:08.703]  - attr(*, "where")=List of 2
[15:31:08.703]   ..$ ...          :<environment: 0x000001bcbb54fa78> 
[15:31:08.703]   ..$ ...future.FUN:<environment: namespace:base> 
[15:31:08.703]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:08.703]  - attr(*, "resolved")= logi FALSE
[15:31:08.703]  - attr(*, "total_size")= num NA
[15:31:08.711] Packages to be attached in all futures: [n=0] 
[15:31:08.712] getGlobalsAndPackagesXApply() ... DONE
[15:31:08.712] Number of futures (= number of chunks): 2
[15:31:08.713] Launching 2 futures (chunks) ...
[15:31:08.713] Chunk #1 of 2 ...
[15:31:08.714]  - Adjusted option 'future.globals.maxSize': Inf -> 2 * Inf = Inf (bytes)
[15:31:08.714]  - seeds: [1] <seeds>
[15:31:08.714]  - All globals exported: [n=5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:08.715] getGlobalsAndPackages() ...
[15:31:08.715] - globals passed as-is: [5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:08.716] Resolving globals: FALSE
[15:31:08.716] Tweak future expression to call with '...' arguments ...
[15:31:08.716] {
[15:31:08.716]     do.call(function(...) {
[15:31:08.716]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:08.716]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:08.716]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:08.716]             on.exit(options(oopts), add = TRUE)
[15:31:08.716]         }
[15:31:08.716]         {
[15:31:08.716]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:08.716]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:08.716]                 assign(".Random.seed", ...future.seeds_ii[[jj]], 
[15:31:08.716]                   envir = globalenv(), inherits = FALSE)
[15:31:08.716]                 ...future.FUN(...future.X_jj, ...)
[15:31:08.716]             })
[15:31:08.716]         }
[15:31:08.716]     }, args = future.call.arguments)
[15:31:08.716] }
[15:31:08.718] Tweak future expression to call with '...' arguments ... DONE
[15:31:08.719] - globals: [5] 'future.call.arguments', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:08.719] 
[15:31:08.720] getGlobalsAndPackages() ... DONE
[15:31:08.720] run() for 'Future' ...
[15:31:08.721] - state: 'created'
[15:31:08.721] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:08.745] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:08.746] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:31:08.746]   - Field: 'node'
[15:31:08.746]   - Field: 'label'
[15:31:08.747]   - Field: 'local'
[15:31:08.747]   - Field: 'owner'
[15:31:08.748]   - Field: 'envir'
[15:31:08.748]   - Field: 'workers'
[15:31:08.748]   - Field: 'packages'
[15:31:08.749]   - Field: 'gc'
[15:31:08.749]   - Field: 'conditions'
[15:31:08.750]   - Field: 'persistent'
[15:31:08.750]   - Field: 'expr'
[15:31:08.750]   - Field: 'uuid'
[15:31:08.751]   - Field: 'seed'
[15:31:08.751]   - Field: 'version'
[15:31:08.751]   - Field: 'result'
[15:31:08.752]   - Field: 'asynchronous'
[15:31:08.752]   - Field: 'calls'
[15:31:08.752]   - Field: 'globals'
[15:31:08.753]   - Field: 'stdout'
[15:31:08.753]   - Field: 'earlySignal'
[15:31:08.753]   - Field: 'lazy'
[15:31:08.754]   - Field: 'state'
[15:31:08.754] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:31:08.755] - Launch lazy future ...
[15:31:08.755] Packages needed by the future expression (n = 0): <none>
[15:31:08.756] Packages needed by future strategies (n = 0): <none>
[15:31:08.757] {
[15:31:08.757]     {
[15:31:08.757]         {
[15:31:08.757]             ...future.startTime <- base::Sys.time()
[15:31:08.757]             {
[15:31:08.757]                 {
[15:31:08.757]                   {
[15:31:08.757]                     {
[15:31:08.757]                       base::local({
[15:31:08.757]                         has_future <- base::requireNamespace("future", 
[15:31:08.757]                           quietly = TRUE)
[15:31:08.757]                         if (has_future) {
[15:31:08.757]                           ns <- base::getNamespace("future")
[15:31:08.757]                           version <- ns[[".package"]][["version"]]
[15:31:08.757]                           if (is.null(version)) 
[15:31:08.757]                             version <- utils::packageVersion("future")
[15:31:08.757]                         }
[15:31:08.757]                         else {
[15:31:08.757]                           version <- NULL
[15:31:08.757]                         }
[15:31:08.757]                         if (!has_future || version < "1.8.0") {
[15:31:08.757]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:08.757]                             "", base::R.version$version.string), 
[15:31:08.757]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:08.757]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:08.757]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:08.757]                               "release", "version")], collapse = " "), 
[15:31:08.757]                             hostname = base::Sys.info()[["nodename"]])
[15:31:08.757]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:08.757]                             info)
[15:31:08.757]                           info <- base::paste(info, collapse = "; ")
[15:31:08.757]                           if (!has_future) {
[15:31:08.757]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:08.757]                               info)
[15:31:08.757]                           }
[15:31:08.757]                           else {
[15:31:08.757]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:08.757]                               info, version)
[15:31:08.757]                           }
[15:31:08.757]                           base::stop(msg)
[15:31:08.757]                         }
[15:31:08.757]                       })
[15:31:08.757]                     }
[15:31:08.757]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:08.757]                     base::options(mc.cores = 1L)
[15:31:08.757]                   }
[15:31:08.757]                   ...future.strategy.old <- future::plan("list")
[15:31:08.757]                   options(future.plan = NULL)
[15:31:08.757]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:08.757]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:08.757]                 }
[15:31:08.757]                 ...future.workdir <- getwd()
[15:31:08.757]             }
[15:31:08.757]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:08.757]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:08.757]         }
[15:31:08.757]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:08.757]             future.globals.maxSize = Inf, future.globals.method = NULL, 
[15:31:08.757]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:08.757]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:08.757]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:08.757]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:08.757]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:08.757]             base::names(...future.oldOptions))
[15:31:08.757]     }
[15:31:08.757]     if (FALSE) {
[15:31:08.757]     }
[15:31:08.757]     else {
[15:31:08.757]         if (TRUE) {
[15:31:08.757]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:08.757]                 open = "w")
[15:31:08.757]         }
[15:31:08.757]         else {
[15:31:08.757]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:08.757]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:08.757]         }
[15:31:08.757]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:08.757]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:08.757]             base::sink(type = "output", split = FALSE)
[15:31:08.757]             base::close(...future.stdout)
[15:31:08.757]         }, add = TRUE)
[15:31:08.757]     }
[15:31:08.757]     ...future.frame <- base::sys.nframe()
[15:31:08.757]     ...future.conditions <- base::list()
[15:31:08.757]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:08.757]     if (FALSE) {
[15:31:08.757]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:08.757]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:08.757]     }
[15:31:08.757]     ...future.result <- base::tryCatch({
[15:31:08.757]         base::withCallingHandlers({
[15:31:08.757]             ...future.value <- base::withVisible(base::local({
[15:31:08.757]                 ...future.makeSendCondition <- base::local({
[15:31:08.757]                   sendCondition <- NULL
[15:31:08.757]                   function(frame = 1L) {
[15:31:08.757]                     if (is.function(sendCondition)) 
[15:31:08.757]                       return(sendCondition)
[15:31:08.757]                     ns <- getNamespace("parallel")
[15:31:08.757]                     if (exists("sendData", mode = "function", 
[15:31:08.757]                       envir = ns)) {
[15:31:08.757]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:08.757]                         envir = ns)
[15:31:08.757]                       envir <- sys.frame(frame)
[15:31:08.757]                       master <- NULL
[15:31:08.757]                       while (!identical(envir, .GlobalEnv) && 
[15:31:08.757]                         !identical(envir, emptyenv())) {
[15:31:08.757]                         if (exists("master", mode = "list", envir = envir, 
[15:31:08.757]                           inherits = FALSE)) {
[15:31:08.757]                           master <- get("master", mode = "list", 
[15:31:08.757]                             envir = envir, inherits = FALSE)
[15:31:08.757]                           if (inherits(master, c("SOCKnode", 
[15:31:08.757]                             "SOCK0node"))) {
[15:31:08.757]                             sendCondition <<- function(cond) {
[15:31:08.757]                               data <- list(type = "VALUE", value = cond, 
[15:31:08.757]                                 success = TRUE)
[15:31:08.757]                               parallel_sendData(master, data)
[15:31:08.757]                             }
[15:31:08.757]                             return(sendCondition)
[15:31:08.757]                           }
[15:31:08.757]                         }
[15:31:08.757]                         frame <- frame + 1L
[15:31:08.757]                         envir <- sys.frame(frame)
[15:31:08.757]                       }
[15:31:08.757]                     }
[15:31:08.757]                     sendCondition <<- function(cond) NULL
[15:31:08.757]                   }
[15:31:08.757]                 })
[15:31:08.757]                 withCallingHandlers({
[15:31:08.757]                   {
[15:31:08.757]                     do.call(function(...) {
[15:31:08.757]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:08.757]                       if (!identical(...future.globals.maxSize.org, 
[15:31:08.757]                         ...future.globals.maxSize)) {
[15:31:08.757]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:08.757]                         on.exit(options(oopts), add = TRUE)
[15:31:08.757]                       }
[15:31:08.757]                       {
[15:31:08.757]                         lapply(seq_along(...future.elements_ii), 
[15:31:08.757]                           FUN = function(jj) {
[15:31:08.757]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:08.757]                             assign(".Random.seed", ...future.seeds_ii[[jj]], 
[15:31:08.757]                               envir = globalenv(), inherits = FALSE)
[15:31:08.757]                             ...future.FUN(...future.X_jj, ...)
[15:31:08.757]                           })
[15:31:08.757]                       }
[15:31:08.757]                     }, args = future.call.arguments)
[15:31:08.757]                   }
[15:31:08.757]                 }, immediateCondition = function(cond) {
[15:31:08.757]                   sendCondition <- ...future.makeSendCondition()
[15:31:08.757]                   sendCondition(cond)
[15:31:08.757]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:08.757]                   {
[15:31:08.757]                     inherits <- base::inherits
[15:31:08.757]                     invokeRestart <- base::invokeRestart
[15:31:08.757]                     is.null <- base::is.null
[15:31:08.757]                     muffled <- FALSE
[15:31:08.757]                     if (inherits(cond, "message")) {
[15:31:08.757]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:08.757]                       if (muffled) 
[15:31:08.757]                         invokeRestart("muffleMessage")
[15:31:08.757]                     }
[15:31:08.757]                     else if (inherits(cond, "warning")) {
[15:31:08.757]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:08.757]                       if (muffled) 
[15:31:08.757]                         invokeRestart("muffleWarning")
[15:31:08.757]                     }
[15:31:08.757]                     else if (inherits(cond, "condition")) {
[15:31:08.757]                       if (!is.null(pattern)) {
[15:31:08.757]                         computeRestarts <- base::computeRestarts
[15:31:08.757]                         grepl <- base::grepl
[15:31:08.757]                         restarts <- computeRestarts(cond)
[15:31:08.757]                         for (restart in restarts) {
[15:31:08.757]                           name <- restart$name
[15:31:08.757]                           if (is.null(name)) 
[15:31:08.757]                             next
[15:31:08.757]                           if (!grepl(pattern, name)) 
[15:31:08.757]                             next
[15:31:08.757]                           invokeRestart(restart)
[15:31:08.757]                           muffled <- TRUE
[15:31:08.757]                           break
[15:31:08.757]                         }
[15:31:08.757]                       }
[15:31:08.757]                     }
[15:31:08.757]                     invisible(muffled)
[15:31:08.757]                   }
[15:31:08.757]                   muffleCondition(cond)
[15:31:08.757]                 })
[15:31:08.757]             }))
[15:31:08.757]             future::FutureResult(value = ...future.value$value, 
[15:31:08.757]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:08.757]                   ...future.rng), globalenv = if (FALSE) 
[15:31:08.757]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:08.757]                     ...future.globalenv.names))
[15:31:08.757]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:08.757]         }, condition = base::local({
[15:31:08.757]             c <- base::c
[15:31:08.757]             inherits <- base::inherits
[15:31:08.757]             invokeRestart <- base::invokeRestart
[15:31:08.757]             length <- base::length
[15:31:08.757]             list <- base::list
[15:31:08.757]             seq.int <- base::seq.int
[15:31:08.757]             signalCondition <- base::signalCondition
[15:31:08.757]             sys.calls <- base::sys.calls
[15:31:08.757]             `[[` <- base::`[[`
[15:31:08.757]             `+` <- base::`+`
[15:31:08.757]             `<<-` <- base::`<<-`
[15:31:08.757]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:08.757]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:08.757]                   3L)]
[15:31:08.757]             }
[15:31:08.757]             function(cond) {
[15:31:08.757]                 is_error <- inherits(cond, "error")
[15:31:08.757]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:08.757]                   NULL)
[15:31:08.757]                 if (is_error) {
[15:31:08.757]                   sessionInformation <- function() {
[15:31:08.757]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:08.757]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:08.757]                       search = base::search(), system = base::Sys.info())
[15:31:08.757]                   }
[15:31:08.757]                   ...future.conditions[[length(...future.conditions) + 
[15:31:08.757]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:08.757]                     cond$call), session = sessionInformation(), 
[15:31:08.757]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:08.757]                   signalCondition(cond)
[15:31:08.757]                 }
[15:31:08.757]                 else if (!ignore && TRUE && inherits(cond, "immediateCondition")) {
[15:31:08.757]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:08.757]                   ...future.conditions[[length(...future.conditions) + 
[15:31:08.757]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:08.757]                   if (TRUE && !signal) {
[15:31:08.757]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:08.757]                     {
[15:31:08.757]                       inherits <- base::inherits
[15:31:08.757]                       invokeRestart <- base::invokeRestart
[15:31:08.757]                       is.null <- base::is.null
[15:31:08.757]                       muffled <- FALSE
[15:31:08.757]                       if (inherits(cond, "message")) {
[15:31:08.757]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:08.757]                         if (muffled) 
[15:31:08.757]                           invokeRestart("muffleMessage")
[15:31:08.757]                       }
[15:31:08.757]                       else if (inherits(cond, "warning")) {
[15:31:08.757]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:08.757]                         if (muffled) 
[15:31:08.757]                           invokeRestart("muffleWarning")
[15:31:08.757]                       }
[15:31:08.757]                       else if (inherits(cond, "condition")) {
[15:31:08.757]                         if (!is.null(pattern)) {
[15:31:08.757]                           computeRestarts <- base::computeRestarts
[15:31:08.757]                           grepl <- base::grepl
[15:31:08.757]                           restarts <- computeRestarts(cond)
[15:31:08.757]                           for (restart in restarts) {
[15:31:08.757]                             name <- restart$name
[15:31:08.757]                             if (is.null(name)) 
[15:31:08.757]                               next
[15:31:08.757]                             if (!grepl(pattern, name)) 
[15:31:08.757]                               next
[15:31:08.757]                             invokeRestart(restart)
[15:31:08.757]                             muffled <- TRUE
[15:31:08.757]                             break
[15:31:08.757]                           }
[15:31:08.757]                         }
[15:31:08.757]                       }
[15:31:08.757]                       invisible(muffled)
[15:31:08.757]                     }
[15:31:08.757]                     muffleCondition(cond, pattern = "^muffle")
[15:31:08.757]                   }
[15:31:08.757]                 }
[15:31:08.757]                 else {
[15:31:08.757]                   if (TRUE) {
[15:31:08.757]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:08.757]                     {
[15:31:08.757]                       inherits <- base::inherits
[15:31:08.757]                       invokeRestart <- base::invokeRestart
[15:31:08.757]                       is.null <- base::is.null
[15:31:08.757]                       muffled <- FALSE
[15:31:08.757]                       if (inherits(cond, "message")) {
[15:31:08.757]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:08.757]                         if (muffled) 
[15:31:08.757]                           invokeRestart("muffleMessage")
[15:31:08.757]                       }
[15:31:08.757]                       else if (inherits(cond, "warning")) {
[15:31:08.757]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:08.757]                         if (muffled) 
[15:31:08.757]                           invokeRestart("muffleWarning")
[15:31:08.757]                       }
[15:31:08.757]                       else if (inherits(cond, "condition")) {
[15:31:08.757]                         if (!is.null(pattern)) {
[15:31:08.757]                           computeRestarts <- base::computeRestarts
[15:31:08.757]                           grepl <- base::grepl
[15:31:08.757]                           restarts <- computeRestarts(cond)
[15:31:08.757]                           for (restart in restarts) {
[15:31:08.757]                             name <- restart$name
[15:31:08.757]                             if (is.null(name)) 
[15:31:08.757]                               next
[15:31:08.757]                             if (!grepl(pattern, name)) 
[15:31:08.757]                               next
[15:31:08.757]                             invokeRestart(restart)
[15:31:08.757]                             muffled <- TRUE
[15:31:08.757]                             break
[15:31:08.757]                           }
[15:31:08.757]                         }
[15:31:08.757]                       }
[15:31:08.757]                       invisible(muffled)
[15:31:08.757]                     }
[15:31:08.757]                     muffleCondition(cond, pattern = "^muffle")
[15:31:08.757]                   }
[15:31:08.757]                 }
[15:31:08.757]             }
[15:31:08.757]         }))
[15:31:08.757]     }, error = function(ex) {
[15:31:08.757]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:08.757]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:08.757]                 ...future.rng), started = ...future.startTime, 
[15:31:08.757]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:08.757]             version = "1.8"), class = "FutureResult")
[15:31:08.757]     }, finally = {
[15:31:08.757]         if (!identical(...future.workdir, getwd())) 
[15:31:08.757]             setwd(...future.workdir)
[15:31:08.757]         {
[15:31:08.757]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:08.757]                 ...future.oldOptions$nwarnings <- NULL
[15:31:08.757]             }
[15:31:08.757]             base::options(...future.oldOptions)
[15:31:08.757]             if (.Platform$OS.type == "windows") {
[15:31:08.757]                 old_names <- names(...future.oldEnvVars)
[15:31:08.757]                 envs <- base::Sys.getenv()
[15:31:08.757]                 names <- names(envs)
[15:31:08.757]                 common <- intersect(names, old_names)
[15:31:08.757]                 added <- setdiff(names, old_names)
[15:31:08.757]                 removed <- setdiff(old_names, names)
[15:31:08.757]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:08.757]                   envs[common]]
[15:31:08.757]                 NAMES <- toupper(changed)
[15:31:08.757]                 args <- list()
[15:31:08.757]                 for (kk in seq_along(NAMES)) {
[15:31:08.757]                   name <- changed[[kk]]
[15:31:08.757]                   NAME <- NAMES[[kk]]
[15:31:08.757]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:08.757]                     next
[15:31:08.757]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:08.757]                 }
[15:31:08.757]                 NAMES <- toupper(added)
[15:31:08.757]                 for (kk in seq_along(NAMES)) {
[15:31:08.757]                   name <- added[[kk]]
[15:31:08.757]                   NAME <- NAMES[[kk]]
[15:31:08.757]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:08.757]                     next
[15:31:08.757]                   args[[name]] <- ""
[15:31:08.757]                 }
[15:31:08.757]                 NAMES <- toupper(removed)
[15:31:08.757]                 for (kk in seq_along(NAMES)) {
[15:31:08.757]                   name <- removed[[kk]]
[15:31:08.757]                   NAME <- NAMES[[kk]]
[15:31:08.757]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:08.757]                     next
[15:31:08.757]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:08.757]                 }
[15:31:08.757]                 if (length(args) > 0) 
[15:31:08.757]                   base::do.call(base::Sys.setenv, args = args)
[15:31:08.757]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:08.757]             }
[15:31:08.757]             else {
[15:31:08.757]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:08.757]             }
[15:31:08.757]             {
[15:31:08.757]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:08.757]                   0L) {
[15:31:08.757]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:08.757]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:08.757]                   base::options(opts)
[15:31:08.757]                 }
[15:31:08.757]                 {
[15:31:08.757]                   {
[15:31:08.757]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:08.757]                     NULL
[15:31:08.757]                   }
[15:31:08.757]                   options(future.plan = NULL)
[15:31:08.757]                   if (is.na(NA_character_)) 
[15:31:08.757]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:08.757]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:08.757]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:08.757]                     .init = FALSE)
[15:31:08.757]                 }
[15:31:08.757]             }
[15:31:08.757]         }
[15:31:08.757]     })
[15:31:08.757]     if (TRUE) {
[15:31:08.757]         base::sink(type = "output", split = FALSE)
[15:31:08.757]         if (TRUE) {
[15:31:08.757]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:08.757]         }
[15:31:08.757]         else {
[15:31:08.757]             ...future.result["stdout"] <- base::list(NULL)
[15:31:08.757]         }
[15:31:08.757]         base::close(...future.stdout)
[15:31:08.757]         ...future.stdout <- NULL
[15:31:08.757]     }
[15:31:08.757]     ...future.result$conditions <- ...future.conditions
[15:31:08.757]     ...future.result$finished <- base::Sys.time()
[15:31:08.757]     ...future.result
[15:31:08.757] }
[15:31:08.767] Exporting 5 global objects (35.63 KiB) to cluster node #1 ...
[15:31:08.768] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:31:08.769] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:31:08.769] Exporting '...future.FUN' (35.45 KiB) to cluster node #1 ...
[15:31:08.770] Exporting '...future.FUN' (35.45 KiB) to cluster node #1 ... DONE
[15:31:08.770] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[15:31:08.771] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[15:31:08.771] Exporting '...future.seeds_ii' (80 bytes) to cluster node #1 ...
[15:31:08.772] Exporting '...future.seeds_ii' (80 bytes) to cluster node #1 ... DONE
[15:31:08.772] Exporting '...future.globals.maxSize' (56 bytes) to cluster node #1 ...
[15:31:08.773] Exporting '...future.globals.maxSize' (56 bytes) to cluster node #1 ... DONE
[15:31:08.773] Exporting 5 global objects (35.63 KiB) to cluster node #1 ... DONE
[15:31:08.774] MultisessionFuture started
[15:31:08.774] - Launch lazy future ... done
[15:31:08.775] run() for 'MultisessionFuture' ... done
[15:31:08.775] Created future:
[15:31:08.800] receiveMessageFromWorker() for ClusterFuture ...
[15:31:08.801] - Validating connection of MultisessionFuture
[15:31:08.801] - received message: FutureResult
[15:31:08.802] - Received FutureResult
[15:31:08.802] - Erased future from FutureRegistry
[15:31:08.802] result() for ClusterFuture ...
[15:31:08.802] - result already collected: FutureResult
[15:31:08.803] result() for ClusterFuture ... done
[15:31:08.803] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:08.775] MultisessionFuture:
[15:31:08.775] Label: 'future_apply-1'
[15:31:08.775] Expression:
[15:31:08.775] {
[15:31:08.775]     do.call(function(...) {
[15:31:08.775]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:08.775]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:08.775]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:08.775]             on.exit(options(oopts), add = TRUE)
[15:31:08.775]         }
[15:31:08.775]         {
[15:31:08.775]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:08.775]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:08.775]                 assign(".Random.seed", ...future.seeds_ii[[jj]], 
[15:31:08.775]                   envir = globalenv(), inherits = FALSE)
[15:31:08.775]                 ...future.FUN(...future.X_jj, ...)
[15:31:08.775]             })
[15:31:08.775]         }
[15:31:08.775]     }, args = future.call.arguments)
[15:31:08.775] }
[15:31:08.775] Lazy evaluation: FALSE
[15:31:08.775] Asynchronous evaluation: TRUE
[15:31:08.775] Local evaluation: TRUE
[15:31:08.775] Environment: R_GlobalEnv
[15:31:08.775] Capture standard output: TRUE
[15:31:08.775] Capture condition classes: <none>
[15:31:08.775] Globals: 5 objects totaling 35.63 KiB (DotDotDotList 'future.call.arguments' of 0 bytes, function '...future.FUN' of 35.45 KiB, list '...future.elements_ii' of 56 bytes, list '...future.seeds_ii' of 80 bytes, numeric '...future.globals.maxSize' of 56 bytes)
[15:31:08.775] Packages: <none>
[15:31:08.775] L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[15:31:08.775] Resolved: TRUE
[15:31:08.775] Value: <not collected>
[15:31:08.775] Conditions captured: <none>
[15:31:08.775] Early signaling: FALSE
[15:31:08.775] Owner process: 6672a580-6d3c-e82f-380e-108c475ace70
[15:31:08.775] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:08.803] Chunk #1 of 2 ... DONE
[15:31:08.804] Chunk #2 of 2 ...
[15:31:08.804]  - Adjusted option 'future.globals.maxSize': Inf -> 2 * Inf = Inf (bytes)
[15:31:08.804]  - seeds: [1] <seeds>
[15:31:08.805]  - All globals exported: [n=5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:08.805] getGlobalsAndPackages() ...
[15:31:08.805] - globals passed as-is: [5] '...', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:08.805] Resolving globals: FALSE
[15:31:08.806] Tweak future expression to call with '...' arguments ...
[15:31:08.806] {
[15:31:08.806]     do.call(function(...) {
[15:31:08.806]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:08.806]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:08.806]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:08.806]             on.exit(options(oopts), add = TRUE)
[15:31:08.806]         }
[15:31:08.806]         {
[15:31:08.806]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:08.806]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:08.806]                 assign(".Random.seed", ...future.seeds_ii[[jj]], 
[15:31:08.806]                   envir = globalenv(), inherits = FALSE)
[15:31:08.806]                 ...future.FUN(...future.X_jj, ...)
[15:31:08.806]             })
[15:31:08.806]         }
[15:31:08.806]     }, args = future.call.arguments)
[15:31:08.806] }
[15:31:08.807] Tweak future expression to call with '...' arguments ... DONE
[15:31:08.807] - globals: [5] 'future.call.arguments', '...future.FUN', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:08.808] 
[15:31:08.808] getGlobalsAndPackages() ... DONE
[15:31:08.809] run() for 'Future' ...
[15:31:08.809] - state: 'created'
[15:31:08.809] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:08.826] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:08.826] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:31:08.826]   - Field: 'node'
[15:31:08.826]   - Field: 'label'
[15:31:08.827]   - Field: 'local'
[15:31:08.827]   - Field: 'owner'
[15:31:08.827]   - Field: 'envir'
[15:31:08.828]   - Field: 'workers'
[15:31:08.828]   - Field: 'packages'
[15:31:08.828]   - Field: 'gc'
[15:31:08.828]   - Field: 'conditions'
[15:31:08.829]   - Field: 'persistent'
[15:31:08.829]   - Field: 'expr'
[15:31:08.829]   - Field: 'uuid'
[15:31:08.829]   - Field: 'seed'
[15:31:08.830]   - Field: 'version'
[15:31:08.830]   - Field: 'result'
[15:31:08.830]   - Field: 'asynchronous'
[15:31:08.830]   - Field: 'calls'
[15:31:08.831]   - Field: 'globals'
[15:31:08.831]   - Field: 'stdout'
[15:31:08.831]   - Field: 'earlySignal'
[15:31:08.831]   - Field: 'lazy'
[15:31:08.832]   - Field: 'state'
[15:31:08.832] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:31:08.832] - Launch lazy future ...
[15:31:08.833] Packages needed by the future expression (n = 0): <none>
[15:31:08.833] Packages needed by future strategies (n = 0): <none>
[15:31:08.834] {
[15:31:08.834]     {
[15:31:08.834]         {
[15:31:08.834]             ...future.startTime <- base::Sys.time()
[15:31:08.834]             {
[15:31:08.834]                 {
[15:31:08.834]                   {
[15:31:08.834]                     {
[15:31:08.834]                       base::local({
[15:31:08.834]                         has_future <- base::requireNamespace("future", 
[15:31:08.834]                           quietly = TRUE)
[15:31:08.834]                         if (has_future) {
[15:31:08.834]                           ns <- base::getNamespace("future")
[15:31:08.834]                           version <- ns[[".package"]][["version"]]
[15:31:08.834]                           if (is.null(version)) 
[15:31:08.834]                             version <- utils::packageVersion("future")
[15:31:08.834]                         }
[15:31:08.834]                         else {
[15:31:08.834]                           version <- NULL
[15:31:08.834]                         }
[15:31:08.834]                         if (!has_future || version < "1.8.0") {
[15:31:08.834]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:08.834]                             "", base::R.version$version.string), 
[15:31:08.834]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:08.834]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:08.834]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:08.834]                               "release", "version")], collapse = " "), 
[15:31:08.834]                             hostname = base::Sys.info()[["nodename"]])
[15:31:08.834]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:08.834]                             info)
[15:31:08.834]                           info <- base::paste(info, collapse = "; ")
[15:31:08.834]                           if (!has_future) {
[15:31:08.834]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:08.834]                               info)
[15:31:08.834]                           }
[15:31:08.834]                           else {
[15:31:08.834]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:08.834]                               info, version)
[15:31:08.834]                           }
[15:31:08.834]                           base::stop(msg)
[15:31:08.834]                         }
[15:31:08.834]                       })
[15:31:08.834]                     }
[15:31:08.834]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:08.834]                     base::options(mc.cores = 1L)
[15:31:08.834]                   }
[15:31:08.834]                   ...future.strategy.old <- future::plan("list")
[15:31:08.834]                   options(future.plan = NULL)
[15:31:08.834]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:08.834]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:08.834]                 }
[15:31:08.834]                 ...future.workdir <- getwd()
[15:31:08.834]             }
[15:31:08.834]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:08.834]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:08.834]         }
[15:31:08.834]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:08.834]             future.globals.maxSize = Inf, future.globals.method = NULL, 
[15:31:08.834]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:08.834]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:08.834]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:08.834]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:08.834]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:08.834]             base::names(...future.oldOptions))
[15:31:08.834]     }
[15:31:08.834]     if (FALSE) {
[15:31:08.834]     }
[15:31:08.834]     else {
[15:31:08.834]         if (TRUE) {
[15:31:08.834]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:08.834]                 open = "w")
[15:31:08.834]         }
[15:31:08.834]         else {
[15:31:08.834]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:08.834]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:08.834]         }
[15:31:08.834]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:08.834]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:08.834]             base::sink(type = "output", split = FALSE)
[15:31:08.834]             base::close(...future.stdout)
[15:31:08.834]         }, add = TRUE)
[15:31:08.834]     }
[15:31:08.834]     ...future.frame <- base::sys.nframe()
[15:31:08.834]     ...future.conditions <- base::list()
[15:31:08.834]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:08.834]     if (FALSE) {
[15:31:08.834]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:08.834]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:08.834]     }
[15:31:08.834]     ...future.result <- base::tryCatch({
[15:31:08.834]         base::withCallingHandlers({
[15:31:08.834]             ...future.value <- base::withVisible(base::local({
[15:31:08.834]                 ...future.makeSendCondition <- base::local({
[15:31:08.834]                   sendCondition <- NULL
[15:31:08.834]                   function(frame = 1L) {
[15:31:08.834]                     if (is.function(sendCondition)) 
[15:31:08.834]                       return(sendCondition)
[15:31:08.834]                     ns <- getNamespace("parallel")
[15:31:08.834]                     if (exists("sendData", mode = "function", 
[15:31:08.834]                       envir = ns)) {
[15:31:08.834]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:08.834]                         envir = ns)
[15:31:08.834]                       envir <- sys.frame(frame)
[15:31:08.834]                       master <- NULL
[15:31:08.834]                       while (!identical(envir, .GlobalEnv) && 
[15:31:08.834]                         !identical(envir, emptyenv())) {
[15:31:08.834]                         if (exists("master", mode = "list", envir = envir, 
[15:31:08.834]                           inherits = FALSE)) {
[15:31:08.834]                           master <- get("master", mode = "list", 
[15:31:08.834]                             envir = envir, inherits = FALSE)
[15:31:08.834]                           if (inherits(master, c("SOCKnode", 
[15:31:08.834]                             "SOCK0node"))) {
[15:31:08.834]                             sendCondition <<- function(cond) {
[15:31:08.834]                               data <- list(type = "VALUE", value = cond, 
[15:31:08.834]                                 success = TRUE)
[15:31:08.834]                               parallel_sendData(master, data)
[15:31:08.834]                             }
[15:31:08.834]                             return(sendCondition)
[15:31:08.834]                           }
[15:31:08.834]                         }
[15:31:08.834]                         frame <- frame + 1L
[15:31:08.834]                         envir <- sys.frame(frame)
[15:31:08.834]                       }
[15:31:08.834]                     }
[15:31:08.834]                     sendCondition <<- function(cond) NULL
[15:31:08.834]                   }
[15:31:08.834]                 })
[15:31:08.834]                 withCallingHandlers({
[15:31:08.834]                   {
[15:31:08.834]                     do.call(function(...) {
[15:31:08.834]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:08.834]                       if (!identical(...future.globals.maxSize.org, 
[15:31:08.834]                         ...future.globals.maxSize)) {
[15:31:08.834]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:08.834]                         on.exit(options(oopts), add = TRUE)
[15:31:08.834]                       }
[15:31:08.834]                       {
[15:31:08.834]                         lapply(seq_along(...future.elements_ii), 
[15:31:08.834]                           FUN = function(jj) {
[15:31:08.834]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:08.834]                             assign(".Random.seed", ...future.seeds_ii[[jj]], 
[15:31:08.834]                               envir = globalenv(), inherits = FALSE)
[15:31:08.834]                             ...future.FUN(...future.X_jj, ...)
[15:31:08.834]                           })
[15:31:08.834]                       }
[15:31:08.834]                     }, args = future.call.arguments)
[15:31:08.834]                   }
[15:31:08.834]                 }, immediateCondition = function(cond) {
[15:31:08.834]                   sendCondition <- ...future.makeSendCondition()
[15:31:08.834]                   sendCondition(cond)
[15:31:08.834]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:08.834]                   {
[15:31:08.834]                     inherits <- base::inherits
[15:31:08.834]                     invokeRestart <- base::invokeRestart
[15:31:08.834]                     is.null <- base::is.null
[15:31:08.834]                     muffled <- FALSE
[15:31:08.834]                     if (inherits(cond, "message")) {
[15:31:08.834]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:08.834]                       if (muffled) 
[15:31:08.834]                         invokeRestart("muffleMessage")
[15:31:08.834]                     }
[15:31:08.834]                     else if (inherits(cond, "warning")) {
[15:31:08.834]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:08.834]                       if (muffled) 
[15:31:08.834]                         invokeRestart("muffleWarning")
[15:31:08.834]                     }
[15:31:08.834]                     else if (inherits(cond, "condition")) {
[15:31:08.834]                       if (!is.null(pattern)) {
[15:31:08.834]                         computeRestarts <- base::computeRestarts
[15:31:08.834]                         grepl <- base::grepl
[15:31:08.834]                         restarts <- computeRestarts(cond)
[15:31:08.834]                         for (restart in restarts) {
[15:31:08.834]                           name <- restart$name
[15:31:08.834]                           if (is.null(name)) 
[15:31:08.834]                             next
[15:31:08.834]                           if (!grepl(pattern, name)) 
[15:31:08.834]                             next
[15:31:08.834]                           invokeRestart(restart)
[15:31:08.834]                           muffled <- TRUE
[15:31:08.834]                           break
[15:31:08.834]                         }
[15:31:08.834]                       }
[15:31:08.834]                     }
[15:31:08.834]                     invisible(muffled)
[15:31:08.834]                   }
[15:31:08.834]                   muffleCondition(cond)
[15:31:08.834]                 })
[15:31:08.834]             }))
[15:31:08.834]             future::FutureResult(value = ...future.value$value, 
[15:31:08.834]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:08.834]                   ...future.rng), globalenv = if (FALSE) 
[15:31:08.834]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:08.834]                     ...future.globalenv.names))
[15:31:08.834]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:08.834]         }, condition = base::local({
[15:31:08.834]             c <- base::c
[15:31:08.834]             inherits <- base::inherits
[15:31:08.834]             invokeRestart <- base::invokeRestart
[15:31:08.834]             length <- base::length
[15:31:08.834]             list <- base::list
[15:31:08.834]             seq.int <- base::seq.int
[15:31:08.834]             signalCondition <- base::signalCondition
[15:31:08.834]             sys.calls <- base::sys.calls
[15:31:08.834]             `[[` <- base::`[[`
[15:31:08.834]             `+` <- base::`+`
[15:31:08.834]             `<<-` <- base::`<<-`
[15:31:08.834]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:08.834]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:08.834]                   3L)]
[15:31:08.834]             }
[15:31:08.834]             function(cond) {
[15:31:08.834]                 is_error <- inherits(cond, "error")
[15:31:08.834]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:08.834]                   NULL)
[15:31:08.834]                 if (is_error) {
[15:31:08.834]                   sessionInformation <- function() {
[15:31:08.834]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:08.834]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:08.834]                       search = base::search(), system = base::Sys.info())
[15:31:08.834]                   }
[15:31:08.834]                   ...future.conditions[[length(...future.conditions) + 
[15:31:08.834]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:08.834]                     cond$call), session = sessionInformation(), 
[15:31:08.834]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:08.834]                   signalCondition(cond)
[15:31:08.834]                 }
[15:31:08.834]                 else if (!ignore && TRUE && inherits(cond, "immediateCondition")) {
[15:31:08.834]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:08.834]                   ...future.conditions[[length(...future.conditions) + 
[15:31:08.834]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:08.834]                   if (TRUE && !signal) {
[15:31:08.834]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:08.834]                     {
[15:31:08.834]                       inherits <- base::inherits
[15:31:08.834]                       invokeRestart <- base::invokeRestart
[15:31:08.834]                       is.null <- base::is.null
[15:31:08.834]                       muffled <- FALSE
[15:31:08.834]                       if (inherits(cond, "message")) {
[15:31:08.834]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:08.834]                         if (muffled) 
[15:31:08.834]                           invokeRestart("muffleMessage")
[15:31:08.834]                       }
[15:31:08.834]                       else if (inherits(cond, "warning")) {
[15:31:08.834]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:08.834]                         if (muffled) 
[15:31:08.834]                           invokeRestart("muffleWarning")
[15:31:08.834]                       }
[15:31:08.834]                       else if (inherits(cond, "condition")) {
[15:31:08.834]                         if (!is.null(pattern)) {
[15:31:08.834]                           computeRestarts <- base::computeRestarts
[15:31:08.834]                           grepl <- base::grepl
[15:31:08.834]                           restarts <- computeRestarts(cond)
[15:31:08.834]                           for (restart in restarts) {
[15:31:08.834]                             name <- restart$name
[15:31:08.834]                             if (is.null(name)) 
[15:31:08.834]                               next
[15:31:08.834]                             if (!grepl(pattern, name)) 
[15:31:08.834]                               next
[15:31:08.834]                             invokeRestart(restart)
[15:31:08.834]                             muffled <- TRUE
[15:31:08.834]                             break
[15:31:08.834]                           }
[15:31:08.834]                         }
[15:31:08.834]                       }
[15:31:08.834]                       invisible(muffled)
[15:31:08.834]                     }
[15:31:08.834]                     muffleCondition(cond, pattern = "^muffle")
[15:31:08.834]                   }
[15:31:08.834]                 }
[15:31:08.834]                 else {
[15:31:08.834]                   if (TRUE) {
[15:31:08.834]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:08.834]                     {
[15:31:08.834]                       inherits <- base::inherits
[15:31:08.834]                       invokeRestart <- base::invokeRestart
[15:31:08.834]                       is.null <- base::is.null
[15:31:08.834]                       muffled <- FALSE
[15:31:08.834]                       if (inherits(cond, "message")) {
[15:31:08.834]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:08.834]                         if (muffled) 
[15:31:08.834]                           invokeRestart("muffleMessage")
[15:31:08.834]                       }
[15:31:08.834]                       else if (inherits(cond, "warning")) {
[15:31:08.834]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:08.834]                         if (muffled) 
[15:31:08.834]                           invokeRestart("muffleWarning")
[15:31:08.834]                       }
[15:31:08.834]                       else if (inherits(cond, "condition")) {
[15:31:08.834]                         if (!is.null(pattern)) {
[15:31:08.834]                           computeRestarts <- base::computeRestarts
[15:31:08.834]                           grepl <- base::grepl
[15:31:08.834]                           restarts <- computeRestarts(cond)
[15:31:08.834]                           for (restart in restarts) {
[15:31:08.834]                             name <- restart$name
[15:31:08.834]                             if (is.null(name)) 
[15:31:08.834]                               next
[15:31:08.834]                             if (!grepl(pattern, name)) 
[15:31:08.834]                               next
[15:31:08.834]                             invokeRestart(restart)
[15:31:08.834]                             muffled <- TRUE
[15:31:08.834]                             break
[15:31:08.834]                           }
[15:31:08.834]                         }
[15:31:08.834]                       }
[15:31:08.834]                       invisible(muffled)
[15:31:08.834]                     }
[15:31:08.834]                     muffleCondition(cond, pattern = "^muffle")
[15:31:08.834]                   }
[15:31:08.834]                 }
[15:31:08.834]             }
[15:31:08.834]         }))
[15:31:08.834]     }, error = function(ex) {
[15:31:08.834]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:08.834]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:08.834]                 ...future.rng), started = ...future.startTime, 
[15:31:08.834]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:08.834]             version = "1.8"), class = "FutureResult")
[15:31:08.834]     }, finally = {
[15:31:08.834]         if (!identical(...future.workdir, getwd())) 
[15:31:08.834]             setwd(...future.workdir)
[15:31:08.834]         {
[15:31:08.834]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:08.834]                 ...future.oldOptions$nwarnings <- NULL
[15:31:08.834]             }
[15:31:08.834]             base::options(...future.oldOptions)
[15:31:08.834]             if (.Platform$OS.type == "windows") {
[15:31:08.834]                 old_names <- names(...future.oldEnvVars)
[15:31:08.834]                 envs <- base::Sys.getenv()
[15:31:08.834]                 names <- names(envs)
[15:31:08.834]                 common <- intersect(names, old_names)
[15:31:08.834]                 added <- setdiff(names, old_names)
[15:31:08.834]                 removed <- setdiff(old_names, names)
[15:31:08.834]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:08.834]                   envs[common]]
[15:31:08.834]                 NAMES <- toupper(changed)
[15:31:08.834]                 args <- list()
[15:31:08.834]                 for (kk in seq_along(NAMES)) {
[15:31:08.834]                   name <- changed[[kk]]
[15:31:08.834]                   NAME <- NAMES[[kk]]
[15:31:08.834]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:08.834]                     next
[15:31:08.834]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:08.834]                 }
[15:31:08.834]                 NAMES <- toupper(added)
[15:31:08.834]                 for (kk in seq_along(NAMES)) {
[15:31:08.834]                   name <- added[[kk]]
[15:31:08.834]                   NAME <- NAMES[[kk]]
[15:31:08.834]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:08.834]                     next
[15:31:08.834]                   args[[name]] <- ""
[15:31:08.834]                 }
[15:31:08.834]                 NAMES <- toupper(removed)
[15:31:08.834]                 for (kk in seq_along(NAMES)) {
[15:31:08.834]                   name <- removed[[kk]]
[15:31:08.834]                   NAME <- NAMES[[kk]]
[15:31:08.834]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:08.834]                     next
[15:31:08.834]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:08.834]                 }
[15:31:08.834]                 if (length(args) > 0) 
[15:31:08.834]                   base::do.call(base::Sys.setenv, args = args)
[15:31:08.834]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:08.834]             }
[15:31:08.834]             else {
[15:31:08.834]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:08.834]             }
[15:31:08.834]             {
[15:31:08.834]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:08.834]                   0L) {
[15:31:08.834]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:08.834]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:08.834]                   base::options(opts)
[15:31:08.834]                 }
[15:31:08.834]                 {
[15:31:08.834]                   {
[15:31:08.834]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:08.834]                     NULL
[15:31:08.834]                   }
[15:31:08.834]                   options(future.plan = NULL)
[15:31:08.834]                   if (is.na(NA_character_)) 
[15:31:08.834]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:08.834]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:08.834]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:08.834]                     .init = FALSE)
[15:31:08.834]                 }
[15:31:08.834]             }
[15:31:08.834]         }
[15:31:08.834]     })
[15:31:08.834]     if (TRUE) {
[15:31:08.834]         base::sink(type = "output", split = FALSE)
[15:31:08.834]         if (TRUE) {
[15:31:08.834]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:08.834]         }
[15:31:08.834]         else {
[15:31:08.834]             ...future.result["stdout"] <- base::list(NULL)
[15:31:08.834]         }
[15:31:08.834]         base::close(...future.stdout)
[15:31:08.834]         ...future.stdout <- NULL
[15:31:08.834]     }
[15:31:08.834]     ...future.result$conditions <- ...future.conditions
[15:31:08.834]     ...future.result$finished <- base::Sys.time()
[15:31:08.834]     ...future.result
[15:31:08.834] }
[15:31:08.842] Exporting 5 global objects (35.63 KiB) to cluster node #1 ...
[15:31:08.843] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:31:08.843] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:31:08.844] Exporting '...future.FUN' (35.45 KiB) to cluster node #1 ...
[15:31:08.844] Exporting '...future.FUN' (35.45 KiB) to cluster node #1 ... DONE
[15:31:08.845] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ...
[15:31:08.845] Exporting '...future.elements_ii' (56 bytes) to cluster node #1 ... DONE
[15:31:08.845] Exporting '...future.seeds_ii' (80 bytes) to cluster node #1 ...
[15:31:08.846] Exporting '...future.seeds_ii' (80 bytes) to cluster node #1 ... DONE
[15:31:08.846] Exporting '...future.globals.maxSize' (56 bytes) to cluster node #1 ...
[15:31:08.847] Exporting '...future.globals.maxSize' (56 bytes) to cluster node #1 ... DONE
[15:31:08.847] Exporting 5 global objects (35.63 KiB) to cluster node #1 ... DONE
[15:31:08.848] MultisessionFuture started
[15:31:08.848] - Launch lazy future ... done
[15:31:08.848] run() for 'MultisessionFuture' ... done
[15:31:08.849] Created future:
[15:31:08.874] receiveMessageFromWorker() for ClusterFuture ...
[15:31:08.875] - Validating connection of MultisessionFuture
[15:31:08.875] - received message: FutureResult
[15:31:08.875] - Received FutureResult
[15:31:08.876] - Erased future from FutureRegistry
[15:31:08.876] result() for ClusterFuture ...
[15:31:08.876] - result already collected: FutureResult
[15:31:08.876] result() for ClusterFuture ... done
[15:31:08.876] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:08.849] MultisessionFuture:
[15:31:08.849] Label: 'future_apply-2'
[15:31:08.849] Expression:
[15:31:08.849] {
[15:31:08.849]     do.call(function(...) {
[15:31:08.849]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:08.849]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:08.849]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:08.849]             on.exit(options(oopts), add = TRUE)
[15:31:08.849]         }
[15:31:08.849]         {
[15:31:08.849]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:08.849]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:08.849]                 assign(".Random.seed", ...future.seeds_ii[[jj]], 
[15:31:08.849]                   envir = globalenv(), inherits = FALSE)
[15:31:08.849]                 ...future.FUN(...future.X_jj, ...)
[15:31:08.849]             })
[15:31:08.849]         }
[15:31:08.849]     }, args = future.call.arguments)
[15:31:08.849] }
[15:31:08.849] Lazy evaluation: FALSE
[15:31:08.849] Asynchronous evaluation: TRUE
[15:31:08.849] Local evaluation: TRUE
[15:31:08.849] Environment: R_GlobalEnv
[15:31:08.849] Capture standard output: TRUE
[15:31:08.849] Capture condition classes: <none>
[15:31:08.849] Globals: 5 objects totaling 35.63 KiB (DotDotDotList 'future.call.arguments' of 0 bytes, function '...future.FUN' of 35.45 KiB, list '...future.elements_ii' of 56 bytes, list '...future.seeds_ii' of 80 bytes, numeric '...future.globals.maxSize' of 56 bytes)
[15:31:08.849] Packages: <none>
[15:31:08.849] L'Ecuyer-CMRG RNG seed: <none> (seed = NULL)
[15:31:08.849] Resolved: TRUE
[15:31:08.849] Value: <not collected>
[15:31:08.849] Conditions captured: <none>
[15:31:08.849] Early signaling: FALSE
[15:31:08.849] Owner process: 6672a580-6d3c-e82f-380e-108c475ace70
[15:31:08.849] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:08.877] Chunk #2 of 2 ... DONE
[15:31:08.877] Launching 2 futures (chunks) ... DONE
[15:31:08.877] Resolving 2 futures (chunks) ...
[15:31:08.877] resolve() on list ...
[15:31:08.877]  recursive: 0
[15:31:08.878]  length: 2
[15:31:08.878] 
[15:31:08.878] Future #1
[15:31:08.878] result() for ClusterFuture ...
[15:31:08.878] - result already collected: FutureResult
[15:31:08.878] result() for ClusterFuture ... done
[15:31:08.879] result() for ClusterFuture ...
[15:31:08.879] - result already collected: FutureResult
[15:31:08.879] result() for ClusterFuture ... done
[15:31:08.879] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:31:08.879] - nx: 2
[15:31:08.880] - relay: TRUE
[15:31:08.880] - stdout: TRUE
[15:31:08.880] - signal: TRUE
[15:31:08.880] - resignal: FALSE
[15:31:08.880] - force: TRUE
[15:31:08.880] - relayed: [n=2] FALSE, FALSE
[15:31:08.880] - queued futures: [n=2] FALSE, FALSE
[15:31:08.881]  - until=1
[15:31:08.881]  - relaying element #1
[15:31:08.881] result() for ClusterFuture ...
[15:31:08.881] - result already collected: FutureResult
[15:31:08.881] result() for ClusterFuture ... done
[15:31:08.881] result() for ClusterFuture ...
[15:31:08.882] - result already collected: FutureResult
[15:31:08.882] result() for ClusterFuture ... done
[15:31:08.882] result() for ClusterFuture ...
[15:31:08.882] - result already collected: FutureResult
[15:31:08.882] result() for ClusterFuture ... done
[15:31:08.882] result() for ClusterFuture ...
[15:31:08.883] - result already collected: FutureResult
[15:31:08.883] result() for ClusterFuture ... done
[15:31:08.883] - relayed: [n=2] TRUE, FALSE
[15:31:08.883] - queued futures: [n=2] TRUE, FALSE
[15:31:08.883] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:31:08.883]  length: 1 (resolved future 1)
[15:31:08.884] Future #2
[15:31:08.884] result() for ClusterFuture ...
[15:31:08.884] - result already collected: FutureResult
[15:31:08.884] result() for ClusterFuture ... done
[15:31:08.884] result() for ClusterFuture ...
[15:31:08.884] - result already collected: FutureResult
[15:31:08.885] result() for ClusterFuture ... done
[15:31:08.885] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:31:08.885] - nx: 2
[15:31:08.885] - relay: TRUE
[15:31:08.885] - stdout: TRUE
[15:31:08.885] - signal: TRUE
[15:31:08.886] - resignal: FALSE
[15:31:08.886] - force: TRUE
[15:31:08.886] - relayed: [n=2] TRUE, FALSE
[15:31:08.886] - queued futures: [n=2] TRUE, FALSE
[15:31:08.886]  - until=2
[15:31:08.886]  - relaying element #2
[15:31:08.887] result() for ClusterFuture ...
[15:31:08.887] - result already collected: FutureResult
[15:31:08.887] result() for ClusterFuture ... done
[15:31:08.887] result() for ClusterFuture ...
[15:31:08.887] - result already collected: FutureResult
[15:31:08.887] result() for ClusterFuture ... done
[15:31:08.888] result() for ClusterFuture ...
[15:31:08.888] - result already collected: FutureResult
[15:31:08.888] result() for ClusterFuture ... done
[15:31:08.888] result() for ClusterFuture ...
[15:31:08.888] - result already collected: FutureResult
[15:31:08.888] result() for ClusterFuture ... done
[15:31:08.889] - relayed: [n=2] TRUE, TRUE
[15:31:08.889] - queued futures: [n=2] TRUE, TRUE
[15:31:08.889] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:31:08.889]  length: 0 (resolved future 2)
[15:31:08.889] Relaying remaining futures
[15:31:08.889] signalConditionsASAP(NULL, pos=0) ...
[15:31:08.890] - nx: 2
[15:31:08.890] - relay: TRUE
[15:31:08.890] - stdout: TRUE
[15:31:08.890] - signal: TRUE
[15:31:08.890] - resignal: FALSE
[15:31:08.890] - force: TRUE
[15:31:08.891] - relayed: [n=2] TRUE, TRUE
[15:31:08.891] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:31:08.891] - relayed: [n=2] TRUE, TRUE
[15:31:08.891] - queued futures: [n=2] TRUE, TRUE
[15:31:08.891] signalConditionsASAP(NULL, pos=0) ... done
[15:31:08.892] resolve() on list ... DONE
[15:31:08.892] result() for ClusterFuture ...
[15:31:08.892] - result already collected: FutureResult
[15:31:08.892] result() for ClusterFuture ... done
[15:31:08.892] result() for ClusterFuture ...
[15:31:08.892] - result already collected: FutureResult
[15:31:08.892] result() for ClusterFuture ... done
[15:31:08.893] result() for ClusterFuture ...
[15:31:08.893] - result already collected: FutureResult
[15:31:08.893] result() for ClusterFuture ... done
[15:31:08.893] result() for ClusterFuture ...
[15:31:08.893] - result already collected: FutureResult
[15:31:08.894] result() for ClusterFuture ... done
[15:31:08.894]  - Number of value chunks collected: 2
[15:31:08.894] Resolving 2 futures (chunks) ... DONE
[15:31:08.894] Reducing values from 2 chunks ...
[15:31:08.894]  - Number of values collected after concatenation: 2
[15:31:08.894]  - Number of values expected: 2
[15:31:08.895] Reducing values from 2 chunks ... DONE
[15:31:08.895] future_lapply() ... DONE
     [,1] [,2]
[1,]    3    2
[2,]    1    4
[15:31:08.895] plan(): Setting new future strategy stack:
[15:31:08.895] List of future strategies:
[15:31:08.895] 1. sequential:
[15:31:08.895]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:08.895]    - tweaked: FALSE
[15:31:08.895]    - call: plan(sequential)
[15:31:08.897] plan(): nbrOfWorkers() = 1
*** strategy = 'multisession' ... done
> 
> 
> message("*** apply(X, ...) - prod(dim(X)) == 0 [non-parallel] ...")
*** apply(X, ...) - prod(dim(X)) == 0 [non-parallel] ...
> X <- matrix(nrow = 0L, ncol = 2L)
> y0 <- apply(X, MARGIN = 1L, FUN = identity)
> y1 <- future_apply(X, MARGIN = 1L, FUN = identity)
> print(y1)
logical(0)
> stopifnot(identical(y1, y0))
>   
> 
> message("*** exceptions ...")
*** exceptions ...
> 
> ## Error: dim(X) must have a positive length
> res <- tryCatch({
+   y <- future_apply(1L, MARGIN = 1L, FUN = identity)
+ }, error = identity)
> stopifnot(inherits(res, "error"))
> 
> ## Error: 'X' must have named dimnames
> X <- matrix(1:2, nrow = 2L, ncol = 1L)
> res <- tryCatch({
+   y <- future_apply(X, MARGIN = "rows", FUN = identity)
+ }, error = identity)
> stopifnot(inherits(res, "error"))
> 
> ## Error: not all elements of 'MARGIN' are names of dimensions
> X <- matrix(1:2, nrow = 2L, ncol = 1L, dimnames = list(rows = c("a", "b")))
> res <- tryCatch({
+   y <- future_apply(X, MARGIN = "cols", FUN = identity)
+ }, error = identity)
> stopifnot(inherits(res, "error"))
> 
> 
> message("*** future_apply() ... DONE")
*** future_apply() ... DONE
> 
> source("incl/end.R")
[15:31:08.899] plan(): Setting new future strategy stack:
[15:31:08.899] List of future strategies:
[15:31:08.899] 1. FutureStrategy:
[15:31:08.899]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:08.899]    - tweaked: FALSE
[15:31:08.899]    - call: future::plan(oplan)
[15:31:08.900] plan(): nbrOfWorkers() = 1
> 
> proc.time()
   user  system elapsed 
   3.96    0.23    5.61