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:14.615] plan(): Setting new future strategy stack:
[15:31:14.616] List of future strategies:
[15:31:14.616] 1. sequential:
[15:31:14.616]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:14.616]    - tweaked: FALSE
[15:31:14.616]    - call: future::plan("sequential")
[15:31:14.635] plan(): nbrOfWorkers() = 1
> 
> message("*** future_eapply() ...")
*** future_eapply() ...
> 
> message("- From example(eapply) ...")
- From example(eapply) ...
> 
> for (strategy in supportedStrategies()) {
+   message(sprintf("*** strategy = %s ...", sQuote(strategy)))
+   plan(strategy)
+   
+   env <- new.env(hash = FALSE)
+   env$a <- 1:10
+   env$beta <- exp(-3:3)
+   env$logic <- c(TRUE, FALSE, FALSE, TRUE)
+   
+   y0 <- unlist(eapply(env, mean, USE.NAMES = FALSE))
+   y1 <- unlist(future_eapply(env, mean, USE.NAMES = FALSE))
+   stopifnot(all.equal(y1, y0))
+   
+   y0 <- eapply(env, quantile, probs = 1:3/4)
+   y1 <- future_eapply(env, quantile, probs = 1:3/4)
+   stopifnot(all.equal(y1, y0))
+   
+   y0 <- eapply(env, quantile)
+   y1 <- future_eapply(env, quantile)
+   stopifnot(all.equal(y1, y0))
+   y2 <- future_eapply(env, "quantile")
+   stopifnot(all.equal(y2, y0))
+ 
+   plan(sequential)
+   message(sprintf("*** strategy = %s ... done", sQuote(strategy)))
+ } ## for (strategy in ...) 
*** strategy = 'sequential' ...
[15:31:14.670] plan(): Setting new future strategy stack:
[15:31:14.671] List of future strategies:
[15:31:14.671] 1. sequential:
[15:31:14.671]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:14.671]    - tweaked: FALSE
[15:31:14.671]    - call: plan(strategy)
[15:31:14.695] plan(): nbrOfWorkers() = 1
[15:31:14.696] future_lapply() ...
[15:31:14.704] Number of chunks: 1
[15:31:14.704] getGlobalsAndPackagesXApply() ...
[15:31:14.705]  - future.globals: TRUE
[15:31:14.706] getGlobalsAndPackages() ...
[15:31:14.706] Searching for globals...
[15:31:14.711] - globals found: [2] 'FUN', 'UseMethod'
[15:31:14.712] Searching for globals ... DONE
[15:31:14.716] Resolving globals: FALSE
[15:31:14.718] The total size of the 1 globals is 1.21 KiB (1240 bytes)
[15:31:14.719] The total size of the 1 globals exported for future expression ('FUN()') is 1.21 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.21 KiB of class 'function')
[15:31:14.720] - globals: [1] 'FUN'
[15:31:14.720] 
[15:31:14.720] getGlobalsAndPackages() ... DONE
[15:31:14.721]  - globals found/used: [n=1] 'FUN'
[15:31:14.721]  - needed namespaces: [n=0] 
[15:31:14.721] Finding globals ... DONE
[15:31:14.722]  - use_args: TRUE
[15:31:14.722]  - Getting '...' globals ...
[15:31:14.724] resolve() on list ...
[15:31:14.724]  recursive: 0
[15:31:14.725]  length: 1
[15:31:14.725]  elements: '...'
[15:31:14.726]  length: 0 (resolved future 1)
[15:31:14.726] resolve() on list ... DONE
[15:31:14.727]    - '...' content: [n=0] 
[15:31:14.727] List of 1
[15:31:14.727]  $ ...: list()
[15:31:14.727]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:14.727]  - attr(*, "where")=List of 1
[15:31:14.727]   ..$ ...:<environment: 0x000001b3fa52f568> 
[15:31:14.727]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:14.727]  - attr(*, "resolved")= logi TRUE
[15:31:14.727]  - attr(*, "total_size")= num NA
[15:31:14.738]  - Getting '...' globals ... DONE
[15:31:14.738] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:14.739] List of 2
[15:31:14.739]  $ ...future.FUN:function (x, ...)  
[15:31:14.739]  $ ...          : list()
[15:31:14.739]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:14.739]  - attr(*, "where")=List of 2
[15:31:14.739]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:14.739]   ..$ ...          :<environment: 0x000001b3fa52f568> 
[15:31:14.739]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:14.739]  - attr(*, "resolved")= logi FALSE
[15:31:14.739]  - attr(*, "total_size")= num 1240
[15:31:14.745] Packages to be attached in all futures: [n=0] 
[15:31:14.745] getGlobalsAndPackagesXApply() ... DONE
[15:31:14.746] Number of futures (= number of chunks): 1
[15:31:14.747] Launching 1 futures (chunks) ...
[15:31:14.747] Chunk #1 of 1 ...
[15:31:14.748]  - Finding globals in 'X' for chunk #1 ...
[15:31:14.748] getGlobalsAndPackages() ...
[15:31:14.748] Searching for globals...
[15:31:14.749] 
[15:31:14.749] Searching for globals ... DONE
[15:31:14.750] - globals: [0] <none>
[15:31:14.750] getGlobalsAndPackages() ... DONE
[15:31:14.750]    + additional globals found: [n=0] 
[15:31:14.751]    + additional namespaces needed: [n=0] 
[15:31:14.751]  - Finding globals in 'X' for chunk #1 ... DONE
[15:31:14.751]  - seeds: <none>
[15:31:14.752]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:14.752] getGlobalsAndPackages() ...
[15:31:14.753] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:14.753] Resolving globals: FALSE
[15:31:14.753] Tweak future expression to call with '...' arguments ...
[15:31:14.753] {
[15:31:14.753]     do.call(function(...) {
[15:31:14.753]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:14.753]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:14.753]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:14.753]             on.exit(options(oopts), add = TRUE)
[15:31:14.753]         }
[15:31:14.753]         {
[15:31:14.753]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:14.753]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:14.753]                 ...future.FUN(...future.X_jj, ...)
[15:31:14.753]             })
[15:31:14.753]         }
[15:31:14.753]     }, args = future.call.arguments)
[15:31:14.753] }
[15:31:14.754] Tweak future expression to call with '...' arguments ... DONE
[15:31:14.755] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:14.755] 
[15:31:14.756] getGlobalsAndPackages() ... DONE
[15:31:14.757] run() for 'Future' ...
[15:31:14.757] - state: 'created'
[15:31:14.758] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:31:14.759] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:14.759] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:31:14.759]   - Field: 'label'
[15:31:14.760]   - Field: 'local'
[15:31:14.760]   - Field: 'owner'
[15:31:14.760]   - Field: 'envir'
[15:31:14.760]   - Field: 'packages'
[15:31:14.761]   - Field: 'gc'
[15:31:14.761]   - Field: 'conditions'
[15:31:14.761]   - Field: 'expr'
[15:31:14.762]   - Field: 'uuid'
[15:31:14.762]   - Field: 'seed'
[15:31:14.762]   - Field: 'version'
[15:31:14.763]   - Field: 'result'
[15:31:14.763]   - Field: 'asynchronous'
[15:31:14.763]   - Field: 'calls'
[15:31:14.763]   - Field: 'globals'
[15:31:14.764]   - Field: 'stdout'
[15:31:14.764]   - Field: 'earlySignal'
[15:31:14.764]   - Field: 'lazy'
[15:31:14.765]   - Field: 'state'
[15:31:14.765] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:31:14.765] - Launch lazy future ...
[15:31:14.767] Packages needed by the future expression (n = 0): <none>
[15:31:14.767] Packages needed by future strategies (n = 0): <none>
[15:31:14.769] {
[15:31:14.769]     {
[15:31:14.769]         {
[15:31:14.769]             ...future.startTime <- base::Sys.time()
[15:31:14.769]             {
[15:31:14.769]                 {
[15:31:14.769]                   {
[15:31:14.769]                     base::local({
[15:31:14.769]                       has_future <- base::requireNamespace("future", 
[15:31:14.769]                         quietly = TRUE)
[15:31:14.769]                       if (has_future) {
[15:31:14.769]                         ns <- base::getNamespace("future")
[15:31:14.769]                         version <- ns[[".package"]][["version"]]
[15:31:14.769]                         if (is.null(version)) 
[15:31:14.769]                           version <- utils::packageVersion("future")
[15:31:14.769]                       }
[15:31:14.769]                       else {
[15:31:14.769]                         version <- NULL
[15:31:14.769]                       }
[15:31:14.769]                       if (!has_future || version < "1.8.0") {
[15:31:14.769]                         info <- base::c(r_version = base::gsub("R version ", 
[15:31:14.769]                           "", base::R.version$version.string), 
[15:31:14.769]                           platform = base::sprintf("%s (%s-bit)", 
[15:31:14.769]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:14.769]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:14.769]                             "release", "version")], collapse = " "), 
[15:31:14.769]                           hostname = base::Sys.info()[["nodename"]])
[15:31:14.769]                         info <- base::sprintf("%s: %s", base::names(info), 
[15:31:14.769]                           info)
[15:31:14.769]                         info <- base::paste(info, collapse = "; ")
[15:31:14.769]                         if (!has_future) {
[15:31:14.769]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:14.769]                             info)
[15:31:14.769]                         }
[15:31:14.769]                         else {
[15:31:14.769]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:14.769]                             info, version)
[15:31:14.769]                         }
[15:31:14.769]                         base::stop(msg)
[15:31:14.769]                       }
[15:31:14.769]                     })
[15:31:14.769]                   }
[15:31:14.769]                   ...future.strategy.old <- future::plan("list")
[15:31:14.769]                   options(future.plan = NULL)
[15:31:14.769]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:14.769]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:14.769]                 }
[15:31:14.769]                 ...future.workdir <- getwd()
[15:31:14.769]             }
[15:31:14.769]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:14.769]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:14.769]         }
[15:31:14.769]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:14.769]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:31:14.769]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:14.769]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:14.769]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:14.769]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:14.769]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:14.769]             base::names(...future.oldOptions))
[15:31:14.769]     }
[15:31:14.769]     if (FALSE) {
[15:31:14.769]     }
[15:31:14.769]     else {
[15:31:14.769]         if (TRUE) {
[15:31:14.769]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:14.769]                 open = "w")
[15:31:14.769]         }
[15:31:14.769]         else {
[15:31:14.769]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:14.769]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:14.769]         }
[15:31:14.769]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:14.769]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:14.769]             base::sink(type = "output", split = FALSE)
[15:31:14.769]             base::close(...future.stdout)
[15:31:14.769]         }, add = TRUE)
[15:31:14.769]     }
[15:31:14.769]     ...future.frame <- base::sys.nframe()
[15:31:14.769]     ...future.conditions <- base::list()
[15:31:14.769]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:14.769]     if (FALSE) {
[15:31:14.769]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:14.769]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:14.769]     }
[15:31:14.769]     ...future.result <- base::tryCatch({
[15:31:14.769]         base::withCallingHandlers({
[15:31:14.769]             ...future.value <- base::withVisible(base::local({
[15:31:14.769]                 do.call(function(...) {
[15:31:14.769]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:14.769]                   if (!identical(...future.globals.maxSize.org, 
[15:31:14.769]                     ...future.globals.maxSize)) {
[15:31:14.769]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:14.769]                     on.exit(options(oopts), add = TRUE)
[15:31:14.769]                   }
[15:31:14.769]                   {
[15:31:14.769]                     lapply(seq_along(...future.elements_ii), 
[15:31:14.769]                       FUN = function(jj) {
[15:31:14.769]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:14.769]                         ...future.FUN(...future.X_jj, ...)
[15:31:14.769]                       })
[15:31:14.769]                   }
[15:31:14.769]                 }, args = future.call.arguments)
[15:31:14.769]             }))
[15:31:14.769]             future::FutureResult(value = ...future.value$value, 
[15:31:14.769]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:14.769]                   ...future.rng), globalenv = if (FALSE) 
[15:31:14.769]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:14.769]                     ...future.globalenv.names))
[15:31:14.769]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:14.769]         }, condition = base::local({
[15:31:14.769]             c <- base::c
[15:31:14.769]             inherits <- base::inherits
[15:31:14.769]             invokeRestart <- base::invokeRestart
[15:31:14.769]             length <- base::length
[15:31:14.769]             list <- base::list
[15:31:14.769]             seq.int <- base::seq.int
[15:31:14.769]             signalCondition <- base::signalCondition
[15:31:14.769]             sys.calls <- base::sys.calls
[15:31:14.769]             `[[` <- base::`[[`
[15:31:14.769]             `+` <- base::`+`
[15:31:14.769]             `<<-` <- base::`<<-`
[15:31:14.769]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:14.769]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:14.769]                   3L)]
[15:31:14.769]             }
[15:31:14.769]             function(cond) {
[15:31:14.769]                 is_error <- inherits(cond, "error")
[15:31:14.769]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:14.769]                   NULL)
[15:31:14.769]                 if (is_error) {
[15:31:14.769]                   sessionInformation <- function() {
[15:31:14.769]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:14.769]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:14.769]                       search = base::search(), system = base::Sys.info())
[15:31:14.769]                   }
[15:31:14.769]                   ...future.conditions[[length(...future.conditions) + 
[15:31:14.769]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:14.769]                     cond$call), session = sessionInformation(), 
[15:31:14.769]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:14.769]                   signalCondition(cond)
[15:31:14.769]                 }
[15:31:14.769]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:14.769]                 "immediateCondition"))) {
[15:31:14.769]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:14.769]                   ...future.conditions[[length(...future.conditions) + 
[15:31:14.769]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:14.769]                   if (TRUE && !signal) {
[15:31:14.769]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:14.769]                     {
[15:31:14.769]                       inherits <- base::inherits
[15:31:14.769]                       invokeRestart <- base::invokeRestart
[15:31:14.769]                       is.null <- base::is.null
[15:31:14.769]                       muffled <- FALSE
[15:31:14.769]                       if (inherits(cond, "message")) {
[15:31:14.769]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:14.769]                         if (muffled) 
[15:31:14.769]                           invokeRestart("muffleMessage")
[15:31:14.769]                       }
[15:31:14.769]                       else if (inherits(cond, "warning")) {
[15:31:14.769]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:14.769]                         if (muffled) 
[15:31:14.769]                           invokeRestart("muffleWarning")
[15:31:14.769]                       }
[15:31:14.769]                       else if (inherits(cond, "condition")) {
[15:31:14.769]                         if (!is.null(pattern)) {
[15:31:14.769]                           computeRestarts <- base::computeRestarts
[15:31:14.769]                           grepl <- base::grepl
[15:31:14.769]                           restarts <- computeRestarts(cond)
[15:31:14.769]                           for (restart in restarts) {
[15:31:14.769]                             name <- restart$name
[15:31:14.769]                             if (is.null(name)) 
[15:31:14.769]                               next
[15:31:14.769]                             if (!grepl(pattern, name)) 
[15:31:14.769]                               next
[15:31:14.769]                             invokeRestart(restart)
[15:31:14.769]                             muffled <- TRUE
[15:31:14.769]                             break
[15:31:14.769]                           }
[15:31:14.769]                         }
[15:31:14.769]                       }
[15:31:14.769]                       invisible(muffled)
[15:31:14.769]                     }
[15:31:14.769]                     muffleCondition(cond, pattern = "^muffle")
[15:31:14.769]                   }
[15:31:14.769]                 }
[15:31:14.769]                 else {
[15:31:14.769]                   if (TRUE) {
[15:31:14.769]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:14.769]                     {
[15:31:14.769]                       inherits <- base::inherits
[15:31:14.769]                       invokeRestart <- base::invokeRestart
[15:31:14.769]                       is.null <- base::is.null
[15:31:14.769]                       muffled <- FALSE
[15:31:14.769]                       if (inherits(cond, "message")) {
[15:31:14.769]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:14.769]                         if (muffled) 
[15:31:14.769]                           invokeRestart("muffleMessage")
[15:31:14.769]                       }
[15:31:14.769]                       else if (inherits(cond, "warning")) {
[15:31:14.769]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:14.769]                         if (muffled) 
[15:31:14.769]                           invokeRestart("muffleWarning")
[15:31:14.769]                       }
[15:31:14.769]                       else if (inherits(cond, "condition")) {
[15:31:14.769]                         if (!is.null(pattern)) {
[15:31:14.769]                           computeRestarts <- base::computeRestarts
[15:31:14.769]                           grepl <- base::grepl
[15:31:14.769]                           restarts <- computeRestarts(cond)
[15:31:14.769]                           for (restart in restarts) {
[15:31:14.769]                             name <- restart$name
[15:31:14.769]                             if (is.null(name)) 
[15:31:14.769]                               next
[15:31:14.769]                             if (!grepl(pattern, name)) 
[15:31:14.769]                               next
[15:31:14.769]                             invokeRestart(restart)
[15:31:14.769]                             muffled <- TRUE
[15:31:14.769]                             break
[15:31:14.769]                           }
[15:31:14.769]                         }
[15:31:14.769]                       }
[15:31:14.769]                       invisible(muffled)
[15:31:14.769]                     }
[15:31:14.769]                     muffleCondition(cond, pattern = "^muffle")
[15:31:14.769]                   }
[15:31:14.769]                 }
[15:31:14.769]             }
[15:31:14.769]         }))
[15:31:14.769]     }, error = function(ex) {
[15:31:14.769]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:14.769]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:14.769]                 ...future.rng), started = ...future.startTime, 
[15:31:14.769]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:14.769]             version = "1.8"), class = "FutureResult")
[15:31:14.769]     }, finally = {
[15:31:14.769]         if (!identical(...future.workdir, getwd())) 
[15:31:14.769]             setwd(...future.workdir)
[15:31:14.769]         {
[15:31:14.769]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:14.769]                 ...future.oldOptions$nwarnings <- NULL
[15:31:14.769]             }
[15:31:14.769]             base::options(...future.oldOptions)
[15:31:14.769]             if (.Platform$OS.type == "windows") {
[15:31:14.769]                 old_names <- names(...future.oldEnvVars)
[15:31:14.769]                 envs <- base::Sys.getenv()
[15:31:14.769]                 names <- names(envs)
[15:31:14.769]                 common <- intersect(names, old_names)
[15:31:14.769]                 added <- setdiff(names, old_names)
[15:31:14.769]                 removed <- setdiff(old_names, names)
[15:31:14.769]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:14.769]                   envs[common]]
[15:31:14.769]                 NAMES <- toupper(changed)
[15:31:14.769]                 args <- list()
[15:31:14.769]                 for (kk in seq_along(NAMES)) {
[15:31:14.769]                   name <- changed[[kk]]
[15:31:14.769]                   NAME <- NAMES[[kk]]
[15:31:14.769]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:14.769]                     next
[15:31:14.769]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:14.769]                 }
[15:31:14.769]                 NAMES <- toupper(added)
[15:31:14.769]                 for (kk in seq_along(NAMES)) {
[15:31:14.769]                   name <- added[[kk]]
[15:31:14.769]                   NAME <- NAMES[[kk]]
[15:31:14.769]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:14.769]                     next
[15:31:14.769]                   args[[name]] <- ""
[15:31:14.769]                 }
[15:31:14.769]                 NAMES <- toupper(removed)
[15:31:14.769]                 for (kk in seq_along(NAMES)) {
[15:31:14.769]                   name <- removed[[kk]]
[15:31:14.769]                   NAME <- NAMES[[kk]]
[15:31:14.769]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:14.769]                     next
[15:31:14.769]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:14.769]                 }
[15:31:14.769]                 if (length(args) > 0) 
[15:31:14.769]                   base::do.call(base::Sys.setenv, args = args)
[15:31:14.769]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:14.769]             }
[15:31:14.769]             else {
[15:31:14.769]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:14.769]             }
[15:31:14.769]             {
[15:31:14.769]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:14.769]                   0L) {
[15:31:14.769]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:14.769]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:14.769]                   base::options(opts)
[15:31:14.769]                 }
[15:31:14.769]                 {
[15:31:14.769]                   {
[15:31:14.769]                     NULL
[15:31:14.769]                     RNGkind("Mersenne-Twister")
[15:31:14.769]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:31:14.769]                       inherits = FALSE)
[15:31:14.769]                   }
[15:31:14.769]                   options(future.plan = NULL)
[15:31:14.769]                   if (is.na(NA_character_)) 
[15:31:14.769]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:14.769]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:14.769]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:14.769]                     .init = FALSE)
[15:31:14.769]                 }
[15:31:14.769]             }
[15:31:14.769]         }
[15:31:14.769]     })
[15:31:14.769]     if (TRUE) {
[15:31:14.769]         base::sink(type = "output", split = FALSE)
[15:31:14.769]         if (TRUE) {
[15:31:14.769]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:14.769]         }
[15:31:14.769]         else {
[15:31:14.769]             ...future.result["stdout"] <- base::list(NULL)
[15:31:14.769]         }
[15:31:14.769]         base::close(...future.stdout)
[15:31:14.769]         ...future.stdout <- NULL
[15:31:14.769]     }
[15:31:14.769]     ...future.result$conditions <- ...future.conditions
[15:31:14.769]     ...future.result$finished <- base::Sys.time()
[15:31:14.769]     ...future.result
[15:31:14.769] }
[15:31:14.776] assign_globals() ...
[15:31:14.777] List of 5
[15:31:14.777]  $ ...future.FUN            :function (x, ...)  
[15:31:14.777]  $ future.call.arguments    : list()
[15:31:14.777]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:14.777]  $ ...future.elements_ii    :List of 3
[15:31:14.777]   ..$ : logi [1:4] TRUE FALSE FALSE TRUE
[15:31:14.777]   ..$ : num [1:7] 0.0498 0.1353 0.3679 1 2.7183 ...
[15:31:14.777]   ..$ : int [1:10] 1 2 3 4 5 6 7 8 9 10
[15:31:14.777]  $ ...future.seeds_ii       : NULL
[15:31:14.777]  $ ...future.globals.maxSize: NULL
[15:31:14.777]  - attr(*, "where")=List of 5
[15:31:14.777]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:31:14.777]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:31:14.777]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:31:14.777]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:31:14.777]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:31:14.777]  - attr(*, "resolved")= logi FALSE
[15:31:14.777]  - attr(*, "total_size")= num 1240
[15:31:14.777]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:14.777]  - attr(*, "already-done")= logi TRUE
[15:31:14.792] - copied '...future.FUN' to environment
[15:31:14.792] - copied 'future.call.arguments' to environment
[15:31:14.792] - copied '...future.elements_ii' to environment
[15:31:14.793] - copied '...future.seeds_ii' to environment
[15:31:14.793] - copied '...future.globals.maxSize' to environment
[15:31:14.793] assign_globals() ... done
[15:31:14.794] plan(): Setting new future strategy stack:
[15:31:14.794] List of future strategies:
[15:31:14.794] 1. sequential:
[15:31:14.794]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:14.794]    - tweaked: FALSE
[15:31:14.794]    - call: NULL
[15:31:14.795] plan(): nbrOfWorkers() = 1
[15:31:14.799] plan(): Setting new future strategy stack:
[15:31:14.799] List of future strategies:
[15:31:14.799] 1. sequential:
[15:31:14.799]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:14.799]    - tweaked: FALSE
[15:31:14.799]    - call: plan(strategy)
[15:31:14.800] plan(): nbrOfWorkers() = 1
[15:31:14.800] SequentialFuture started (and completed)
[15:31:14.801] - Launch lazy future ... done
[15:31:14.802] run() for 'SequentialFuture' ... done
[15:31:14.802] Created future:
[15:31:14.802] SequentialFuture:
[15:31:14.802] Label: 'future_eapply-1'
[15:31:14.802] Expression:
[15:31:14.802] {
[15:31:14.802]     do.call(function(...) {
[15:31:14.802]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:14.802]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:14.802]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:14.802]             on.exit(options(oopts), add = TRUE)
[15:31:14.802]         }
[15:31:14.802]         {
[15:31:14.802]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:14.802]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:14.802]                 ...future.FUN(...future.X_jj, ...)
[15:31:14.802]             })
[15:31:14.802]         }
[15:31:14.802]     }, args = future.call.arguments)
[15:31:14.802] }
[15:31:14.802] Lazy evaluation: FALSE
[15:31:14.802] Asynchronous evaluation: FALSE
[15:31:14.802] Local evaluation: TRUE
[15:31:14.802] Environment: R_GlobalEnv
[15:31:14.802] Capture standard output: TRUE
[15:31:14.802] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:14.802] Globals: 5 objects totaling 1.48 KiB (function '...future.FUN' of 1.21 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 272 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:31:14.802] Packages: <none>
[15:31:14.802] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:14.802] Resolved: TRUE
[15:31:14.802] Value: 168 bytes of class 'list'
[15:31:14.802] Early signaling: FALSE
[15:31:14.802] Owner process: 1f501b3c-5bdf-35ad-4a62-196ce98a2fc6
[15:31:14.802] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:14.805] Chunk #1 of 1 ... DONE
[15:31:14.806] Launching 1 futures (chunks) ... DONE
[15:31:14.806] Resolving 1 futures (chunks) ...
[15:31:14.806] resolve() on list ...
[15:31:14.807]  recursive: 0
[15:31:14.807]  length: 1
[15:31:14.807] 
[15:31:14.808] resolved() for 'SequentialFuture' ...
[15:31:14.808] - state: 'finished'
[15:31:14.808] - run: TRUE
[15:31:14.808] - result: 'FutureResult'
[15:31:14.809] resolved() for 'SequentialFuture' ... done
[15:31:14.809] Future #1
[15:31:14.810] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:31:14.810] - nx: 1
[15:31:14.810] - relay: TRUE
[15:31:14.811] - stdout: TRUE
[15:31:14.811] - signal: TRUE
[15:31:14.811] - resignal: FALSE
[15:31:14.811] - force: TRUE
[15:31:14.812] - relayed: [n=1] FALSE
[15:31:14.812] - queued futures: [n=1] FALSE
[15:31:14.812]  - until=1
[15:31:14.812]  - relaying element #1
[15:31:14.813] - relayed: [n=1] TRUE
[15:31:14.813] - queued futures: [n=1] TRUE
[15:31:14.813] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:31:14.814]  length: 0 (resolved future 1)
[15:31:14.814] Relaying remaining futures
[15:31:14.815] signalConditionsASAP(NULL, pos=0) ...
[15:31:14.815] - nx: 1
[15:31:14.815] - relay: TRUE
[15:31:14.815] - stdout: TRUE
[15:31:14.816] - signal: TRUE
[15:31:14.816] - resignal: FALSE
[15:31:14.816] - force: TRUE
[15:31:14.816] - relayed: [n=1] TRUE
[15:31:14.817] - queued futures: [n=1] TRUE
 - flush all
[15:31:14.817] - relayed: [n=1] TRUE
[15:31:14.817] - queued futures: [n=1] TRUE
[15:31:14.817] signalConditionsASAP(NULL, pos=0) ... done
[15:31:14.818] resolve() on list ... DONE
[15:31:14.818]  - Number of value chunks collected: 1
[15:31:14.818] Resolving 1 futures (chunks) ... DONE
[15:31:14.819] Reducing values from 1 chunks ...
[15:31:14.819]  - Number of values collected after concatenation: 3
[15:31:14.819]  - Number of values expected: 3
[15:31:14.820] Reducing values from 1 chunks ... DONE
[15:31:14.820] future_lapply() ... DONE
[15:31:14.823] future_lapply() ...
[15:31:14.824] Number of chunks: 1
[15:31:14.825] getGlobalsAndPackagesXApply() ...
[15:31:14.825]  - future.globals: TRUE
[15:31:14.825] getGlobalsAndPackages() ...
[15:31:14.825] Searching for globals...
[15:31:14.827] - globals found: [2] 'FUN', 'UseMethod'
[15:31:14.828] Searching for globals ... DONE
[15:31:14.828] Resolving globals: FALSE
[15:31:14.829] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:31:14.830] The total size of the 1 globals exported for future expression ('FUN(probs = c(0.25, 0.5, 0.75))') 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:14.830] - globals: [1] 'FUN'
[15:31:14.830] - packages: [1] 'stats'
[15:31:14.830] getGlobalsAndPackages() ... DONE
[15:31:14.831]  - globals found/used: [n=1] 'FUN'
[15:31:14.831]  - needed namespaces: [n=1] 'stats'
[15:31:14.831] Finding globals ... DONE
[15:31:14.832]  - use_args: TRUE
[15:31:14.832]  - Getting '...' globals ...
[15:31:14.833] resolve() on list ...
[15:31:14.833]  recursive: 0
[15:31:14.833]  length: 1
[15:31:14.833]  elements: '...'
[15:31:14.834]  length: 0 (resolved future 1)
[15:31:14.834] resolve() on list ... DONE
[15:31:14.834]    - '...' content: [n=1] 'probs'
[15:31:14.835] List of 1
[15:31:14.835]  $ ...:List of 1
[15:31:14.835]   ..$ probs: num [1:3] 0.25 0.5 0.75
[15:31:14.835]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:14.835]  - attr(*, "where")=List of 1
[15:31:14.835]   ..$ ...:<environment: 0x000001b3f9c85e98> 
[15:31:14.835]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:14.835]  - attr(*, "resolved")= logi TRUE
[15:31:14.835]  - attr(*, "total_size")= num NA
[15:31:14.843]  - Getting '...' globals ... DONE
[15:31:14.844] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:14.844] List of 2
[15:31:14.844]  $ ...future.FUN:function (x, ...)  
[15:31:14.844]  $ ...          :List of 1
[15:31:14.844]   ..$ probs: num [1:3] 0.25 0.5 0.75
[15:31:14.844]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:14.844]  - attr(*, "where")=List of 2
[15:31:14.844]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:14.844]   ..$ ...          :<environment: 0x000001b3f9c85e98> 
[15:31:14.844]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:14.844]  - attr(*, "resolved")= logi FALSE
[15:31:14.844]  - attr(*, "total_size")= num 1328
[15:31:14.850] Packages to be attached in all futures: [n=1] 'stats'
[15:31:14.850] getGlobalsAndPackagesXApply() ... DONE
[15:31:14.851] Number of futures (= number of chunks): 1
[15:31:14.851] Launching 1 futures (chunks) ...
[15:31:14.851] Chunk #1 of 1 ...
[15:31:14.852]  - Finding globals in 'X' for chunk #1 ...
[15:31:14.852] getGlobalsAndPackages() ...
[15:31:14.852] Searching for globals...
[15:31:14.853] 
[15:31:14.853] Searching for globals ... DONE
[15:31:14.853] - globals: [0] <none>
[15:31:14.854] getGlobalsAndPackages() ... DONE
[15:31:14.854]    + additional globals found: [n=0] 
[15:31:14.854]    + additional namespaces needed: [n=0] 
[15:31:14.854]  - Finding globals in 'X' for chunk #1 ... DONE
[15:31:14.855]  - seeds: <none>
[15:31:14.855]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:14.855] getGlobalsAndPackages() ...
[15:31:14.855] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:14.856] Resolving globals: FALSE
[15:31:14.856] Tweak future expression to call with '...' arguments ...
[15:31:14.856] {
[15:31:14.856]     do.call(function(...) {
[15:31:14.856]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:14.856]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:14.856]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:14.856]             on.exit(options(oopts), add = TRUE)
[15:31:14.856]         }
[15:31:14.856]         {
[15:31:14.856]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:14.856]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:14.856]                 ...future.FUN(...future.X_jj, ...)
[15:31:14.856]             })
[15:31:14.856]         }
[15:31:14.856]     }, args = future.call.arguments)
[15:31:14.856] }
[15:31:14.857] Tweak future expression to call with '...' arguments ... DONE
[15:31:14.858] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:14.858] - packages: [1] 'stats'
[15:31:14.859] getGlobalsAndPackages() ... DONE
[15:31:14.859] run() for 'Future' ...
[15:31:14.860] - state: 'created'
[15:31:14.860] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:31:14.860] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:14.861] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:31:14.861]   - Field: 'label'
[15:31:14.861]   - Field: 'local'
[15:31:14.862]   - Field: 'owner'
[15:31:14.862]   - Field: 'envir'
[15:31:14.862]   - Field: 'packages'
[15:31:14.863]   - Field: 'gc'
[15:31:14.863]   - Field: 'conditions'
[15:31:14.863]   - Field: 'expr'
[15:31:14.863]   - Field: 'uuid'
[15:31:14.864]   - Field: 'seed'
[15:31:14.864]   - Field: 'version'
[15:31:14.864]   - Field: 'result'
[15:31:14.865]   - Field: 'asynchronous'
[15:31:14.865]   - Field: 'calls'
[15:31:14.865]   - Field: 'globals'
[15:31:14.865]   - Field: 'stdout'
[15:31:14.866]   - Field: 'earlySignal'
[15:31:14.866]   - Field: 'lazy'
[15:31:14.866]   - Field: 'state'
[15:31:14.867] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:31:14.867] - Launch lazy future ...
[15:31:14.867] Packages needed by the future expression (n = 1): 'stats'
[15:31:14.868] Packages needed by future strategies (n = 0): <none>
[15:31:14.869] {
[15:31:14.869]     {
[15:31:14.869]         {
[15:31:14.869]             ...future.startTime <- base::Sys.time()
[15:31:14.869]             {
[15:31:14.869]                 {
[15:31:14.869]                   {
[15:31:14.869]                     {
[15:31:14.869]                       base::local({
[15:31:14.869]                         has_future <- base::requireNamespace("future", 
[15:31:14.869]                           quietly = TRUE)
[15:31:14.869]                         if (has_future) {
[15:31:14.869]                           ns <- base::getNamespace("future")
[15:31:14.869]                           version <- ns[[".package"]][["version"]]
[15:31:14.869]                           if (is.null(version)) 
[15:31:14.869]                             version <- utils::packageVersion("future")
[15:31:14.869]                         }
[15:31:14.869]                         else {
[15:31:14.869]                           version <- NULL
[15:31:14.869]                         }
[15:31:14.869]                         if (!has_future || version < "1.8.0") {
[15:31:14.869]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:14.869]                             "", base::R.version$version.string), 
[15:31:14.869]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:14.869]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:14.869]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:14.869]                               "release", "version")], collapse = " "), 
[15:31:14.869]                             hostname = base::Sys.info()[["nodename"]])
[15:31:14.869]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:14.869]                             info)
[15:31:14.869]                           info <- base::paste(info, collapse = "; ")
[15:31:14.869]                           if (!has_future) {
[15:31:14.869]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:14.869]                               info)
[15:31:14.869]                           }
[15:31:14.869]                           else {
[15:31:14.869]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:14.869]                               info, version)
[15:31:14.869]                           }
[15:31:14.869]                           base::stop(msg)
[15:31:14.869]                         }
[15:31:14.869]                       })
[15:31:14.869]                     }
[15:31:14.869]                     base::local({
[15:31:14.869]                       for (pkg in "stats") {
[15:31:14.869]                         base::loadNamespace(pkg)
[15:31:14.869]                         base::library(pkg, character.only = TRUE)
[15:31:14.869]                       }
[15:31:14.869]                     })
[15:31:14.869]                   }
[15:31:14.869]                   ...future.strategy.old <- future::plan("list")
[15:31:14.869]                   options(future.plan = NULL)
[15:31:14.869]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:14.869]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:14.869]                 }
[15:31:14.869]                 ...future.workdir <- getwd()
[15:31:14.869]             }
[15:31:14.869]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:14.869]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:14.869]         }
[15:31:14.869]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:14.869]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:31:14.869]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:14.869]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:14.869]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:14.869]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:14.869]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:14.869]             base::names(...future.oldOptions))
[15:31:14.869]     }
[15:31:14.869]     if (FALSE) {
[15:31:14.869]     }
[15:31:14.869]     else {
[15:31:14.869]         if (TRUE) {
[15:31:14.869]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:14.869]                 open = "w")
[15:31:14.869]         }
[15:31:14.869]         else {
[15:31:14.869]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:14.869]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:14.869]         }
[15:31:14.869]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:14.869]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:14.869]             base::sink(type = "output", split = FALSE)
[15:31:14.869]             base::close(...future.stdout)
[15:31:14.869]         }, add = TRUE)
[15:31:14.869]     }
[15:31:14.869]     ...future.frame <- base::sys.nframe()
[15:31:14.869]     ...future.conditions <- base::list()
[15:31:14.869]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:14.869]     if (FALSE) {
[15:31:14.869]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:14.869]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:14.869]     }
[15:31:14.869]     ...future.result <- base::tryCatch({
[15:31:14.869]         base::withCallingHandlers({
[15:31:14.869]             ...future.value <- base::withVisible(base::local({
[15:31:14.869]                 do.call(function(...) {
[15:31:14.869]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:14.869]                   if (!identical(...future.globals.maxSize.org, 
[15:31:14.869]                     ...future.globals.maxSize)) {
[15:31:14.869]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:14.869]                     on.exit(options(oopts), add = TRUE)
[15:31:14.869]                   }
[15:31:14.869]                   {
[15:31:14.869]                     lapply(seq_along(...future.elements_ii), 
[15:31:14.869]                       FUN = function(jj) {
[15:31:14.869]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:14.869]                         ...future.FUN(...future.X_jj, ...)
[15:31:14.869]                       })
[15:31:14.869]                   }
[15:31:14.869]                 }, args = future.call.arguments)
[15:31:14.869]             }))
[15:31:14.869]             future::FutureResult(value = ...future.value$value, 
[15:31:14.869]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:14.869]                   ...future.rng), globalenv = if (FALSE) 
[15:31:14.869]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:14.869]                     ...future.globalenv.names))
[15:31:14.869]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:14.869]         }, condition = base::local({
[15:31:14.869]             c <- base::c
[15:31:14.869]             inherits <- base::inherits
[15:31:14.869]             invokeRestart <- base::invokeRestart
[15:31:14.869]             length <- base::length
[15:31:14.869]             list <- base::list
[15:31:14.869]             seq.int <- base::seq.int
[15:31:14.869]             signalCondition <- base::signalCondition
[15:31:14.869]             sys.calls <- base::sys.calls
[15:31:14.869]             `[[` <- base::`[[`
[15:31:14.869]             `+` <- base::`+`
[15:31:14.869]             `<<-` <- base::`<<-`
[15:31:14.869]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:14.869]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:14.869]                   3L)]
[15:31:14.869]             }
[15:31:14.869]             function(cond) {
[15:31:14.869]                 is_error <- inherits(cond, "error")
[15:31:14.869]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:14.869]                   NULL)
[15:31:14.869]                 if (is_error) {
[15:31:14.869]                   sessionInformation <- function() {
[15:31:14.869]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:14.869]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:14.869]                       search = base::search(), system = base::Sys.info())
[15:31:14.869]                   }
[15:31:14.869]                   ...future.conditions[[length(...future.conditions) + 
[15:31:14.869]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:14.869]                     cond$call), session = sessionInformation(), 
[15:31:14.869]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:14.869]                   signalCondition(cond)
[15:31:14.869]                 }
[15:31:14.869]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:14.869]                 "immediateCondition"))) {
[15:31:14.869]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:14.869]                   ...future.conditions[[length(...future.conditions) + 
[15:31:14.869]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:14.869]                   if (TRUE && !signal) {
[15:31:14.869]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:14.869]                     {
[15:31:14.869]                       inherits <- base::inherits
[15:31:14.869]                       invokeRestart <- base::invokeRestart
[15:31:14.869]                       is.null <- base::is.null
[15:31:14.869]                       muffled <- FALSE
[15:31:14.869]                       if (inherits(cond, "message")) {
[15:31:14.869]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:14.869]                         if (muffled) 
[15:31:14.869]                           invokeRestart("muffleMessage")
[15:31:14.869]                       }
[15:31:14.869]                       else if (inherits(cond, "warning")) {
[15:31:14.869]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:14.869]                         if (muffled) 
[15:31:14.869]                           invokeRestart("muffleWarning")
[15:31:14.869]                       }
[15:31:14.869]                       else if (inherits(cond, "condition")) {
[15:31:14.869]                         if (!is.null(pattern)) {
[15:31:14.869]                           computeRestarts <- base::computeRestarts
[15:31:14.869]                           grepl <- base::grepl
[15:31:14.869]                           restarts <- computeRestarts(cond)
[15:31:14.869]                           for (restart in restarts) {
[15:31:14.869]                             name <- restart$name
[15:31:14.869]                             if (is.null(name)) 
[15:31:14.869]                               next
[15:31:14.869]                             if (!grepl(pattern, name)) 
[15:31:14.869]                               next
[15:31:14.869]                             invokeRestart(restart)
[15:31:14.869]                             muffled <- TRUE
[15:31:14.869]                             break
[15:31:14.869]                           }
[15:31:14.869]                         }
[15:31:14.869]                       }
[15:31:14.869]                       invisible(muffled)
[15:31:14.869]                     }
[15:31:14.869]                     muffleCondition(cond, pattern = "^muffle")
[15:31:14.869]                   }
[15:31:14.869]                 }
[15:31:14.869]                 else {
[15:31:14.869]                   if (TRUE) {
[15:31:14.869]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:14.869]                     {
[15:31:14.869]                       inherits <- base::inherits
[15:31:14.869]                       invokeRestart <- base::invokeRestart
[15:31:14.869]                       is.null <- base::is.null
[15:31:14.869]                       muffled <- FALSE
[15:31:14.869]                       if (inherits(cond, "message")) {
[15:31:14.869]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:14.869]                         if (muffled) 
[15:31:14.869]                           invokeRestart("muffleMessage")
[15:31:14.869]                       }
[15:31:14.869]                       else if (inherits(cond, "warning")) {
[15:31:14.869]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:14.869]                         if (muffled) 
[15:31:14.869]                           invokeRestart("muffleWarning")
[15:31:14.869]                       }
[15:31:14.869]                       else if (inherits(cond, "condition")) {
[15:31:14.869]                         if (!is.null(pattern)) {
[15:31:14.869]                           computeRestarts <- base::computeRestarts
[15:31:14.869]                           grepl <- base::grepl
[15:31:14.869]                           restarts <- computeRestarts(cond)
[15:31:14.869]                           for (restart in restarts) {
[15:31:14.869]                             name <- restart$name
[15:31:14.869]                             if (is.null(name)) 
[15:31:14.869]                               next
[15:31:14.869]                             if (!grepl(pattern, name)) 
[15:31:14.869]                               next
[15:31:14.869]                             invokeRestart(restart)
[15:31:14.869]                             muffled <- TRUE
[15:31:14.869]                             break
[15:31:14.869]                           }
[15:31:14.869]                         }
[15:31:14.869]                       }
[15:31:14.869]                       invisible(muffled)
[15:31:14.869]                     }
[15:31:14.869]                     muffleCondition(cond, pattern = "^muffle")
[15:31:14.869]                   }
[15:31:14.869]                 }
[15:31:14.869]             }
[15:31:14.869]         }))
[15:31:14.869]     }, error = function(ex) {
[15:31:14.869]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:14.869]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:14.869]                 ...future.rng), started = ...future.startTime, 
[15:31:14.869]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:14.869]             version = "1.8"), class = "FutureResult")
[15:31:14.869]     }, finally = {
[15:31:14.869]         if (!identical(...future.workdir, getwd())) 
[15:31:14.869]             setwd(...future.workdir)
[15:31:14.869]         {
[15:31:14.869]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:14.869]                 ...future.oldOptions$nwarnings <- NULL
[15:31:14.869]             }
[15:31:14.869]             base::options(...future.oldOptions)
[15:31:14.869]             if (.Platform$OS.type == "windows") {
[15:31:14.869]                 old_names <- names(...future.oldEnvVars)
[15:31:14.869]                 envs <- base::Sys.getenv()
[15:31:14.869]                 names <- names(envs)
[15:31:14.869]                 common <- intersect(names, old_names)
[15:31:14.869]                 added <- setdiff(names, old_names)
[15:31:14.869]                 removed <- setdiff(old_names, names)
[15:31:14.869]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:14.869]                   envs[common]]
[15:31:14.869]                 NAMES <- toupper(changed)
[15:31:14.869]                 args <- list()
[15:31:14.869]                 for (kk in seq_along(NAMES)) {
[15:31:14.869]                   name <- changed[[kk]]
[15:31:14.869]                   NAME <- NAMES[[kk]]
[15:31:14.869]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:14.869]                     next
[15:31:14.869]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:14.869]                 }
[15:31:14.869]                 NAMES <- toupper(added)
[15:31:14.869]                 for (kk in seq_along(NAMES)) {
[15:31:14.869]                   name <- added[[kk]]
[15:31:14.869]                   NAME <- NAMES[[kk]]
[15:31:14.869]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:14.869]                     next
[15:31:14.869]                   args[[name]] <- ""
[15:31:14.869]                 }
[15:31:14.869]                 NAMES <- toupper(removed)
[15:31:14.869]                 for (kk in seq_along(NAMES)) {
[15:31:14.869]                   name <- removed[[kk]]
[15:31:14.869]                   NAME <- NAMES[[kk]]
[15:31:14.869]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:14.869]                     next
[15:31:14.869]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:14.869]                 }
[15:31:14.869]                 if (length(args) > 0) 
[15:31:14.869]                   base::do.call(base::Sys.setenv, args = args)
[15:31:14.869]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:14.869]             }
[15:31:14.869]             else {
[15:31:14.869]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:14.869]             }
[15:31:14.869]             {
[15:31:14.869]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:14.869]                   0L) {
[15:31:14.869]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:14.869]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:14.869]                   base::options(opts)
[15:31:14.869]                 }
[15:31:14.869]                 {
[15:31:14.869]                   {
[15:31:14.869]                     NULL
[15:31:14.869]                     RNGkind("Mersenne-Twister")
[15:31:14.869]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:31:14.869]                       inherits = FALSE)
[15:31:14.869]                   }
[15:31:14.869]                   options(future.plan = NULL)
[15:31:14.869]                   if (is.na(NA_character_)) 
[15:31:14.869]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:14.869]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:14.869]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:14.869]                     .init = FALSE)
[15:31:14.869]                 }
[15:31:14.869]             }
[15:31:14.869]         }
[15:31:14.869]     })
[15:31:14.869]     if (TRUE) {
[15:31:14.869]         base::sink(type = "output", split = FALSE)
[15:31:14.869]         if (TRUE) {
[15:31:14.869]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:14.869]         }
[15:31:14.869]         else {
[15:31:14.869]             ...future.result["stdout"] <- base::list(NULL)
[15:31:14.869]         }
[15:31:14.869]         base::close(...future.stdout)
[15:31:14.869]         ...future.stdout <- NULL
[15:31:14.869]     }
[15:31:14.869]     ...future.result$conditions <- ...future.conditions
[15:31:14.869]     ...future.result$finished <- base::Sys.time()
[15:31:14.869]     ...future.result
[15:31:14.869] }
[15:31:14.876] assign_globals() ...
[15:31:14.876] List of 5
[15:31:14.876]  $ ...future.FUN            :function (x, ...)  
[15:31:14.876]  $ future.call.arguments    :List of 1
[15:31:14.876]   ..$ probs: num [1:3] 0.25 0.5 0.75
[15:31:14.876]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:14.876]  $ ...future.elements_ii    :List of 3
[15:31:14.876]   ..$ logic: logi [1:4] TRUE FALSE FALSE TRUE
[15:31:14.876]   ..$ beta : num [1:7] 0.0498 0.1353 0.3679 1 2.7183 ...
[15:31:14.876]   ..$ a    : int [1:10] 1 2 3 4 5 6 7 8 9 10
[15:31:14.876]  $ ...future.seeds_ii       : NULL
[15:31:14.876]  $ ...future.globals.maxSize: NULL
[15:31:14.876]  - attr(*, "where")=List of 5
[15:31:14.876]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:31:14.876]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:31:14.876]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:31:14.876]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:31:14.876]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:31:14.876]  - attr(*, "resolved")= logi FALSE
[15:31:14.876]  - attr(*, "total_size")= num 1328
[15:31:14.876]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:14.876]  - attr(*, "already-done")= logi TRUE
[15:31:14.890] - copied '...future.FUN' to environment
[15:31:14.890] - copied 'future.call.arguments' to environment
[15:31:14.890] - copied '...future.elements_ii' to environment
[15:31:14.891] - copied '...future.seeds_ii' to environment
[15:31:14.891] - copied '...future.globals.maxSize' to environment
[15:31:14.891] assign_globals() ... done
[15:31:14.892] plan(): Setting new future strategy stack:
[15:31:14.892] List of future strategies:
[15:31:14.892] 1. sequential:
[15:31:14.892]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:14.892]    - tweaked: FALSE
[15:31:14.892]    - call: NULL
[15:31:14.893] plan(): nbrOfWorkers() = 1
[15:31:14.896] plan(): Setting new future strategy stack:
[15:31:14.896] List of future strategies:
[15:31:14.896] 1. sequential:
[15:31:14.896]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:14.896]    - tweaked: FALSE
[15:31:14.896]    - call: plan(strategy)
[15:31:14.897] plan(): nbrOfWorkers() = 1
[15:31:14.898] SequentialFuture started (and completed)
[15:31:14.898] - Launch lazy future ... done
[15:31:14.898] run() for 'SequentialFuture' ... done
[15:31:14.899] Created future:
[15:31:14.899] SequentialFuture:
[15:31:14.899] Label: 'future_eapply-1'
[15:31:14.899] Expression:
[15:31:14.899] {
[15:31:14.899]     do.call(function(...) {
[15:31:14.899]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:14.899]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:14.899]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:14.899]             on.exit(options(oopts), add = TRUE)
[15:31:14.899]         }
[15:31:14.899]         {
[15:31:14.899]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:14.899]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:14.899]                 ...future.FUN(...future.X_jj, ...)
[15:31:14.899]             })
[15:31:14.899]         }
[15:31:14.899]     }, args = future.call.arguments)
[15:31:14.899] }
[15:31:14.899] Lazy evaluation: FALSE
[15:31:14.899] Asynchronous evaluation: FALSE
[15:31:14.899] Local evaluation: TRUE
[15:31:14.899] Environment: R_GlobalEnv
[15:31:14.899] Capture standard output: TRUE
[15:31:14.899] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:14.899] Globals: 5 objects totaling 1.56 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 80 bytes, list '...future.elements_ii' of 272 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:31:14.899] Packages: 1 packages ('stats')
[15:31:14.899] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:14.899] Resolved: TRUE
[15:31:14.899] Value: 1.29 KiB of class 'list'
[15:31:14.899] Early signaling: FALSE
[15:31:14.899] Owner process: 1f501b3c-5bdf-35ad-4a62-196ce98a2fc6
[15:31:14.899] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:14.901] Chunk #1 of 1 ... DONE
[15:31:14.902] Launching 1 futures (chunks) ... DONE
[15:31:14.902] Resolving 1 futures (chunks) ...
[15:31:14.902] resolve() on list ...
[15:31:14.903]  recursive: 0
[15:31:14.903]  length: 1
[15:31:14.903] 
[15:31:14.904] resolved() for 'SequentialFuture' ...
[15:31:14.904] - state: 'finished'
[15:31:14.904] - run: TRUE
[15:31:14.905] - result: 'FutureResult'
[15:31:14.905] resolved() for 'SequentialFuture' ... done
[15:31:14.905] Future #1
[15:31:14.906] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:31:14.906] - nx: 1
[15:31:14.906] - relay: TRUE
[15:31:14.906] - stdout: TRUE
[15:31:14.907] - signal: TRUE
[15:31:14.907] - resignal: FALSE
[15:31:14.907] - force: TRUE
[15:31:14.907] - relayed: [n=1] FALSE
[15:31:14.908] - queued futures: [n=1] FALSE
[15:31:14.908]  - until=1
[15:31:14.908]  - relaying element #1
[15:31:14.909] - relayed: [n=1] TRUE
[15:31:14.909] - queued futures: [n=1] TRUE
[15:31:14.909] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:31:14.909]  length: 0 (resolved future 1)
[15:31:14.910] Relaying remaining futures
[15:31:14.910] signalConditionsASAP(NULL, pos=0) ...
[15:31:14.910] - nx: 1
[15:31:14.910] - relay: TRUE
[15:31:14.911] - stdout: TRUE
[15:31:14.911] - signal: TRUE
[15:31:14.911] - resignal: FALSE
[15:31:14.911] - force: TRUE
[15:31:14.912] - relayed: [n=1] TRUE
[15:31:14.912] - queued futures: [n=1] TRUE
 - flush all
[15:31:14.912] - relayed: [n=1] TRUE
[15:31:14.913] - queued futures: [n=1] TRUE
[15:31:14.913] signalConditionsASAP(NULL, pos=0) ... done
[15:31:14.913] resolve() on list ... DONE
[15:31:14.914]  - Number of value chunks collected: 1
[15:31:14.914] Resolving 1 futures (chunks) ... DONE
[15:31:14.914] Reducing values from 1 chunks ...
[15:31:14.914]  - Number of values collected after concatenation: 3
[15:31:14.915]  - Number of values expected: 3
[15:31:14.915] Reducing values from 1 chunks ... DONE
[15:31:14.915] future_lapply() ... DONE
[15:31:14.918] future_lapply() ...
[15:31:14.919] Number of chunks: 1
[15:31:14.919] getGlobalsAndPackagesXApply() ...
[15:31:14.919]  - future.globals: TRUE
[15:31:14.919] getGlobalsAndPackages() ...
[15:31:14.920] Searching for globals...
[15:31:14.922] - globals found: [2] 'FUN', 'UseMethod'
[15:31:14.922] Searching for globals ... DONE
[15:31:14.922] Resolving globals: FALSE
[15:31:14.923] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:31:14.924] The total size of the 1 globals exported for future expression ('FUN()') 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:14.924] - globals: [1] 'FUN'
[15:31:14.925] - packages: [1] 'stats'
[15:31:14.925] getGlobalsAndPackages() ... DONE
[15:31:14.925]  - globals found/used: [n=1] 'FUN'
[15:31:14.925]  - needed namespaces: [n=1] 'stats'
[15:31:14.926] Finding globals ... DONE
[15:31:14.926]  - use_args: TRUE
[15:31:14.926]  - Getting '...' globals ...
[15:31:14.927] resolve() on list ...
[15:31:14.927]  recursive: 0
[15:31:14.927]  length: 1
[15:31:14.928]  elements: '...'
[15:31:14.928]  length: 0 (resolved future 1)
[15:31:14.928] resolve() on list ... DONE
[15:31:14.929]    - '...' content: [n=0] 
[15:31:14.929] List of 1
[15:31:14.929]  $ ...: list()
[15:31:14.929]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:14.929]  - attr(*, "where")=List of 1
[15:31:14.929]   ..$ ...:<environment: 0x000001b3f9a2c880> 
[15:31:14.929]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:14.929]  - attr(*, "resolved")= logi TRUE
[15:31:14.929]  - attr(*, "total_size")= num NA
[15:31:14.934]  - Getting '...' globals ... DONE
[15:31:14.937] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:14.937] List of 2
[15:31:14.937]  $ ...future.FUN:function (x, ...)  
[15:31:14.937]  $ ...          : list()
[15:31:14.937]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:14.937]  - attr(*, "where")=List of 2
[15:31:14.937]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:14.937]   ..$ ...          :<environment: 0x000001b3f9a2c880> 
[15:31:14.937]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:14.937]  - attr(*, "resolved")= logi FALSE
[15:31:14.937]  - attr(*, "total_size")= num 1248
[15:31:14.942] Packages to be attached in all futures: [n=1] 'stats'
[15:31:14.943] getGlobalsAndPackagesXApply() ... DONE
[15:31:14.943] Number of futures (= number of chunks): 1
[15:31:14.944] Launching 1 futures (chunks) ...
[15:31:14.944] Chunk #1 of 1 ...
[15:31:14.944]  - Finding globals in 'X' for chunk #1 ...
[15:31:14.944] getGlobalsAndPackages() ...
[15:31:14.945] Searching for globals...
[15:31:14.945] 
[15:31:14.946] Searching for globals ... DONE
[15:31:14.946] - globals: [0] <none>
[15:31:14.946] getGlobalsAndPackages() ... DONE
[15:31:14.946]    + additional globals found: [n=0] 
[15:31:14.947]    + additional namespaces needed: [n=0] 
[15:31:14.947]  - Finding globals in 'X' for chunk #1 ... DONE
[15:31:14.947]  - seeds: <none>
[15:31:14.947]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:14.948] getGlobalsAndPackages() ...
[15:31:14.948] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:14.948] Resolving globals: FALSE
[15:31:14.949] Tweak future expression to call with '...' arguments ...
[15:31:14.949] {
[15:31:14.949]     do.call(function(...) {
[15:31:14.949]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:14.949]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:14.949]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:14.949]             on.exit(options(oopts), add = TRUE)
[15:31:14.949]         }
[15:31:14.949]         {
[15:31:14.949]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:14.949]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:14.949]                 ...future.FUN(...future.X_jj, ...)
[15:31:14.949]             })
[15:31:14.949]         }
[15:31:14.949]     }, args = future.call.arguments)
[15:31:14.949] }
[15:31:14.950] Tweak future expression to call with '...' arguments ... DONE
[15:31:14.950] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:14.951] - packages: [1] 'stats'
[15:31:14.951] getGlobalsAndPackages() ... DONE
[15:31:14.952] run() for 'Future' ...
[15:31:14.952] - state: 'created'
[15:31:14.952] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:31:14.953] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:14.953] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:31:14.954]   - Field: 'label'
[15:31:14.954]   - Field: 'local'
[15:31:14.954]   - Field: 'owner'
[15:31:14.955]   - Field: 'envir'
[15:31:14.955]   - Field: 'packages'
[15:31:14.955]   - Field: 'gc'
[15:31:14.955]   - Field: 'conditions'
[15:31:14.956]   - Field: 'expr'
[15:31:14.956]   - Field: 'uuid'
[15:31:14.956]   - Field: 'seed'
[15:31:14.957]   - Field: 'version'
[15:31:14.957]   - Field: 'result'
[15:31:14.957]   - Field: 'asynchronous'
[15:31:14.957]   - Field: 'calls'
[15:31:14.958]   - Field: 'globals'
[15:31:14.958]   - Field: 'stdout'
[15:31:14.958]   - Field: 'earlySignal'
[15:31:14.959]   - Field: 'lazy'
[15:31:14.959]   - Field: 'state'
[15:31:14.959] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:31:14.960] - Launch lazy future ...
[15:31:14.960] Packages needed by the future expression (n = 1): 'stats'
[15:31:14.960] Packages needed by future strategies (n = 0): <none>
[15:31:14.961] {
[15:31:14.961]     {
[15:31:14.961]         {
[15:31:14.961]             ...future.startTime <- base::Sys.time()
[15:31:14.961]             {
[15:31:14.961]                 {
[15:31:14.961]                   {
[15:31:14.961]                     {
[15:31:14.961]                       base::local({
[15:31:14.961]                         has_future <- base::requireNamespace("future", 
[15:31:14.961]                           quietly = TRUE)
[15:31:14.961]                         if (has_future) {
[15:31:14.961]                           ns <- base::getNamespace("future")
[15:31:14.961]                           version <- ns[[".package"]][["version"]]
[15:31:14.961]                           if (is.null(version)) 
[15:31:14.961]                             version <- utils::packageVersion("future")
[15:31:14.961]                         }
[15:31:14.961]                         else {
[15:31:14.961]                           version <- NULL
[15:31:14.961]                         }
[15:31:14.961]                         if (!has_future || version < "1.8.0") {
[15:31:14.961]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:14.961]                             "", base::R.version$version.string), 
[15:31:14.961]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:14.961]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:14.961]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:14.961]                               "release", "version")], collapse = " "), 
[15:31:14.961]                             hostname = base::Sys.info()[["nodename"]])
[15:31:14.961]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:14.961]                             info)
[15:31:14.961]                           info <- base::paste(info, collapse = "; ")
[15:31:14.961]                           if (!has_future) {
[15:31:14.961]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:14.961]                               info)
[15:31:14.961]                           }
[15:31:14.961]                           else {
[15:31:14.961]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:14.961]                               info, version)
[15:31:14.961]                           }
[15:31:14.961]                           base::stop(msg)
[15:31:14.961]                         }
[15:31:14.961]                       })
[15:31:14.961]                     }
[15:31:14.961]                     base::local({
[15:31:14.961]                       for (pkg in "stats") {
[15:31:14.961]                         base::loadNamespace(pkg)
[15:31:14.961]                         base::library(pkg, character.only = TRUE)
[15:31:14.961]                       }
[15:31:14.961]                     })
[15:31:14.961]                   }
[15:31:14.961]                   ...future.strategy.old <- future::plan("list")
[15:31:14.961]                   options(future.plan = NULL)
[15:31:14.961]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:14.961]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:14.961]                 }
[15:31:14.961]                 ...future.workdir <- getwd()
[15:31:14.961]             }
[15:31:14.961]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:14.961]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:14.961]         }
[15:31:14.961]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:14.961]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:31:14.961]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:14.961]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:14.961]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:14.961]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:14.961]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:14.961]             base::names(...future.oldOptions))
[15:31:14.961]     }
[15:31:14.961]     if (FALSE) {
[15:31:14.961]     }
[15:31:14.961]     else {
[15:31:14.961]         if (TRUE) {
[15:31:14.961]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:14.961]                 open = "w")
[15:31:14.961]         }
[15:31:14.961]         else {
[15:31:14.961]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:14.961]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:14.961]         }
[15:31:14.961]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:14.961]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:14.961]             base::sink(type = "output", split = FALSE)
[15:31:14.961]             base::close(...future.stdout)
[15:31:14.961]         }, add = TRUE)
[15:31:14.961]     }
[15:31:14.961]     ...future.frame <- base::sys.nframe()
[15:31:14.961]     ...future.conditions <- base::list()
[15:31:14.961]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:14.961]     if (FALSE) {
[15:31:14.961]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:14.961]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:14.961]     }
[15:31:14.961]     ...future.result <- base::tryCatch({
[15:31:14.961]         base::withCallingHandlers({
[15:31:14.961]             ...future.value <- base::withVisible(base::local({
[15:31:14.961]                 do.call(function(...) {
[15:31:14.961]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:14.961]                   if (!identical(...future.globals.maxSize.org, 
[15:31:14.961]                     ...future.globals.maxSize)) {
[15:31:14.961]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:14.961]                     on.exit(options(oopts), add = TRUE)
[15:31:14.961]                   }
[15:31:14.961]                   {
[15:31:14.961]                     lapply(seq_along(...future.elements_ii), 
[15:31:14.961]                       FUN = function(jj) {
[15:31:14.961]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:14.961]                         ...future.FUN(...future.X_jj, ...)
[15:31:14.961]                       })
[15:31:14.961]                   }
[15:31:14.961]                 }, args = future.call.arguments)
[15:31:14.961]             }))
[15:31:14.961]             future::FutureResult(value = ...future.value$value, 
[15:31:14.961]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:14.961]                   ...future.rng), globalenv = if (FALSE) 
[15:31:14.961]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:14.961]                     ...future.globalenv.names))
[15:31:14.961]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:14.961]         }, condition = base::local({
[15:31:14.961]             c <- base::c
[15:31:14.961]             inherits <- base::inherits
[15:31:14.961]             invokeRestart <- base::invokeRestart
[15:31:14.961]             length <- base::length
[15:31:14.961]             list <- base::list
[15:31:14.961]             seq.int <- base::seq.int
[15:31:14.961]             signalCondition <- base::signalCondition
[15:31:14.961]             sys.calls <- base::sys.calls
[15:31:14.961]             `[[` <- base::`[[`
[15:31:14.961]             `+` <- base::`+`
[15:31:14.961]             `<<-` <- base::`<<-`
[15:31:14.961]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:14.961]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:14.961]                   3L)]
[15:31:14.961]             }
[15:31:14.961]             function(cond) {
[15:31:14.961]                 is_error <- inherits(cond, "error")
[15:31:14.961]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:14.961]                   NULL)
[15:31:14.961]                 if (is_error) {
[15:31:14.961]                   sessionInformation <- function() {
[15:31:14.961]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:14.961]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:14.961]                       search = base::search(), system = base::Sys.info())
[15:31:14.961]                   }
[15:31:14.961]                   ...future.conditions[[length(...future.conditions) + 
[15:31:14.961]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:14.961]                     cond$call), session = sessionInformation(), 
[15:31:14.961]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:14.961]                   signalCondition(cond)
[15:31:14.961]                 }
[15:31:14.961]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:14.961]                 "immediateCondition"))) {
[15:31:14.961]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:14.961]                   ...future.conditions[[length(...future.conditions) + 
[15:31:14.961]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:14.961]                   if (TRUE && !signal) {
[15:31:14.961]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:14.961]                     {
[15:31:14.961]                       inherits <- base::inherits
[15:31:14.961]                       invokeRestart <- base::invokeRestart
[15:31:14.961]                       is.null <- base::is.null
[15:31:14.961]                       muffled <- FALSE
[15:31:14.961]                       if (inherits(cond, "message")) {
[15:31:14.961]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:14.961]                         if (muffled) 
[15:31:14.961]                           invokeRestart("muffleMessage")
[15:31:14.961]                       }
[15:31:14.961]                       else if (inherits(cond, "warning")) {
[15:31:14.961]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:14.961]                         if (muffled) 
[15:31:14.961]                           invokeRestart("muffleWarning")
[15:31:14.961]                       }
[15:31:14.961]                       else if (inherits(cond, "condition")) {
[15:31:14.961]                         if (!is.null(pattern)) {
[15:31:14.961]                           computeRestarts <- base::computeRestarts
[15:31:14.961]                           grepl <- base::grepl
[15:31:14.961]                           restarts <- computeRestarts(cond)
[15:31:14.961]                           for (restart in restarts) {
[15:31:14.961]                             name <- restart$name
[15:31:14.961]                             if (is.null(name)) 
[15:31:14.961]                               next
[15:31:14.961]                             if (!grepl(pattern, name)) 
[15:31:14.961]                               next
[15:31:14.961]                             invokeRestart(restart)
[15:31:14.961]                             muffled <- TRUE
[15:31:14.961]                             break
[15:31:14.961]                           }
[15:31:14.961]                         }
[15:31:14.961]                       }
[15:31:14.961]                       invisible(muffled)
[15:31:14.961]                     }
[15:31:14.961]                     muffleCondition(cond, pattern = "^muffle")
[15:31:14.961]                   }
[15:31:14.961]                 }
[15:31:14.961]                 else {
[15:31:14.961]                   if (TRUE) {
[15:31:14.961]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:14.961]                     {
[15:31:14.961]                       inherits <- base::inherits
[15:31:14.961]                       invokeRestart <- base::invokeRestart
[15:31:14.961]                       is.null <- base::is.null
[15:31:14.961]                       muffled <- FALSE
[15:31:14.961]                       if (inherits(cond, "message")) {
[15:31:14.961]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:14.961]                         if (muffled) 
[15:31:14.961]                           invokeRestart("muffleMessage")
[15:31:14.961]                       }
[15:31:14.961]                       else if (inherits(cond, "warning")) {
[15:31:14.961]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:14.961]                         if (muffled) 
[15:31:14.961]                           invokeRestart("muffleWarning")
[15:31:14.961]                       }
[15:31:14.961]                       else if (inherits(cond, "condition")) {
[15:31:14.961]                         if (!is.null(pattern)) {
[15:31:14.961]                           computeRestarts <- base::computeRestarts
[15:31:14.961]                           grepl <- base::grepl
[15:31:14.961]                           restarts <- computeRestarts(cond)
[15:31:14.961]                           for (restart in restarts) {
[15:31:14.961]                             name <- restart$name
[15:31:14.961]                             if (is.null(name)) 
[15:31:14.961]                               next
[15:31:14.961]                             if (!grepl(pattern, name)) 
[15:31:14.961]                               next
[15:31:14.961]                             invokeRestart(restart)
[15:31:14.961]                             muffled <- TRUE
[15:31:14.961]                             break
[15:31:14.961]                           }
[15:31:14.961]                         }
[15:31:14.961]                       }
[15:31:14.961]                       invisible(muffled)
[15:31:14.961]                     }
[15:31:14.961]                     muffleCondition(cond, pattern = "^muffle")
[15:31:14.961]                   }
[15:31:14.961]                 }
[15:31:14.961]             }
[15:31:14.961]         }))
[15:31:14.961]     }, error = function(ex) {
[15:31:14.961]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:14.961]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:14.961]                 ...future.rng), started = ...future.startTime, 
[15:31:14.961]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:14.961]             version = "1.8"), class = "FutureResult")
[15:31:14.961]     }, finally = {
[15:31:14.961]         if (!identical(...future.workdir, getwd())) 
[15:31:14.961]             setwd(...future.workdir)
[15:31:14.961]         {
[15:31:14.961]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:14.961]                 ...future.oldOptions$nwarnings <- NULL
[15:31:14.961]             }
[15:31:14.961]             base::options(...future.oldOptions)
[15:31:14.961]             if (.Platform$OS.type == "windows") {
[15:31:14.961]                 old_names <- names(...future.oldEnvVars)
[15:31:14.961]                 envs <- base::Sys.getenv()
[15:31:14.961]                 names <- names(envs)
[15:31:14.961]                 common <- intersect(names, old_names)
[15:31:14.961]                 added <- setdiff(names, old_names)
[15:31:14.961]                 removed <- setdiff(old_names, names)
[15:31:14.961]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:14.961]                   envs[common]]
[15:31:14.961]                 NAMES <- toupper(changed)
[15:31:14.961]                 args <- list()
[15:31:14.961]                 for (kk in seq_along(NAMES)) {
[15:31:14.961]                   name <- changed[[kk]]
[15:31:14.961]                   NAME <- NAMES[[kk]]
[15:31:14.961]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:14.961]                     next
[15:31:14.961]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:14.961]                 }
[15:31:14.961]                 NAMES <- toupper(added)
[15:31:14.961]                 for (kk in seq_along(NAMES)) {
[15:31:14.961]                   name <- added[[kk]]
[15:31:14.961]                   NAME <- NAMES[[kk]]
[15:31:14.961]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:14.961]                     next
[15:31:14.961]                   args[[name]] <- ""
[15:31:14.961]                 }
[15:31:14.961]                 NAMES <- toupper(removed)
[15:31:14.961]                 for (kk in seq_along(NAMES)) {
[15:31:14.961]                   name <- removed[[kk]]
[15:31:14.961]                   NAME <- NAMES[[kk]]
[15:31:14.961]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:14.961]                     next
[15:31:14.961]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:14.961]                 }
[15:31:14.961]                 if (length(args) > 0) 
[15:31:14.961]                   base::do.call(base::Sys.setenv, args = args)
[15:31:14.961]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:14.961]             }
[15:31:14.961]             else {
[15:31:14.961]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:14.961]             }
[15:31:14.961]             {
[15:31:14.961]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:14.961]                   0L) {
[15:31:14.961]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:14.961]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:14.961]                   base::options(opts)
[15:31:14.961]                 }
[15:31:14.961]                 {
[15:31:14.961]                   {
[15:31:14.961]                     NULL
[15:31:14.961]                     RNGkind("Mersenne-Twister")
[15:31:14.961]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:31:14.961]                       inherits = FALSE)
[15:31:14.961]                   }
[15:31:14.961]                   options(future.plan = NULL)
[15:31:14.961]                   if (is.na(NA_character_)) 
[15:31:14.961]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:14.961]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:14.961]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:14.961]                     .init = FALSE)
[15:31:14.961]                 }
[15:31:14.961]             }
[15:31:14.961]         }
[15:31:14.961]     })
[15:31:14.961]     if (TRUE) {
[15:31:14.961]         base::sink(type = "output", split = FALSE)
[15:31:14.961]         if (TRUE) {
[15:31:14.961]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:14.961]         }
[15:31:14.961]         else {
[15:31:14.961]             ...future.result["stdout"] <- base::list(NULL)
[15:31:14.961]         }
[15:31:14.961]         base::close(...future.stdout)
[15:31:14.961]         ...future.stdout <- NULL
[15:31:14.961]     }
[15:31:14.961]     ...future.result$conditions <- ...future.conditions
[15:31:14.961]     ...future.result$finished <- base::Sys.time()
[15:31:14.961]     ...future.result
[15:31:14.961] }
[15:31:14.968] assign_globals() ...
[15:31:14.968] List of 5
[15:31:14.968]  $ ...future.FUN            :function (x, ...)  
[15:31:14.968]  $ future.call.arguments    : list()
[15:31:14.968]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:14.968]  $ ...future.elements_ii    :List of 3
[15:31:14.968]   ..$ logic: logi [1:4] TRUE FALSE FALSE TRUE
[15:31:14.968]   ..$ beta : num [1:7] 0.0498 0.1353 0.3679 1 2.7183 ...
[15:31:14.968]   ..$ a    : int [1:10] 1 2 3 4 5 6 7 8 9 10
[15:31:14.968]  $ ...future.seeds_ii       : NULL
[15:31:14.968]  $ ...future.globals.maxSize: NULL
[15:31:14.968]  - attr(*, "where")=List of 5
[15:31:14.968]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:31:14.968]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:31:14.968]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:31:14.968]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:31:14.968]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:31:14.968]  - attr(*, "resolved")= logi FALSE
[15:31:14.968]  - attr(*, "total_size")= num 1248
[15:31:14.968]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:14.968]  - attr(*, "already-done")= logi TRUE
[15:31:14.979] - copied '...future.FUN' to environment
[15:31:14.979] - copied 'future.call.arguments' to environment
[15:31:14.980] - copied '...future.elements_ii' to environment
[15:31:14.980] - copied '...future.seeds_ii' to environment
[15:31:14.980] - copied '...future.globals.maxSize' to environment
[15:31:14.980] assign_globals() ... done
[15:31:14.982] plan(): Setting new future strategy stack:
[15:31:14.982] List of future strategies:
[15:31:14.982] 1. sequential:
[15:31:14.982]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:14.982]    - tweaked: FALSE
[15:31:14.982]    - call: NULL
[15:31:14.985] plan(): nbrOfWorkers() = 1
[15:31:14.988] plan(): Setting new future strategy stack:
[15:31:14.989] List of future strategies:
[15:31:14.989] 1. sequential:
[15:31:14.989]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:14.989]    - tweaked: FALSE
[15:31:14.989]    - call: plan(strategy)
[15:31:14.990] plan(): nbrOfWorkers() = 1
[15:31:14.990] SequentialFuture started (and completed)
[15:31:14.990] - Launch lazy future ... done
[15:31:14.991] run() for 'SequentialFuture' ... done
[15:31:14.991] Created future:
[15:31:14.991] SequentialFuture:
[15:31:14.991] Label: 'future_eapply-1'
[15:31:14.991] Expression:
[15:31:14.991] {
[15:31:14.991]     do.call(function(...) {
[15:31:14.991]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:14.991]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:14.991]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:14.991]             on.exit(options(oopts), add = TRUE)
[15:31:14.991]         }
[15:31:14.991]         {
[15:31:14.991]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:14.991]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:14.991]                 ...future.FUN(...future.X_jj, ...)
[15:31:14.991]             })
[15:31:14.991]         }
[15:31:14.991]     }, args = future.call.arguments)
[15:31:14.991] }
[15:31:14.991] Lazy evaluation: FALSE
[15:31:14.991] Asynchronous evaluation: FALSE
[15:31:14.991] Local evaluation: TRUE
[15:31:14.991] Environment: R_GlobalEnv
[15:31:14.991] Capture standard output: TRUE
[15:31:14.991] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:14.991] Globals: 5 objects totaling 1.48 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 272 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:31:14.991] Packages: 1 packages ('stats')
[15:31:14.991] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:14.991] Resolved: TRUE
[15:31:14.991] Value: 1.71 KiB of class 'list'
[15:31:14.991] Early signaling: FALSE
[15:31:14.991] Owner process: 1f501b3c-5bdf-35ad-4a62-196ce98a2fc6
[15:31:14.991] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:14.993] Chunk #1 of 1 ... DONE
[15:31:14.994] Launching 1 futures (chunks) ... DONE
[15:31:14.994] Resolving 1 futures (chunks) ...
[15:31:14.994] resolve() on list ...
[15:31:14.994]  recursive: 0
[15:31:14.995]  length: 1
[15:31:14.995] 
[15:31:14.995] resolved() for 'SequentialFuture' ...
[15:31:14.996] - state: 'finished'
[15:31:14.996] - run: TRUE
[15:31:14.996] - result: 'FutureResult'
[15:31:14.997] resolved() for 'SequentialFuture' ... done
[15:31:14.997] Future #1
[15:31:14.997] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:31:14.998] - nx: 1
[15:31:14.998] - relay: TRUE
[15:31:14.998] - stdout: TRUE
[15:31:14.998] - signal: TRUE
[15:31:14.999] - resignal: FALSE
[15:31:14.999] - force: TRUE
[15:31:14.999] - relayed: [n=1] FALSE
[15:31:14.999] - queued futures: [n=1] FALSE
[15:31:15.000]  - until=1
[15:31:15.000]  - relaying element #1
[15:31:15.000] - relayed: [n=1] TRUE
[15:31:15.001] - queued futures: [n=1] TRUE
[15:31:15.001] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:31:15.001]  length: 0 (resolved future 1)
[15:31:15.002] Relaying remaining futures
[15:31:15.002] signalConditionsASAP(NULL, pos=0) ...
[15:31:15.002] - nx: 1
[15:31:15.002] - relay: TRUE
[15:31:15.003] - stdout: TRUE
[15:31:15.003] - signal: TRUE
[15:31:15.003] - resignal: FALSE
[15:31:15.003] - force: TRUE
[15:31:15.004] - relayed: [n=1] TRUE
[15:31:15.004] - queued futures: [n=1] TRUE
 - flush all
[15:31:15.004] - relayed: [n=1] TRUE
[15:31:15.004] - queued futures: [n=1] TRUE
[15:31:15.005] signalConditionsASAP(NULL, pos=0) ... done
[15:31:15.005] resolve() on list ... DONE
[15:31:15.005]  - Number of value chunks collected: 1
[15:31:15.006] Resolving 1 futures (chunks) ... DONE
[15:31:15.006] Reducing values from 1 chunks ...
[15:31:15.006]  - Number of values collected after concatenation: 3
[15:31:15.006]  - Number of values expected: 3
[15:31:15.007] Reducing values from 1 chunks ... DONE
[15:31:15.007] future_lapply() ... DONE
[15:31:15.008] future_lapply() ...
[15:31:15.009] Number of chunks: 1
[15:31:15.009] getGlobalsAndPackagesXApply() ...
[15:31:15.009]  - future.globals: TRUE
[15:31:15.010] getGlobalsAndPackages() ...
[15:31:15.010] Searching for globals...
[15:31:15.012] - globals found: [2] 'FUN', 'UseMethod'
[15:31:15.012] Searching for globals ... DONE
[15:31:15.013] Resolving globals: FALSE
[15:31:15.013] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:31:15.014] The total size of the 1 globals exported for future expression ('FUN()') 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:15.015] - globals: [1] 'FUN'
[15:31:15.015] - packages: [1] 'stats'
[15:31:15.015] getGlobalsAndPackages() ... DONE
[15:31:15.015]  - globals found/used: [n=1] 'FUN'
[15:31:15.016]  - needed namespaces: [n=1] 'stats'
[15:31:15.016] Finding globals ... DONE
[15:31:15.016]  - use_args: TRUE
[15:31:15.017]  - Getting '...' globals ...
[15:31:15.017] resolve() on list ...
[15:31:15.018]  recursive: 0
[15:31:15.018]  length: 1
[15:31:15.018]  elements: '...'
[15:31:15.018]  length: 0 (resolved future 1)
[15:31:15.019] resolve() on list ... DONE
[15:31:15.019]    - '...' content: [n=0] 
[15:31:15.019] List of 1
[15:31:15.019]  $ ...: list()
[15:31:15.019]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:15.019]  - attr(*, "where")=List of 1
[15:31:15.019]   ..$ ...:<environment: 0x000001b3f9899958> 
[15:31:15.019]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:15.019]  - attr(*, "resolved")= logi TRUE
[15:31:15.019]  - attr(*, "total_size")= num NA
[15:31:15.024]  - Getting '...' globals ... DONE
[15:31:15.025] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:15.025] List of 2
[15:31:15.025]  $ ...future.FUN:function (x, ...)  
[15:31:15.025]  $ ...          : list()
[15:31:15.025]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:15.025]  - attr(*, "where")=List of 2
[15:31:15.025]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:15.025]   ..$ ...          :<environment: 0x000001b3f9899958> 
[15:31:15.025]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:15.025]  - attr(*, "resolved")= logi FALSE
[15:31:15.025]  - attr(*, "total_size")= num 1248
[15:31:15.033] Packages to be attached in all futures: [n=1] 'stats'
[15:31:15.033] getGlobalsAndPackagesXApply() ... DONE
[15:31:15.034] Number of futures (= number of chunks): 1
[15:31:15.034] Launching 1 futures (chunks) ...
[15:31:15.034] Chunk #1 of 1 ...
[15:31:15.035]  - Finding globals in 'X' for chunk #1 ...
[15:31:15.035] getGlobalsAndPackages() ...
[15:31:15.035] Searching for globals...
[15:31:15.036] 
[15:31:15.036] Searching for globals ... DONE
[15:31:15.036] - globals: [0] <none>
[15:31:15.037] getGlobalsAndPackages() ... DONE
[15:31:15.037]    + additional globals found: [n=0] 
[15:31:15.037]    + additional namespaces needed: [n=0] 
[15:31:15.037]  - Finding globals in 'X' for chunk #1 ... DONE
[15:31:15.038]  - seeds: <none>
[15:31:15.038]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:15.038] getGlobalsAndPackages() ...
[15:31:15.039] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:15.039] Resolving globals: FALSE
[15:31:15.039] Tweak future expression to call with '...' arguments ...
[15:31:15.039] {
[15:31:15.039]     do.call(function(...) {
[15:31:15.039]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:15.039]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:15.039]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:15.039]             on.exit(options(oopts), add = TRUE)
[15:31:15.039]         }
[15:31:15.039]         {
[15:31:15.039]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:15.039]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:15.039]                 ...future.FUN(...future.X_jj, ...)
[15:31:15.039]             })
[15:31:15.039]         }
[15:31:15.039]     }, args = future.call.arguments)
[15:31:15.039] }
[15:31:15.040] Tweak future expression to call with '...' arguments ... DONE
[15:31:15.041] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:15.042] - packages: [1] 'stats'
[15:31:15.042] getGlobalsAndPackages() ... DONE
[15:31:15.042] run() for 'Future' ...
[15:31:15.043] - state: 'created'
[15:31:15.043] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[15:31:15.044] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:15.044] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[15:31:15.044]   - Field: 'label'
[15:31:15.045]   - Field: 'local'
[15:31:15.045]   - Field: 'owner'
[15:31:15.045]   - Field: 'envir'
[15:31:15.046]   - Field: 'packages'
[15:31:15.046]   - Field: 'gc'
[15:31:15.046]   - Field: 'conditions'
[15:31:15.046]   - Field: 'expr'
[15:31:15.047]   - Field: 'uuid'
[15:31:15.047]   - Field: 'seed'
[15:31:15.047]   - Field: 'version'
[15:31:15.048]   - Field: 'result'
[15:31:15.048]   - Field: 'asynchronous'
[15:31:15.048]   - Field: 'calls'
[15:31:15.049]   - Field: 'globals'
[15:31:15.049]   - Field: 'stdout'
[15:31:15.049]   - Field: 'earlySignal'
[15:31:15.049]   - Field: 'lazy'
[15:31:15.050]   - Field: 'state'
[15:31:15.050] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[15:31:15.050] - Launch lazy future ...
[15:31:15.051] Packages needed by the future expression (n = 1): 'stats'
[15:31:15.051] Packages needed by future strategies (n = 0): <none>
[15:31:15.052] {
[15:31:15.052]     {
[15:31:15.052]         {
[15:31:15.052]             ...future.startTime <- base::Sys.time()
[15:31:15.052]             {
[15:31:15.052]                 {
[15:31:15.052]                   {
[15:31:15.052]                     {
[15:31:15.052]                       base::local({
[15:31:15.052]                         has_future <- base::requireNamespace("future", 
[15:31:15.052]                           quietly = TRUE)
[15:31:15.052]                         if (has_future) {
[15:31:15.052]                           ns <- base::getNamespace("future")
[15:31:15.052]                           version <- ns[[".package"]][["version"]]
[15:31:15.052]                           if (is.null(version)) 
[15:31:15.052]                             version <- utils::packageVersion("future")
[15:31:15.052]                         }
[15:31:15.052]                         else {
[15:31:15.052]                           version <- NULL
[15:31:15.052]                         }
[15:31:15.052]                         if (!has_future || version < "1.8.0") {
[15:31:15.052]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:15.052]                             "", base::R.version$version.string), 
[15:31:15.052]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:15.052]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:15.052]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:15.052]                               "release", "version")], collapse = " "), 
[15:31:15.052]                             hostname = base::Sys.info()[["nodename"]])
[15:31:15.052]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:15.052]                             info)
[15:31:15.052]                           info <- base::paste(info, collapse = "; ")
[15:31:15.052]                           if (!has_future) {
[15:31:15.052]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:15.052]                               info)
[15:31:15.052]                           }
[15:31:15.052]                           else {
[15:31:15.052]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:15.052]                               info, version)
[15:31:15.052]                           }
[15:31:15.052]                           base::stop(msg)
[15:31:15.052]                         }
[15:31:15.052]                       })
[15:31:15.052]                     }
[15:31:15.052]                     base::local({
[15:31:15.052]                       for (pkg in "stats") {
[15:31:15.052]                         base::loadNamespace(pkg)
[15:31:15.052]                         base::library(pkg, character.only = TRUE)
[15:31:15.052]                       }
[15:31:15.052]                     })
[15:31:15.052]                   }
[15:31:15.052]                   ...future.strategy.old <- future::plan("list")
[15:31:15.052]                   options(future.plan = NULL)
[15:31:15.052]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:15.052]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:15.052]                 }
[15:31:15.052]                 ...future.workdir <- getwd()
[15:31:15.052]             }
[15:31:15.052]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:15.052]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:15.052]         }
[15:31:15.052]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:15.052]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:31:15.052]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:15.052]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:15.052]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:15.052]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:15.052]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:15.052]             base::names(...future.oldOptions))
[15:31:15.052]     }
[15:31:15.052]     if (FALSE) {
[15:31:15.052]     }
[15:31:15.052]     else {
[15:31:15.052]         if (TRUE) {
[15:31:15.052]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:15.052]                 open = "w")
[15:31:15.052]         }
[15:31:15.052]         else {
[15:31:15.052]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:15.052]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:15.052]         }
[15:31:15.052]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:15.052]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:15.052]             base::sink(type = "output", split = FALSE)
[15:31:15.052]             base::close(...future.stdout)
[15:31:15.052]         }, add = TRUE)
[15:31:15.052]     }
[15:31:15.052]     ...future.frame <- base::sys.nframe()
[15:31:15.052]     ...future.conditions <- base::list()
[15:31:15.052]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:15.052]     if (FALSE) {
[15:31:15.052]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:15.052]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:15.052]     }
[15:31:15.052]     ...future.result <- base::tryCatch({
[15:31:15.052]         base::withCallingHandlers({
[15:31:15.052]             ...future.value <- base::withVisible(base::local({
[15:31:15.052]                 do.call(function(...) {
[15:31:15.052]                   ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:15.052]                   if (!identical(...future.globals.maxSize.org, 
[15:31:15.052]                     ...future.globals.maxSize)) {
[15:31:15.052]                     oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:15.052]                     on.exit(options(oopts), add = TRUE)
[15:31:15.052]                   }
[15:31:15.052]                   {
[15:31:15.052]                     lapply(seq_along(...future.elements_ii), 
[15:31:15.052]                       FUN = function(jj) {
[15:31:15.052]                         ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:15.052]                         ...future.FUN(...future.X_jj, ...)
[15:31:15.052]                       })
[15:31:15.052]                   }
[15:31:15.052]                 }, args = future.call.arguments)
[15:31:15.052]             }))
[15:31:15.052]             future::FutureResult(value = ...future.value$value, 
[15:31:15.052]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:15.052]                   ...future.rng), globalenv = if (FALSE) 
[15:31:15.052]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:15.052]                     ...future.globalenv.names))
[15:31:15.052]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:15.052]         }, condition = base::local({
[15:31:15.052]             c <- base::c
[15:31:15.052]             inherits <- base::inherits
[15:31:15.052]             invokeRestart <- base::invokeRestart
[15:31:15.052]             length <- base::length
[15:31:15.052]             list <- base::list
[15:31:15.052]             seq.int <- base::seq.int
[15:31:15.052]             signalCondition <- base::signalCondition
[15:31:15.052]             sys.calls <- base::sys.calls
[15:31:15.052]             `[[` <- base::`[[`
[15:31:15.052]             `+` <- base::`+`
[15:31:15.052]             `<<-` <- base::`<<-`
[15:31:15.052]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:15.052]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:15.052]                   3L)]
[15:31:15.052]             }
[15:31:15.052]             function(cond) {
[15:31:15.052]                 is_error <- inherits(cond, "error")
[15:31:15.052]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:15.052]                   NULL)
[15:31:15.052]                 if (is_error) {
[15:31:15.052]                   sessionInformation <- function() {
[15:31:15.052]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:15.052]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:15.052]                       search = base::search(), system = base::Sys.info())
[15:31:15.052]                   }
[15:31:15.052]                   ...future.conditions[[length(...future.conditions) + 
[15:31:15.052]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:15.052]                     cond$call), session = sessionInformation(), 
[15:31:15.052]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:15.052]                   signalCondition(cond)
[15:31:15.052]                 }
[15:31:15.052]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:15.052]                 "immediateCondition"))) {
[15:31:15.052]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:15.052]                   ...future.conditions[[length(...future.conditions) + 
[15:31:15.052]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:15.052]                   if (TRUE && !signal) {
[15:31:15.052]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:15.052]                     {
[15:31:15.052]                       inherits <- base::inherits
[15:31:15.052]                       invokeRestart <- base::invokeRestart
[15:31:15.052]                       is.null <- base::is.null
[15:31:15.052]                       muffled <- FALSE
[15:31:15.052]                       if (inherits(cond, "message")) {
[15:31:15.052]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:15.052]                         if (muffled) 
[15:31:15.052]                           invokeRestart("muffleMessage")
[15:31:15.052]                       }
[15:31:15.052]                       else if (inherits(cond, "warning")) {
[15:31:15.052]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:15.052]                         if (muffled) 
[15:31:15.052]                           invokeRestart("muffleWarning")
[15:31:15.052]                       }
[15:31:15.052]                       else if (inherits(cond, "condition")) {
[15:31:15.052]                         if (!is.null(pattern)) {
[15:31:15.052]                           computeRestarts <- base::computeRestarts
[15:31:15.052]                           grepl <- base::grepl
[15:31:15.052]                           restarts <- computeRestarts(cond)
[15:31:15.052]                           for (restart in restarts) {
[15:31:15.052]                             name <- restart$name
[15:31:15.052]                             if (is.null(name)) 
[15:31:15.052]                               next
[15:31:15.052]                             if (!grepl(pattern, name)) 
[15:31:15.052]                               next
[15:31:15.052]                             invokeRestart(restart)
[15:31:15.052]                             muffled <- TRUE
[15:31:15.052]                             break
[15:31:15.052]                           }
[15:31:15.052]                         }
[15:31:15.052]                       }
[15:31:15.052]                       invisible(muffled)
[15:31:15.052]                     }
[15:31:15.052]                     muffleCondition(cond, pattern = "^muffle")
[15:31:15.052]                   }
[15:31:15.052]                 }
[15:31:15.052]                 else {
[15:31:15.052]                   if (TRUE) {
[15:31:15.052]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:15.052]                     {
[15:31:15.052]                       inherits <- base::inherits
[15:31:15.052]                       invokeRestart <- base::invokeRestart
[15:31:15.052]                       is.null <- base::is.null
[15:31:15.052]                       muffled <- FALSE
[15:31:15.052]                       if (inherits(cond, "message")) {
[15:31:15.052]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:15.052]                         if (muffled) 
[15:31:15.052]                           invokeRestart("muffleMessage")
[15:31:15.052]                       }
[15:31:15.052]                       else if (inherits(cond, "warning")) {
[15:31:15.052]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:15.052]                         if (muffled) 
[15:31:15.052]                           invokeRestart("muffleWarning")
[15:31:15.052]                       }
[15:31:15.052]                       else if (inherits(cond, "condition")) {
[15:31:15.052]                         if (!is.null(pattern)) {
[15:31:15.052]                           computeRestarts <- base::computeRestarts
[15:31:15.052]                           grepl <- base::grepl
[15:31:15.052]                           restarts <- computeRestarts(cond)
[15:31:15.052]                           for (restart in restarts) {
[15:31:15.052]                             name <- restart$name
[15:31:15.052]                             if (is.null(name)) 
[15:31:15.052]                               next
[15:31:15.052]                             if (!grepl(pattern, name)) 
[15:31:15.052]                               next
[15:31:15.052]                             invokeRestart(restart)
[15:31:15.052]                             muffled <- TRUE
[15:31:15.052]                             break
[15:31:15.052]                           }
[15:31:15.052]                         }
[15:31:15.052]                       }
[15:31:15.052]                       invisible(muffled)
[15:31:15.052]                     }
[15:31:15.052]                     muffleCondition(cond, pattern = "^muffle")
[15:31:15.052]                   }
[15:31:15.052]                 }
[15:31:15.052]             }
[15:31:15.052]         }))
[15:31:15.052]     }, error = function(ex) {
[15:31:15.052]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:15.052]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:15.052]                 ...future.rng), started = ...future.startTime, 
[15:31:15.052]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:15.052]             version = "1.8"), class = "FutureResult")
[15:31:15.052]     }, finally = {
[15:31:15.052]         if (!identical(...future.workdir, getwd())) 
[15:31:15.052]             setwd(...future.workdir)
[15:31:15.052]         {
[15:31:15.052]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:15.052]                 ...future.oldOptions$nwarnings <- NULL
[15:31:15.052]             }
[15:31:15.052]             base::options(...future.oldOptions)
[15:31:15.052]             if (.Platform$OS.type == "windows") {
[15:31:15.052]                 old_names <- names(...future.oldEnvVars)
[15:31:15.052]                 envs <- base::Sys.getenv()
[15:31:15.052]                 names <- names(envs)
[15:31:15.052]                 common <- intersect(names, old_names)
[15:31:15.052]                 added <- setdiff(names, old_names)
[15:31:15.052]                 removed <- setdiff(old_names, names)
[15:31:15.052]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:15.052]                   envs[common]]
[15:31:15.052]                 NAMES <- toupper(changed)
[15:31:15.052]                 args <- list()
[15:31:15.052]                 for (kk in seq_along(NAMES)) {
[15:31:15.052]                   name <- changed[[kk]]
[15:31:15.052]                   NAME <- NAMES[[kk]]
[15:31:15.052]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:15.052]                     next
[15:31:15.052]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:15.052]                 }
[15:31:15.052]                 NAMES <- toupper(added)
[15:31:15.052]                 for (kk in seq_along(NAMES)) {
[15:31:15.052]                   name <- added[[kk]]
[15:31:15.052]                   NAME <- NAMES[[kk]]
[15:31:15.052]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:15.052]                     next
[15:31:15.052]                   args[[name]] <- ""
[15:31:15.052]                 }
[15:31:15.052]                 NAMES <- toupper(removed)
[15:31:15.052]                 for (kk in seq_along(NAMES)) {
[15:31:15.052]                   name <- removed[[kk]]
[15:31:15.052]                   NAME <- NAMES[[kk]]
[15:31:15.052]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:15.052]                     next
[15:31:15.052]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:15.052]                 }
[15:31:15.052]                 if (length(args) > 0) 
[15:31:15.052]                   base::do.call(base::Sys.setenv, args = args)
[15:31:15.052]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:15.052]             }
[15:31:15.052]             else {
[15:31:15.052]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:15.052]             }
[15:31:15.052]             {
[15:31:15.052]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:15.052]                   0L) {
[15:31:15.052]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:15.052]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:15.052]                   base::options(opts)
[15:31:15.052]                 }
[15:31:15.052]                 {
[15:31:15.052]                   {
[15:31:15.052]                     NULL
[15:31:15.052]                     RNGkind("Mersenne-Twister")
[15:31:15.052]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[15:31:15.052]                       inherits = FALSE)
[15:31:15.052]                   }
[15:31:15.052]                   options(future.plan = NULL)
[15:31:15.052]                   if (is.na(NA_character_)) 
[15:31:15.052]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:15.052]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:15.052]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:15.052]                     .init = FALSE)
[15:31:15.052]                 }
[15:31:15.052]             }
[15:31:15.052]         }
[15:31:15.052]     })
[15:31:15.052]     if (TRUE) {
[15:31:15.052]         base::sink(type = "output", split = FALSE)
[15:31:15.052]         if (TRUE) {
[15:31:15.052]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:15.052]         }
[15:31:15.052]         else {
[15:31:15.052]             ...future.result["stdout"] <- base::list(NULL)
[15:31:15.052]         }
[15:31:15.052]         base::close(...future.stdout)
[15:31:15.052]         ...future.stdout <- NULL
[15:31:15.052]     }
[15:31:15.052]     ...future.result$conditions <- ...future.conditions
[15:31:15.052]     ...future.result$finished <- base::Sys.time()
[15:31:15.052]     ...future.result
[15:31:15.052] }
[15:31:15.059] assign_globals() ...
[15:31:15.059] List of 5
[15:31:15.059]  $ ...future.FUN            :function (x, ...)  
[15:31:15.059]  $ future.call.arguments    : list()
[15:31:15.059]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:15.059]  $ ...future.elements_ii    :List of 3
[15:31:15.059]   ..$ logic: logi [1:4] TRUE FALSE FALSE TRUE
[15:31:15.059]   ..$ beta : num [1:7] 0.0498 0.1353 0.3679 1 2.7183 ...
[15:31:15.059]   ..$ a    : int [1:10] 1 2 3 4 5 6 7 8 9 10
[15:31:15.059]  $ ...future.seeds_ii       : NULL
[15:31:15.059]  $ ...future.globals.maxSize: NULL
[15:31:15.059]  - attr(*, "where")=List of 5
[15:31:15.059]   ..$ ...future.FUN            :<environment: R_EmptyEnv> 
[15:31:15.059]   ..$ future.call.arguments    :<environment: R_EmptyEnv> 
[15:31:15.059]   ..$ ...future.elements_ii    :<environment: R_EmptyEnv> 
[15:31:15.059]   ..$ ...future.seeds_ii       :<environment: R_EmptyEnv> 
[15:31:15.059]   ..$ ...future.globals.maxSize:<environment: R_EmptyEnv> 
[15:31:15.059]  - attr(*, "resolved")= logi FALSE
[15:31:15.059]  - attr(*, "total_size")= num 1248
[15:31:15.059]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:15.059]  - attr(*, "already-done")= logi TRUE
[15:31:15.071] - copied '...future.FUN' to environment
[15:31:15.071] - copied 'future.call.arguments' to environment
[15:31:15.071] - copied '...future.elements_ii' to environment
[15:31:15.072] - copied '...future.seeds_ii' to environment
[15:31:15.072] - copied '...future.globals.maxSize' to environment
[15:31:15.072] assign_globals() ... done
[15:31:15.073] plan(): Setting new future strategy stack:
[15:31:15.074] List of future strategies:
[15:31:15.074] 1. sequential:
[15:31:15.074]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:15.074]    - tweaked: FALSE
[15:31:15.074]    - call: NULL
[15:31:15.075] plan(): nbrOfWorkers() = 1
[15:31:15.081] plan(): Setting new future strategy stack:
[15:31:15.081] List of future strategies:
[15:31:15.081] 1. sequential:
[15:31:15.081]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:15.081]    - tweaked: FALSE
[15:31:15.081]    - call: plan(strategy)
[15:31:15.082] plan(): nbrOfWorkers() = 1
[15:31:15.083] SequentialFuture started (and completed)
[15:31:15.083] - Launch lazy future ... done
[15:31:15.083] run() for 'SequentialFuture' ... done
[15:31:15.084] Created future:
[15:31:15.084] SequentialFuture:
[15:31:15.084] Label: 'future_eapply-1'
[15:31:15.084] Expression:
[15:31:15.084] {
[15:31:15.084]     do.call(function(...) {
[15:31:15.084]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:15.084]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:15.084]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:15.084]             on.exit(options(oopts), add = TRUE)
[15:31:15.084]         }
[15:31:15.084]         {
[15:31:15.084]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:15.084]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:15.084]                 ...future.FUN(...future.X_jj, ...)
[15:31:15.084]             })
[15:31:15.084]         }
[15:31:15.084]     }, args = future.call.arguments)
[15:31:15.084] }
[15:31:15.084] Lazy evaluation: FALSE
[15:31:15.084] Asynchronous evaluation: FALSE
[15:31:15.084] Local evaluation: TRUE
[15:31:15.084] Environment: R_GlobalEnv
[15:31:15.084] Capture standard output: TRUE
[15:31:15.084] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:15.084] Globals: 5 objects totaling 1.48 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 272 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:31:15.084] Packages: 1 packages ('stats')
[15:31:15.084] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:15.084] Resolved: TRUE
[15:31:15.084] Value: 1.71 KiB of class 'list'
[15:31:15.084] Early signaling: FALSE
[15:31:15.084] Owner process: 1f501b3c-5bdf-35ad-4a62-196ce98a2fc6
[15:31:15.084] Class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[15:31:15.086] Chunk #1 of 1 ... DONE
[15:31:15.087] Launching 1 futures (chunks) ... DONE
[15:31:15.087] Resolving 1 futures (chunks) ...
[15:31:15.087] resolve() on list ...
[15:31:15.088]  recursive: 0
[15:31:15.088]  length: 1
[15:31:15.088] 
[15:31:15.088] resolved() for 'SequentialFuture' ...
[15:31:15.089] - state: 'finished'
[15:31:15.089] - run: TRUE
[15:31:15.090] - result: 'FutureResult'
[15:31:15.090] resolved() for 'SequentialFuture' ... done
[15:31:15.090] Future #1
[15:31:15.091] signalConditionsASAP(SequentialFuture, pos=1) ...
[15:31:15.091] - nx: 1
[15:31:15.091] - relay: TRUE
[15:31:15.092] - stdout: TRUE
[15:31:15.092] - signal: TRUE
[15:31:15.092] - resignal: FALSE
[15:31:15.092] - force: TRUE
[15:31:15.093] - relayed: [n=1] FALSE
[15:31:15.093] - queued futures: [n=1] FALSE
[15:31:15.093]  - until=1
[15:31:15.094]  - relaying element #1
[15:31:15.094] - relayed: [n=1] TRUE
[15:31:15.094] - queued futures: [n=1] TRUE
[15:31:15.095] signalConditionsASAP(SequentialFuture, pos=1) ... done
[15:31:15.095]  length: 0 (resolved future 1)
[15:31:15.095] Relaying remaining futures
[15:31:15.096] signalConditionsASAP(NULL, pos=0) ...
[15:31:15.096] - nx: 1
[15:31:15.096] - relay: TRUE
[15:31:15.096] - stdout: TRUE
[15:31:15.097] - signal: TRUE
[15:31:15.097] - resignal: FALSE
[15:31:15.097] - force: TRUE
[15:31:15.098] - relayed: [n=1] TRUE
[15:31:15.098] - queued futures: [n=1] TRUE
 - flush all
[15:31:15.098] - relayed: [n=1] TRUE
[15:31:15.099] - queued futures: [n=1] TRUE
[15:31:15.099] signalConditionsASAP(NULL, pos=0) ... done
[15:31:15.099] resolve() on list ... DONE
[15:31:15.100]  - Number of value chunks collected: 1
[15:31:15.100] Resolving 1 futures (chunks) ... DONE
[15:31:15.100] Reducing values from 1 chunks ...
[15:31:15.100]  - Number of values collected after concatenation: 3
[15:31:15.100]  - Number of values expected: 3
[15:31:15.100] Reducing values from 1 chunks ... DONE
[15:31:15.101] future_lapply() ... DONE
[15:31:15.101] plan(): Setting new future strategy stack:
[15:31:15.101] List of future strategies:
[15:31:15.101] 1. sequential:
[15:31:15.101]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:15.101]    - tweaked: FALSE
[15:31:15.101]    - call: plan(sequential)
[15:31:15.102] plan(): nbrOfWorkers() = 1
*** strategy = 'sequential' ... done
*** strategy = 'multisession' ...
[15:31:15.103] plan(): Setting new future strategy stack:
[15:31:15.103] List of future strategies:
[15:31:15.103] 1. multisession:
[15:31:15.103]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[15:31:15.103]    - tweaked: FALSE
[15:31:15.103]    - call: plan(strategy)
[15:31:15.103] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[15:31:15.103] multisession:
[15:31:15.103] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[15:31:15.103] - tweaked: FALSE
[15:31:15.103] - call: plan(strategy)
[15:31:15.108] getGlobalsAndPackages() ...
[15:31:15.108] Not searching for globals
[15:31:15.109] - globals: [0] <none>
[15:31:15.109] getGlobalsAndPackages() ... DONE
[15:31:15.109] [local output] makeClusterPSOCK() ...
[15:31:15.161] [local output] Workers: [n = 2] 'localhost', 'localhost'
[15:31:15.169] [local output] Base port: 22391
[15:31:15.169] [local output] Getting setup options for 2 cluster nodes ...
[15:31:15.169] [local output]  - Node 1 of 2 ...
[15:31:15.170] [local output] localMachine=TRUE => revtunnel=FALSE

[15:31:15.172] Testing if worker's PID can be inferred: '"D:/RCompile/recent/R/bin/x64/Rscript" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpqgHNm8/worker.rank=1.parallelly.parent=21072.5250734331f0.pid\")), silent = TRUE)" -e "file.exists(\"D:/temp/RtmpqgHNm8/worker.rank=1.parallelly.parent=21072.5250734331f0.pid\")"'
[15:31:15.608] - Possible to infer worker's PID: TRUE
[15:31:15.609] [local output] Rscript port: 22391

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

[15:31:15.613] [local output] Rscript port: 22391

[15:31:15.614] [local output] Getting setup options for 2 cluster nodes ... done
[15:31:15.614] [local output]  - Parallel setup requested for some PSOCK nodes
[15:31:15.615] [local output] Setting up PSOCK nodes in parallel
[15:31:15.616] List of 36
[15:31:15.616]  $ worker          : chr "localhost"
[15:31:15.616]   ..- attr(*, "localhost")= logi TRUE
[15:31:15.616]  $ master          : chr "localhost"
[15:31:15.616]  $ port            : int 22391
[15:31:15.616]  $ connectTimeout  : num 120
[15:31:15.616]  $ timeout         : num 120
[15:31:15.616]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[15:31:15.616]  $ homogeneous     : logi TRUE
[15:31:15.616]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=future_eapply.R:21072:CRANWIN3:C"| __truncated__
[15:31:15.616]  $ rscript_envs    : NULL
[15:31:15.616]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpIhDozX/RLIBS_2bbc83f2b47c7" "D:/RCompile/recent/R/library"
[15:31:15.616]  $ rscript_startup : NULL
[15:31:15.616]  $ rscript_sh      : chr "cmd"
[15:31:15.616]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[15:31:15.616]  $ methods         : logi TRUE
[15:31:15.616]  $ socketOptions   : chr "no-delay"
[15:31:15.616]  $ useXDR          : logi FALSE
[15:31:15.616]  $ outfile         : chr "/dev/null"
[15:31:15.616]  $ renice          : int NA
[15:31:15.616]  $ rshcmd          : NULL
[15:31:15.616]  $ user            : chr(0) 
[15:31:15.616]  $ revtunnel       : logi FALSE
[15:31:15.616]  $ rshlogfile      : NULL
[15:31:15.616]  $ rshopts         : chr(0) 
[15:31:15.616]  $ rank            : int 1
[15:31:15.616]  $ manual          : logi FALSE
[15:31:15.616]  $ dryrun          : logi FALSE
[15:31:15.616]  $ quiet           : logi FALSE
[15:31:15.616]  $ setup_strategy  : chr "parallel"
[15:31:15.616]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[15:31:15.616]  $ pidfile         : chr "D:/temp/RtmpqgHNm8/worker.rank=1.parallelly.parent=21072.5250734331f0.pid"
[15:31:15.616]  $ rshcmd_label    : NULL
[15:31:15.616]  $ rsh_call        : NULL
[15:31:15.616]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[15:31:15.616]  $ localMachine    : logi TRUE
[15:31:15.616]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[15:31:15.616]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[15:31:15.616]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[15:31:15.616]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[15:31:15.616]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[15:31:15.616]         "cmd", "sh"), default_packages = c("datasets", "utils", "grDevices", 
[15:31:15.616]         "graphics", "stats", if (methods) "methods"), methods = TRUE, socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[15:31:15.616]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[15:31:15.616]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[15:31:15.616]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[15:31:15.616]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[15:31:15.616]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[15:31:15.616]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[15:31:15.616]  $ arguments       :List of 28
[15:31:15.616]   ..$ worker          : chr "localhost"
[15:31:15.616]   ..$ master          : NULL
[15:31:15.616]   ..$ port            : int 22391
[15:31:15.616]   ..$ connectTimeout  : num 120
[15:31:15.616]   ..$ timeout         : num 120
[15:31:15.616]   ..$ rscript         : NULL
[15:31:15.616]   ..$ homogeneous     : NULL
[15:31:15.616]   ..$ rscript_args    : NULL
[15:31:15.616]   ..$ rscript_envs    : NULL
[15:31:15.616]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpIhDozX/RLIBS_2bbc83f2b47c7" "D:/RCompile/recent/R/library"
[15:31:15.616]   ..$ rscript_startup : NULL
[15:31:15.616]   ..$ rscript_sh      : chr [1:3] "auto" "cmd" "sh"
[15:31:15.616]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[15:31:15.616]   ..$ methods         : logi TRUE
[15:31:15.616]   ..$ socketOptions   : chr "no-delay"
[15:31:15.616]   ..$ useXDR          : logi FALSE
[15:31:15.616]   ..$ outfile         : chr "/dev/null"
[15:31:15.616]   ..$ renice          : int NA
[15:31:15.616]   ..$ rshcmd          : NULL
[15:31:15.616]   ..$ user            : NULL
[15:31:15.616]   ..$ revtunnel       : logi NA
[15:31:15.616]   ..$ rshlogfile      : NULL
[15:31:15.616]   ..$ rshopts         : NULL
[15:31:15.616]   ..$ rank            : int 1
[15:31:15.616]   ..$ manual          : logi FALSE
[15:31:15.616]   ..$ dryrun          : logi FALSE
[15:31:15.616]   ..$ quiet           : logi FALSE
[15:31:15.616]   ..$ setup_strategy  : chr "parallel"
[15:31:15.616]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[15:31:15.657] [local output] System call to launch all workers:
[15:31:15.657] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=future_eapply.R:21072:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpqgHNm8/worker.rank=1.parallelly.parent=21072.5250734331f0.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=22391 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[15:31:15.657] [local output] Starting PSOCK main server
[15:31:15.666] [local output] Workers launched
[15:31:15.666] [local output] Waiting for workers to connect back
[15:31:15.667]  - [local output] 0 workers out of 2 ready
[15:31:15.892]  - [local output] 0 workers out of 2 ready
[15:31:15.892]  - [local output] 1 workers out of 2 ready
[15:31:15.894]  - [local output] 1 workers out of 2 ready
[15:31:15.894]  - [local output] 2 workers out of 2 ready
[15:31:15.895] [local output] Launching of workers completed
[15:31:15.895] [local output] Collecting session information from workers
[15:31:15.896] [local output]  - Worker #1 of 2
[15:31:15.897] [local output]  - Worker #2 of 2
[15:31:15.897] [local output] makeClusterPSOCK() ... done
[15:31:15.912] Packages needed by the future expression (n = 0): <none>
[15:31:15.913] Packages needed by future strategies (n = 0): <none>
[15:31:15.914] {
[15:31:15.914]     {
[15:31:15.914]         {
[15:31:15.914]             ...future.startTime <- base::Sys.time()
[15:31:15.914]             {
[15:31:15.914]                 {
[15:31:15.914]                   {
[15:31:15.914]                     {
[15:31:15.914]                       base::local({
[15:31:15.914]                         has_future <- base::requireNamespace("future", 
[15:31:15.914]                           quietly = TRUE)
[15:31:15.914]                         if (has_future) {
[15:31:15.914]                           ns <- base::getNamespace("future")
[15:31:15.914]                           version <- ns[[".package"]][["version"]]
[15:31:15.914]                           if (is.null(version)) 
[15:31:15.914]                             version <- utils::packageVersion("future")
[15:31:15.914]                         }
[15:31:15.914]                         else {
[15:31:15.914]                           version <- NULL
[15:31:15.914]                         }
[15:31:15.914]                         if (!has_future || version < "1.8.0") {
[15:31:15.914]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:15.914]                             "", base::R.version$version.string), 
[15:31:15.914]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:15.914]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:15.914]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:15.914]                               "release", "version")], collapse = " "), 
[15:31:15.914]                             hostname = base::Sys.info()[["nodename"]])
[15:31:15.914]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:15.914]                             info)
[15:31:15.914]                           info <- base::paste(info, collapse = "; ")
[15:31:15.914]                           if (!has_future) {
[15:31:15.914]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:15.914]                               info)
[15:31:15.914]                           }
[15:31:15.914]                           else {
[15:31:15.914]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:15.914]                               info, version)
[15:31:15.914]                           }
[15:31:15.914]                           base::stop(msg)
[15:31:15.914]                         }
[15:31:15.914]                       })
[15:31:15.914]                     }
[15:31:15.914]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:15.914]                     base::options(mc.cores = 1L)
[15:31:15.914]                   }
[15:31:15.914]                   ...future.strategy.old <- future::plan("list")
[15:31:15.914]                   options(future.plan = NULL)
[15:31:15.914]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:15.914]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:15.914]                 }
[15:31:15.914]                 ...future.workdir <- getwd()
[15:31:15.914]             }
[15:31:15.914]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:15.914]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:15.914]         }
[15:31:15.914]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:15.914]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[15:31:15.914]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:15.914]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:15.914]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:15.914]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:15.914]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:15.914]             base::names(...future.oldOptions))
[15:31:15.914]     }
[15:31:15.914]     if (FALSE) {
[15:31:15.914]     }
[15:31:15.914]     else {
[15:31:15.914]         if (TRUE) {
[15:31:15.914]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:15.914]                 open = "w")
[15:31:15.914]         }
[15:31:15.914]         else {
[15:31:15.914]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:15.914]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:15.914]         }
[15:31:15.914]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:15.914]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:15.914]             base::sink(type = "output", split = FALSE)
[15:31:15.914]             base::close(...future.stdout)
[15:31:15.914]         }, add = TRUE)
[15:31:15.914]     }
[15:31:15.914]     ...future.frame <- base::sys.nframe()
[15:31:15.914]     ...future.conditions <- base::list()
[15:31:15.914]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:15.914]     if (FALSE) {
[15:31:15.914]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:15.914]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:15.914]     }
[15:31:15.914]     ...future.result <- base::tryCatch({
[15:31:15.914]         base::withCallingHandlers({
[15:31:15.914]             ...future.value <- base::withVisible(base::local({
[15:31:15.914]                 ...future.makeSendCondition <- base::local({
[15:31:15.914]                   sendCondition <- NULL
[15:31:15.914]                   function(frame = 1L) {
[15:31:15.914]                     if (is.function(sendCondition)) 
[15:31:15.914]                       return(sendCondition)
[15:31:15.914]                     ns <- getNamespace("parallel")
[15:31:15.914]                     if (exists("sendData", mode = "function", 
[15:31:15.914]                       envir = ns)) {
[15:31:15.914]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:15.914]                         envir = ns)
[15:31:15.914]                       envir <- sys.frame(frame)
[15:31:15.914]                       master <- NULL
[15:31:15.914]                       while (!identical(envir, .GlobalEnv) && 
[15:31:15.914]                         !identical(envir, emptyenv())) {
[15:31:15.914]                         if (exists("master", mode = "list", envir = envir, 
[15:31:15.914]                           inherits = FALSE)) {
[15:31:15.914]                           master <- get("master", mode = "list", 
[15:31:15.914]                             envir = envir, inherits = FALSE)
[15:31:15.914]                           if (inherits(master, c("SOCKnode", 
[15:31:15.914]                             "SOCK0node"))) {
[15:31:15.914]                             sendCondition <<- function(cond) {
[15:31:15.914]                               data <- list(type = "VALUE", value = cond, 
[15:31:15.914]                                 success = TRUE)
[15:31:15.914]                               parallel_sendData(master, data)
[15:31:15.914]                             }
[15:31:15.914]                             return(sendCondition)
[15:31:15.914]                           }
[15:31:15.914]                         }
[15:31:15.914]                         frame <- frame + 1L
[15:31:15.914]                         envir <- sys.frame(frame)
[15:31:15.914]                       }
[15:31:15.914]                     }
[15:31:15.914]                     sendCondition <<- function(cond) NULL
[15:31:15.914]                   }
[15:31:15.914]                 })
[15:31:15.914]                 withCallingHandlers({
[15:31:15.914]                   NA
[15:31:15.914]                 }, immediateCondition = function(cond) {
[15:31:15.914]                   sendCondition <- ...future.makeSendCondition()
[15:31:15.914]                   sendCondition(cond)
[15:31:15.914]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:15.914]                   {
[15:31:15.914]                     inherits <- base::inherits
[15:31:15.914]                     invokeRestart <- base::invokeRestart
[15:31:15.914]                     is.null <- base::is.null
[15:31:15.914]                     muffled <- FALSE
[15:31:15.914]                     if (inherits(cond, "message")) {
[15:31:15.914]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:15.914]                       if (muffled) 
[15:31:15.914]                         invokeRestart("muffleMessage")
[15:31:15.914]                     }
[15:31:15.914]                     else if (inherits(cond, "warning")) {
[15:31:15.914]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:15.914]                       if (muffled) 
[15:31:15.914]                         invokeRestart("muffleWarning")
[15:31:15.914]                     }
[15:31:15.914]                     else if (inherits(cond, "condition")) {
[15:31:15.914]                       if (!is.null(pattern)) {
[15:31:15.914]                         computeRestarts <- base::computeRestarts
[15:31:15.914]                         grepl <- base::grepl
[15:31:15.914]                         restarts <- computeRestarts(cond)
[15:31:15.914]                         for (restart in restarts) {
[15:31:15.914]                           name <- restart$name
[15:31:15.914]                           if (is.null(name)) 
[15:31:15.914]                             next
[15:31:15.914]                           if (!grepl(pattern, name)) 
[15:31:15.914]                             next
[15:31:15.914]                           invokeRestart(restart)
[15:31:15.914]                           muffled <- TRUE
[15:31:15.914]                           break
[15:31:15.914]                         }
[15:31:15.914]                       }
[15:31:15.914]                     }
[15:31:15.914]                     invisible(muffled)
[15:31:15.914]                   }
[15:31:15.914]                   muffleCondition(cond)
[15:31:15.914]                 })
[15:31:15.914]             }))
[15:31:15.914]             future::FutureResult(value = ...future.value$value, 
[15:31:15.914]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:15.914]                   ...future.rng), globalenv = if (FALSE) 
[15:31:15.914]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:15.914]                     ...future.globalenv.names))
[15:31:15.914]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:15.914]         }, condition = base::local({
[15:31:15.914]             c <- base::c
[15:31:15.914]             inherits <- base::inherits
[15:31:15.914]             invokeRestart <- base::invokeRestart
[15:31:15.914]             length <- base::length
[15:31:15.914]             list <- base::list
[15:31:15.914]             seq.int <- base::seq.int
[15:31:15.914]             signalCondition <- base::signalCondition
[15:31:15.914]             sys.calls <- base::sys.calls
[15:31:15.914]             `[[` <- base::`[[`
[15:31:15.914]             `+` <- base::`+`
[15:31:15.914]             `<<-` <- base::`<<-`
[15:31:15.914]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:15.914]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:15.914]                   3L)]
[15:31:15.914]             }
[15:31:15.914]             function(cond) {
[15:31:15.914]                 is_error <- inherits(cond, "error")
[15:31:15.914]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:15.914]                   NULL)
[15:31:15.914]                 if (is_error) {
[15:31:15.914]                   sessionInformation <- function() {
[15:31:15.914]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:15.914]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:15.914]                       search = base::search(), system = base::Sys.info())
[15:31:15.914]                   }
[15:31:15.914]                   ...future.conditions[[length(...future.conditions) + 
[15:31:15.914]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:15.914]                     cond$call), session = sessionInformation(), 
[15:31:15.914]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:15.914]                   signalCondition(cond)
[15:31:15.914]                 }
[15:31:15.914]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:15.914]                 "immediateCondition"))) {
[15:31:15.914]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:15.914]                   ...future.conditions[[length(...future.conditions) + 
[15:31:15.914]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:15.914]                   if (TRUE && !signal) {
[15:31:15.914]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:15.914]                     {
[15:31:15.914]                       inherits <- base::inherits
[15:31:15.914]                       invokeRestart <- base::invokeRestart
[15:31:15.914]                       is.null <- base::is.null
[15:31:15.914]                       muffled <- FALSE
[15:31:15.914]                       if (inherits(cond, "message")) {
[15:31:15.914]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:15.914]                         if (muffled) 
[15:31:15.914]                           invokeRestart("muffleMessage")
[15:31:15.914]                       }
[15:31:15.914]                       else if (inherits(cond, "warning")) {
[15:31:15.914]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:15.914]                         if (muffled) 
[15:31:15.914]                           invokeRestart("muffleWarning")
[15:31:15.914]                       }
[15:31:15.914]                       else if (inherits(cond, "condition")) {
[15:31:15.914]                         if (!is.null(pattern)) {
[15:31:15.914]                           computeRestarts <- base::computeRestarts
[15:31:15.914]                           grepl <- base::grepl
[15:31:15.914]                           restarts <- computeRestarts(cond)
[15:31:15.914]                           for (restart in restarts) {
[15:31:15.914]                             name <- restart$name
[15:31:15.914]                             if (is.null(name)) 
[15:31:15.914]                               next
[15:31:15.914]                             if (!grepl(pattern, name)) 
[15:31:15.914]                               next
[15:31:15.914]                             invokeRestart(restart)
[15:31:15.914]                             muffled <- TRUE
[15:31:15.914]                             break
[15:31:15.914]                           }
[15:31:15.914]                         }
[15:31:15.914]                       }
[15:31:15.914]                       invisible(muffled)
[15:31:15.914]                     }
[15:31:15.914]                     muffleCondition(cond, pattern = "^muffle")
[15:31:15.914]                   }
[15:31:15.914]                 }
[15:31:15.914]                 else {
[15:31:15.914]                   if (TRUE) {
[15:31:15.914]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:15.914]                     {
[15:31:15.914]                       inherits <- base::inherits
[15:31:15.914]                       invokeRestart <- base::invokeRestart
[15:31:15.914]                       is.null <- base::is.null
[15:31:15.914]                       muffled <- FALSE
[15:31:15.914]                       if (inherits(cond, "message")) {
[15:31:15.914]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:15.914]                         if (muffled) 
[15:31:15.914]                           invokeRestart("muffleMessage")
[15:31:15.914]                       }
[15:31:15.914]                       else if (inherits(cond, "warning")) {
[15:31:15.914]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:15.914]                         if (muffled) 
[15:31:15.914]                           invokeRestart("muffleWarning")
[15:31:15.914]                       }
[15:31:15.914]                       else if (inherits(cond, "condition")) {
[15:31:15.914]                         if (!is.null(pattern)) {
[15:31:15.914]                           computeRestarts <- base::computeRestarts
[15:31:15.914]                           grepl <- base::grepl
[15:31:15.914]                           restarts <- computeRestarts(cond)
[15:31:15.914]                           for (restart in restarts) {
[15:31:15.914]                             name <- restart$name
[15:31:15.914]                             if (is.null(name)) 
[15:31:15.914]                               next
[15:31:15.914]                             if (!grepl(pattern, name)) 
[15:31:15.914]                               next
[15:31:15.914]                             invokeRestart(restart)
[15:31:15.914]                             muffled <- TRUE
[15:31:15.914]                             break
[15:31:15.914]                           }
[15:31:15.914]                         }
[15:31:15.914]                       }
[15:31:15.914]                       invisible(muffled)
[15:31:15.914]                     }
[15:31:15.914]                     muffleCondition(cond, pattern = "^muffle")
[15:31:15.914]                   }
[15:31:15.914]                 }
[15:31:15.914]             }
[15:31:15.914]         }))
[15:31:15.914]     }, error = function(ex) {
[15:31:15.914]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:15.914]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:15.914]                 ...future.rng), started = ...future.startTime, 
[15:31:15.914]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:15.914]             version = "1.8"), class = "FutureResult")
[15:31:15.914]     }, finally = {
[15:31:15.914]         if (!identical(...future.workdir, getwd())) 
[15:31:15.914]             setwd(...future.workdir)
[15:31:15.914]         {
[15:31:15.914]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:15.914]                 ...future.oldOptions$nwarnings <- NULL
[15:31:15.914]             }
[15:31:15.914]             base::options(...future.oldOptions)
[15:31:15.914]             if (.Platform$OS.type == "windows") {
[15:31:15.914]                 old_names <- names(...future.oldEnvVars)
[15:31:15.914]                 envs <- base::Sys.getenv()
[15:31:15.914]                 names <- names(envs)
[15:31:15.914]                 common <- intersect(names, old_names)
[15:31:15.914]                 added <- setdiff(names, old_names)
[15:31:15.914]                 removed <- setdiff(old_names, names)
[15:31:15.914]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:15.914]                   envs[common]]
[15:31:15.914]                 NAMES <- toupper(changed)
[15:31:15.914]                 args <- list()
[15:31:15.914]                 for (kk in seq_along(NAMES)) {
[15:31:15.914]                   name <- changed[[kk]]
[15:31:15.914]                   NAME <- NAMES[[kk]]
[15:31:15.914]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:15.914]                     next
[15:31:15.914]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:15.914]                 }
[15:31:15.914]                 NAMES <- toupper(added)
[15:31:15.914]                 for (kk in seq_along(NAMES)) {
[15:31:15.914]                   name <- added[[kk]]
[15:31:15.914]                   NAME <- NAMES[[kk]]
[15:31:15.914]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:15.914]                     next
[15:31:15.914]                   args[[name]] <- ""
[15:31:15.914]                 }
[15:31:15.914]                 NAMES <- toupper(removed)
[15:31:15.914]                 for (kk in seq_along(NAMES)) {
[15:31:15.914]                   name <- removed[[kk]]
[15:31:15.914]                   NAME <- NAMES[[kk]]
[15:31:15.914]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:15.914]                     next
[15:31:15.914]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:15.914]                 }
[15:31:15.914]                 if (length(args) > 0) 
[15:31:15.914]                   base::do.call(base::Sys.setenv, args = args)
[15:31:15.914]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:15.914]             }
[15:31:15.914]             else {
[15:31:15.914]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:15.914]             }
[15:31:15.914]             {
[15:31:15.914]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:15.914]                   0L) {
[15:31:15.914]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:15.914]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:15.914]                   base::options(opts)
[15:31:15.914]                 }
[15:31:15.914]                 {
[15:31:15.914]                   {
[15:31:15.914]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:15.914]                     NULL
[15:31:15.914]                   }
[15:31:15.914]                   options(future.plan = NULL)
[15:31:15.914]                   if (is.na(NA_character_)) 
[15:31:15.914]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:15.914]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:15.914]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:15.914]                     .init = FALSE)
[15:31:15.914]                 }
[15:31:15.914]             }
[15:31:15.914]         }
[15:31:15.914]     })
[15:31:15.914]     if (TRUE) {
[15:31:15.914]         base::sink(type = "output", split = FALSE)
[15:31:15.914]         if (TRUE) {
[15:31:15.914]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:15.914]         }
[15:31:15.914]         else {
[15:31:15.914]             ...future.result["stdout"] <- base::list(NULL)
[15:31:15.914]         }
[15:31:15.914]         base::close(...future.stdout)
[15:31:15.914]         ...future.stdout <- NULL
[15:31:15.914]     }
[15:31:15.914]     ...future.result$conditions <- ...future.conditions
[15:31:15.914]     ...future.result$finished <- base::Sys.time()
[15:31:15.914]     ...future.result
[15:31:15.914] }
[15:31:16.041] MultisessionFuture started
[15:31:16.041] result() for ClusterFuture ...
[15:31:16.042] receiveMessageFromWorker() for ClusterFuture ...
[15:31:16.042] - Validating connection of MultisessionFuture
[15:31:16.139] - received message: FutureResult
[15:31:16.140] - Received FutureResult
[15:31:16.145] - Erased future from FutureRegistry
[15:31:16.146] result() for ClusterFuture ...
[15:31:16.146] - result already collected: FutureResult
[15:31:16.147] result() for ClusterFuture ... done
[15:31:16.147] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:16.147] result() for ClusterFuture ... done
[15:31:16.148] result() for ClusterFuture ...
[15:31:16.148] - result already collected: FutureResult
[15:31:16.148] result() for ClusterFuture ... done
[15:31:16.149] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[15:31:16.153] plan(): nbrOfWorkers() = 2
[15:31:16.153] future_lapply() ...
[15:31:16.159] Number of chunks: 2
[15:31:16.160] getGlobalsAndPackagesXApply() ...
[15:31:16.160]  - future.globals: TRUE
[15:31:16.160] getGlobalsAndPackages() ...
[15:31:16.161] Searching for globals...
[15:31:16.163] - globals found: [2] 'FUN', 'UseMethod'
[15:31:16.163] Searching for globals ... DONE
[15:31:16.164] Resolving globals: FALSE
[15:31:16.164] The total size of the 1 globals is 1.21 KiB (1240 bytes)
[15:31:16.165] The total size of the 1 globals exported for future expression ('FUN()') is 1.21 KiB.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'FUN' (1.21 KiB of class 'function')
[15:31:16.165] - globals: [1] 'FUN'
[15:31:16.166] 
[15:31:16.166] getGlobalsAndPackages() ... DONE
[15:31:16.166]  - globals found/used: [n=1] 'FUN'
[15:31:16.167]  - needed namespaces: [n=0] 
[15:31:16.167] Finding globals ... DONE
[15:31:16.167]  - use_args: TRUE
[15:31:16.167]  - Getting '...' globals ...
[15:31:16.168] resolve() on list ...
[15:31:16.169]  recursive: 0
[15:31:16.169]  length: 1
[15:31:16.169]  elements: '...'
[15:31:16.169]  length: 0 (resolved future 1)
[15:31:16.170] resolve() on list ... DONE
[15:31:16.170]    - '...' content: [n=0] 
[15:31:16.171] List of 1
[15:31:16.171]  $ ...: list()
[15:31:16.171]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:16.171]  - attr(*, "where")=List of 1
[15:31:16.171]   ..$ ...:<environment: 0x000001b3fcb4b0a0> 
[15:31:16.171]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:16.171]  - attr(*, "resolved")= logi TRUE
[15:31:16.171]  - attr(*, "total_size")= num NA
[15:31:16.177]  - Getting '...' globals ... DONE
[15:31:16.177] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:16.177] List of 2
[15:31:16.177]  $ ...future.FUN:function (x, ...)  
[15:31:16.177]  $ ...          : list()
[15:31:16.177]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:16.177]  - attr(*, "where")=List of 2
[15:31:16.177]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:16.177]   ..$ ...          :<environment: 0x000001b3fcb4b0a0> 
[15:31:16.177]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:16.177]  - attr(*, "resolved")= logi FALSE
[15:31:16.177]  - attr(*, "total_size")= num 1240
[15:31:16.182] Packages to be attached in all futures: [n=0] 
[15:31:16.182] getGlobalsAndPackagesXApply() ... DONE
[15:31:16.183] Number of futures (= number of chunks): 2
[15:31:16.183] Launching 2 futures (chunks) ...
[15:31:16.183] Chunk #1 of 2 ...
[15:31:16.183]  - Finding globals in 'X' for chunk #1 ...
[15:31:16.184] getGlobalsAndPackages() ...
[15:31:16.184] Searching for globals...
[15:31:16.184] 
[15:31:16.184] Searching for globals ... DONE
[15:31:16.185] - globals: [0] <none>
[15:31:16.185] getGlobalsAndPackages() ... DONE
[15:31:16.185]    + additional globals found: [n=0] 
[15:31:16.185]    + additional namespaces needed: [n=0] 
[15:31:16.186]  - Finding globals in 'X' for chunk #1 ... DONE
[15:31:16.186]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:31:16.186]  - seeds: <none>
[15:31:16.186]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:16.187] getGlobalsAndPackages() ...
[15:31:16.187] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:16.188] Resolving globals: FALSE
[15:31:16.188] Tweak future expression to call with '...' arguments ...
[15:31:16.188] {
[15:31:16.188]     do.call(function(...) {
[15:31:16.188]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:16.188]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:16.188]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:16.188]             on.exit(options(oopts), add = TRUE)
[15:31:16.188]         }
[15:31:16.188]         {
[15:31:16.188]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:16.188]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:16.188]                 ...future.FUN(...future.X_jj, ...)
[15:31:16.188]             })
[15:31:16.188]         }
[15:31:16.188]     }, args = future.call.arguments)
[15:31:16.188] }
[15:31:16.189] Tweak future expression to call with '...' arguments ... DONE
[15:31:16.190] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:16.191] 
[15:31:16.191] getGlobalsAndPackages() ... DONE
[15:31:16.192] run() for 'Future' ...
[15:31:16.192] - state: 'created'
[15:31:16.192] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:16.215] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:16.216] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:31:16.216]   - Field: 'node'
[15:31:16.216]   - Field: 'label'
[15:31:16.217]   - Field: 'local'
[15:31:16.217]   - Field: 'owner'
[15:31:16.218]   - Field: 'envir'
[15:31:16.218]   - Field: 'workers'
[15:31:16.218]   - Field: 'packages'
[15:31:16.219]   - Field: 'gc'
[15:31:16.219]   - Field: 'conditions'
[15:31:16.219]   - Field: 'persistent'
[15:31:16.220]   - Field: 'expr'
[15:31:16.220]   - Field: 'uuid'
[15:31:16.221]   - Field: 'seed'
[15:31:16.221]   - Field: 'version'
[15:31:16.221]   - Field: 'result'
[15:31:16.222]   - Field: 'asynchronous'
[15:31:16.222]   - Field: 'calls'
[15:31:16.223]   - Field: 'globals'
[15:31:16.223]   - Field: 'stdout'
[15:31:16.224]   - Field: 'earlySignal'
[15:31:16.224]   - Field: 'lazy'
[15:31:16.224]   - Field: 'state'
[15:31:16.225] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:31:16.225] - Launch lazy future ...
[15:31:16.226] Packages needed by the future expression (n = 0): <none>
[15:31:16.226] Packages needed by future strategies (n = 0): <none>
[15:31:16.228] {
[15:31:16.228]     {
[15:31:16.228]         {
[15:31:16.228]             ...future.startTime <- base::Sys.time()
[15:31:16.228]             {
[15:31:16.228]                 {
[15:31:16.228]                   {
[15:31:16.228]                     {
[15:31:16.228]                       base::local({
[15:31:16.228]                         has_future <- base::requireNamespace("future", 
[15:31:16.228]                           quietly = TRUE)
[15:31:16.228]                         if (has_future) {
[15:31:16.228]                           ns <- base::getNamespace("future")
[15:31:16.228]                           version <- ns[[".package"]][["version"]]
[15:31:16.228]                           if (is.null(version)) 
[15:31:16.228]                             version <- utils::packageVersion("future")
[15:31:16.228]                         }
[15:31:16.228]                         else {
[15:31:16.228]                           version <- NULL
[15:31:16.228]                         }
[15:31:16.228]                         if (!has_future || version < "1.8.0") {
[15:31:16.228]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:16.228]                             "", base::R.version$version.string), 
[15:31:16.228]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:16.228]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:16.228]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:16.228]                               "release", "version")], collapse = " "), 
[15:31:16.228]                             hostname = base::Sys.info()[["nodename"]])
[15:31:16.228]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:16.228]                             info)
[15:31:16.228]                           info <- base::paste(info, collapse = "; ")
[15:31:16.228]                           if (!has_future) {
[15:31:16.228]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:16.228]                               info)
[15:31:16.228]                           }
[15:31:16.228]                           else {
[15:31:16.228]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:16.228]                               info, version)
[15:31:16.228]                           }
[15:31:16.228]                           base::stop(msg)
[15:31:16.228]                         }
[15:31:16.228]                       })
[15:31:16.228]                     }
[15:31:16.228]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:16.228]                     base::options(mc.cores = 1L)
[15:31:16.228]                   }
[15:31:16.228]                   ...future.strategy.old <- future::plan("list")
[15:31:16.228]                   options(future.plan = NULL)
[15:31:16.228]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:16.228]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:16.228]                 }
[15:31:16.228]                 ...future.workdir <- getwd()
[15:31:16.228]             }
[15:31:16.228]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:16.228]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:16.228]         }
[15:31:16.228]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:16.228]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:31:16.228]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:16.228]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:16.228]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:16.228]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:16.228]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:16.228]             base::names(...future.oldOptions))
[15:31:16.228]     }
[15:31:16.228]     if (FALSE) {
[15:31:16.228]     }
[15:31:16.228]     else {
[15:31:16.228]         if (TRUE) {
[15:31:16.228]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:16.228]                 open = "w")
[15:31:16.228]         }
[15:31:16.228]         else {
[15:31:16.228]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:16.228]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:16.228]         }
[15:31:16.228]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:16.228]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:16.228]             base::sink(type = "output", split = FALSE)
[15:31:16.228]             base::close(...future.stdout)
[15:31:16.228]         }, add = TRUE)
[15:31:16.228]     }
[15:31:16.228]     ...future.frame <- base::sys.nframe()
[15:31:16.228]     ...future.conditions <- base::list()
[15:31:16.228]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:16.228]     if (FALSE) {
[15:31:16.228]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:16.228]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:16.228]     }
[15:31:16.228]     ...future.result <- base::tryCatch({
[15:31:16.228]         base::withCallingHandlers({
[15:31:16.228]             ...future.value <- base::withVisible(base::local({
[15:31:16.228]                 ...future.makeSendCondition <- base::local({
[15:31:16.228]                   sendCondition <- NULL
[15:31:16.228]                   function(frame = 1L) {
[15:31:16.228]                     if (is.function(sendCondition)) 
[15:31:16.228]                       return(sendCondition)
[15:31:16.228]                     ns <- getNamespace("parallel")
[15:31:16.228]                     if (exists("sendData", mode = "function", 
[15:31:16.228]                       envir = ns)) {
[15:31:16.228]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:16.228]                         envir = ns)
[15:31:16.228]                       envir <- sys.frame(frame)
[15:31:16.228]                       master <- NULL
[15:31:16.228]                       while (!identical(envir, .GlobalEnv) && 
[15:31:16.228]                         !identical(envir, emptyenv())) {
[15:31:16.228]                         if (exists("master", mode = "list", envir = envir, 
[15:31:16.228]                           inherits = FALSE)) {
[15:31:16.228]                           master <- get("master", mode = "list", 
[15:31:16.228]                             envir = envir, inherits = FALSE)
[15:31:16.228]                           if (inherits(master, c("SOCKnode", 
[15:31:16.228]                             "SOCK0node"))) {
[15:31:16.228]                             sendCondition <<- function(cond) {
[15:31:16.228]                               data <- list(type = "VALUE", value = cond, 
[15:31:16.228]                                 success = TRUE)
[15:31:16.228]                               parallel_sendData(master, data)
[15:31:16.228]                             }
[15:31:16.228]                             return(sendCondition)
[15:31:16.228]                           }
[15:31:16.228]                         }
[15:31:16.228]                         frame <- frame + 1L
[15:31:16.228]                         envir <- sys.frame(frame)
[15:31:16.228]                       }
[15:31:16.228]                     }
[15:31:16.228]                     sendCondition <<- function(cond) NULL
[15:31:16.228]                   }
[15:31:16.228]                 })
[15:31:16.228]                 withCallingHandlers({
[15:31:16.228]                   {
[15:31:16.228]                     do.call(function(...) {
[15:31:16.228]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:16.228]                       if (!identical(...future.globals.maxSize.org, 
[15:31:16.228]                         ...future.globals.maxSize)) {
[15:31:16.228]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:16.228]                         on.exit(options(oopts), add = TRUE)
[15:31:16.228]                       }
[15:31:16.228]                       {
[15:31:16.228]                         lapply(seq_along(...future.elements_ii), 
[15:31:16.228]                           FUN = function(jj) {
[15:31:16.228]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:16.228]                             ...future.FUN(...future.X_jj, ...)
[15:31:16.228]                           })
[15:31:16.228]                       }
[15:31:16.228]                     }, args = future.call.arguments)
[15:31:16.228]                   }
[15:31:16.228]                 }, immediateCondition = function(cond) {
[15:31:16.228]                   sendCondition <- ...future.makeSendCondition()
[15:31:16.228]                   sendCondition(cond)
[15:31:16.228]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:16.228]                   {
[15:31:16.228]                     inherits <- base::inherits
[15:31:16.228]                     invokeRestart <- base::invokeRestart
[15:31:16.228]                     is.null <- base::is.null
[15:31:16.228]                     muffled <- FALSE
[15:31:16.228]                     if (inherits(cond, "message")) {
[15:31:16.228]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:16.228]                       if (muffled) 
[15:31:16.228]                         invokeRestart("muffleMessage")
[15:31:16.228]                     }
[15:31:16.228]                     else if (inherits(cond, "warning")) {
[15:31:16.228]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:16.228]                       if (muffled) 
[15:31:16.228]                         invokeRestart("muffleWarning")
[15:31:16.228]                     }
[15:31:16.228]                     else if (inherits(cond, "condition")) {
[15:31:16.228]                       if (!is.null(pattern)) {
[15:31:16.228]                         computeRestarts <- base::computeRestarts
[15:31:16.228]                         grepl <- base::grepl
[15:31:16.228]                         restarts <- computeRestarts(cond)
[15:31:16.228]                         for (restart in restarts) {
[15:31:16.228]                           name <- restart$name
[15:31:16.228]                           if (is.null(name)) 
[15:31:16.228]                             next
[15:31:16.228]                           if (!grepl(pattern, name)) 
[15:31:16.228]                             next
[15:31:16.228]                           invokeRestart(restart)
[15:31:16.228]                           muffled <- TRUE
[15:31:16.228]                           break
[15:31:16.228]                         }
[15:31:16.228]                       }
[15:31:16.228]                     }
[15:31:16.228]                     invisible(muffled)
[15:31:16.228]                   }
[15:31:16.228]                   muffleCondition(cond)
[15:31:16.228]                 })
[15:31:16.228]             }))
[15:31:16.228]             future::FutureResult(value = ...future.value$value, 
[15:31:16.228]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:16.228]                   ...future.rng), globalenv = if (FALSE) 
[15:31:16.228]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:16.228]                     ...future.globalenv.names))
[15:31:16.228]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:16.228]         }, condition = base::local({
[15:31:16.228]             c <- base::c
[15:31:16.228]             inherits <- base::inherits
[15:31:16.228]             invokeRestart <- base::invokeRestart
[15:31:16.228]             length <- base::length
[15:31:16.228]             list <- base::list
[15:31:16.228]             seq.int <- base::seq.int
[15:31:16.228]             signalCondition <- base::signalCondition
[15:31:16.228]             sys.calls <- base::sys.calls
[15:31:16.228]             `[[` <- base::`[[`
[15:31:16.228]             `+` <- base::`+`
[15:31:16.228]             `<<-` <- base::`<<-`
[15:31:16.228]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:16.228]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:16.228]                   3L)]
[15:31:16.228]             }
[15:31:16.228]             function(cond) {
[15:31:16.228]                 is_error <- inherits(cond, "error")
[15:31:16.228]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:16.228]                   NULL)
[15:31:16.228]                 if (is_error) {
[15:31:16.228]                   sessionInformation <- function() {
[15:31:16.228]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:16.228]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:16.228]                       search = base::search(), system = base::Sys.info())
[15:31:16.228]                   }
[15:31:16.228]                   ...future.conditions[[length(...future.conditions) + 
[15:31:16.228]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:16.228]                     cond$call), session = sessionInformation(), 
[15:31:16.228]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:16.228]                   signalCondition(cond)
[15:31:16.228]                 }
[15:31:16.228]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:16.228]                 "immediateCondition"))) {
[15:31:16.228]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:16.228]                   ...future.conditions[[length(...future.conditions) + 
[15:31:16.228]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:16.228]                   if (TRUE && !signal) {
[15:31:16.228]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:16.228]                     {
[15:31:16.228]                       inherits <- base::inherits
[15:31:16.228]                       invokeRestart <- base::invokeRestart
[15:31:16.228]                       is.null <- base::is.null
[15:31:16.228]                       muffled <- FALSE
[15:31:16.228]                       if (inherits(cond, "message")) {
[15:31:16.228]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:16.228]                         if (muffled) 
[15:31:16.228]                           invokeRestart("muffleMessage")
[15:31:16.228]                       }
[15:31:16.228]                       else if (inherits(cond, "warning")) {
[15:31:16.228]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:16.228]                         if (muffled) 
[15:31:16.228]                           invokeRestart("muffleWarning")
[15:31:16.228]                       }
[15:31:16.228]                       else if (inherits(cond, "condition")) {
[15:31:16.228]                         if (!is.null(pattern)) {
[15:31:16.228]                           computeRestarts <- base::computeRestarts
[15:31:16.228]                           grepl <- base::grepl
[15:31:16.228]                           restarts <- computeRestarts(cond)
[15:31:16.228]                           for (restart in restarts) {
[15:31:16.228]                             name <- restart$name
[15:31:16.228]                             if (is.null(name)) 
[15:31:16.228]                               next
[15:31:16.228]                             if (!grepl(pattern, name)) 
[15:31:16.228]                               next
[15:31:16.228]                             invokeRestart(restart)
[15:31:16.228]                             muffled <- TRUE
[15:31:16.228]                             break
[15:31:16.228]                           }
[15:31:16.228]                         }
[15:31:16.228]                       }
[15:31:16.228]                       invisible(muffled)
[15:31:16.228]                     }
[15:31:16.228]                     muffleCondition(cond, pattern = "^muffle")
[15:31:16.228]                   }
[15:31:16.228]                 }
[15:31:16.228]                 else {
[15:31:16.228]                   if (TRUE) {
[15:31:16.228]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:16.228]                     {
[15:31:16.228]                       inherits <- base::inherits
[15:31:16.228]                       invokeRestart <- base::invokeRestart
[15:31:16.228]                       is.null <- base::is.null
[15:31:16.228]                       muffled <- FALSE
[15:31:16.228]                       if (inherits(cond, "message")) {
[15:31:16.228]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:16.228]                         if (muffled) 
[15:31:16.228]                           invokeRestart("muffleMessage")
[15:31:16.228]                       }
[15:31:16.228]                       else if (inherits(cond, "warning")) {
[15:31:16.228]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:16.228]                         if (muffled) 
[15:31:16.228]                           invokeRestart("muffleWarning")
[15:31:16.228]                       }
[15:31:16.228]                       else if (inherits(cond, "condition")) {
[15:31:16.228]                         if (!is.null(pattern)) {
[15:31:16.228]                           computeRestarts <- base::computeRestarts
[15:31:16.228]                           grepl <- base::grepl
[15:31:16.228]                           restarts <- computeRestarts(cond)
[15:31:16.228]                           for (restart in restarts) {
[15:31:16.228]                             name <- restart$name
[15:31:16.228]                             if (is.null(name)) 
[15:31:16.228]                               next
[15:31:16.228]                             if (!grepl(pattern, name)) 
[15:31:16.228]                               next
[15:31:16.228]                             invokeRestart(restart)
[15:31:16.228]                             muffled <- TRUE
[15:31:16.228]                             break
[15:31:16.228]                           }
[15:31:16.228]                         }
[15:31:16.228]                       }
[15:31:16.228]                       invisible(muffled)
[15:31:16.228]                     }
[15:31:16.228]                     muffleCondition(cond, pattern = "^muffle")
[15:31:16.228]                   }
[15:31:16.228]                 }
[15:31:16.228]             }
[15:31:16.228]         }))
[15:31:16.228]     }, error = function(ex) {
[15:31:16.228]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:16.228]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:16.228]                 ...future.rng), started = ...future.startTime, 
[15:31:16.228]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:16.228]             version = "1.8"), class = "FutureResult")
[15:31:16.228]     }, finally = {
[15:31:16.228]         if (!identical(...future.workdir, getwd())) 
[15:31:16.228]             setwd(...future.workdir)
[15:31:16.228]         {
[15:31:16.228]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:16.228]                 ...future.oldOptions$nwarnings <- NULL
[15:31:16.228]             }
[15:31:16.228]             base::options(...future.oldOptions)
[15:31:16.228]             if (.Platform$OS.type == "windows") {
[15:31:16.228]                 old_names <- names(...future.oldEnvVars)
[15:31:16.228]                 envs <- base::Sys.getenv()
[15:31:16.228]                 names <- names(envs)
[15:31:16.228]                 common <- intersect(names, old_names)
[15:31:16.228]                 added <- setdiff(names, old_names)
[15:31:16.228]                 removed <- setdiff(old_names, names)
[15:31:16.228]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:16.228]                   envs[common]]
[15:31:16.228]                 NAMES <- toupper(changed)
[15:31:16.228]                 args <- list()
[15:31:16.228]                 for (kk in seq_along(NAMES)) {
[15:31:16.228]                   name <- changed[[kk]]
[15:31:16.228]                   NAME <- NAMES[[kk]]
[15:31:16.228]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:16.228]                     next
[15:31:16.228]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:16.228]                 }
[15:31:16.228]                 NAMES <- toupper(added)
[15:31:16.228]                 for (kk in seq_along(NAMES)) {
[15:31:16.228]                   name <- added[[kk]]
[15:31:16.228]                   NAME <- NAMES[[kk]]
[15:31:16.228]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:16.228]                     next
[15:31:16.228]                   args[[name]] <- ""
[15:31:16.228]                 }
[15:31:16.228]                 NAMES <- toupper(removed)
[15:31:16.228]                 for (kk in seq_along(NAMES)) {
[15:31:16.228]                   name <- removed[[kk]]
[15:31:16.228]                   NAME <- NAMES[[kk]]
[15:31:16.228]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:16.228]                     next
[15:31:16.228]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:16.228]                 }
[15:31:16.228]                 if (length(args) > 0) 
[15:31:16.228]                   base::do.call(base::Sys.setenv, args = args)
[15:31:16.228]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:16.228]             }
[15:31:16.228]             else {
[15:31:16.228]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:16.228]             }
[15:31:16.228]             {
[15:31:16.228]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:16.228]                   0L) {
[15:31:16.228]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:16.228]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:16.228]                   base::options(opts)
[15:31:16.228]                 }
[15:31:16.228]                 {
[15:31:16.228]                   {
[15:31:16.228]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:16.228]                     NULL
[15:31:16.228]                   }
[15:31:16.228]                   options(future.plan = NULL)
[15:31:16.228]                   if (is.na(NA_character_)) 
[15:31:16.228]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:16.228]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:16.228]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:16.228]                     .init = FALSE)
[15:31:16.228]                 }
[15:31:16.228]             }
[15:31:16.228]         }
[15:31:16.228]     })
[15:31:16.228]     if (TRUE) {
[15:31:16.228]         base::sink(type = "output", split = FALSE)
[15:31:16.228]         if (TRUE) {
[15:31:16.228]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:16.228]         }
[15:31:16.228]         else {
[15:31:16.228]             ...future.result["stdout"] <- base::list(NULL)
[15:31:16.228]         }
[15:31:16.228]         base::close(...future.stdout)
[15:31:16.228]         ...future.stdout <- NULL
[15:31:16.228]     }
[15:31:16.228]     ...future.result$conditions <- ...future.conditions
[15:31:16.228]     ...future.result$finished <- base::Sys.time()
[15:31:16.228]     ...future.result
[15:31:16.228] }
[15:31:16.240] Exporting 5 global objects (1.21 KiB) to cluster node #1 ...
[15:31:16.240] Exporting '...future.FUN' (1.21 KiB) to cluster node #1 ...
[15:31:16.241] Exporting '...future.FUN' (1.21 KiB) to cluster node #1 ... DONE
[15:31:16.242] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:31:16.243] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:31:16.243] Exporting '...future.elements_ii' (64 bytes) to cluster node #1 ...
[15:31:16.244] Exporting '...future.elements_ii' (64 bytes) to cluster node #1 ... DONE
[15:31:16.244] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:31:16.245] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:31:16.245] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:31:16.246] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:31:16.246] Exporting 5 global objects (1.21 KiB) to cluster node #1 ... DONE
[15:31:16.247] MultisessionFuture started
[15:31:16.248] - Launch lazy future ... done
[15:31:16.248] run() for 'MultisessionFuture' ... done
[15:31:16.248] Created future:
[15:31:16.269] receiveMessageFromWorker() for ClusterFuture ...
[15:31:16.269] - Validating connection of MultisessionFuture
[15:31:16.269] - received message: FutureResult
[15:31:16.270] - Received FutureResult
[15:31:16.270] - Erased future from FutureRegistry
[15:31:16.270] result() for ClusterFuture ...
[15:31:16.270] - result already collected: FutureResult
[15:31:16.271] result() for ClusterFuture ... done
[15:31:16.271] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:16.249] MultisessionFuture:
[15:31:16.249] Label: 'future_eapply-1'
[15:31:16.249] Expression:
[15:31:16.249] {
[15:31:16.249]     do.call(function(...) {
[15:31:16.249]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:16.249]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:16.249]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:16.249]             on.exit(options(oopts), add = TRUE)
[15:31:16.249]         }
[15:31:16.249]         {
[15:31:16.249]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:16.249]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:16.249]                 ...future.FUN(...future.X_jj, ...)
[15:31:16.249]             })
[15:31:16.249]         }
[15:31:16.249]     }, args = future.call.arguments)
[15:31:16.249] }
[15:31:16.249] Lazy evaluation: FALSE
[15:31:16.249] Asynchronous evaluation: TRUE
[15:31:16.249] Local evaluation: TRUE
[15:31:16.249] Environment: R_GlobalEnv
[15:31:16.249] Capture standard output: TRUE
[15:31:16.249] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:16.249] Globals: 5 objects totaling 1.27 KiB (function '...future.FUN' of 1.21 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 64 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:31:16.249] Packages: <none>
[15:31:16.249] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:16.249] Resolved: TRUE
[15:31:16.249] Value: <not collected>
[15:31:16.249] Conditions captured: <none>
[15:31:16.249] Early signaling: FALSE
[15:31:16.249] Owner process: 1f501b3c-5bdf-35ad-4a62-196ce98a2fc6
[15:31:16.249] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:16.271] Chunk #1 of 2 ... DONE
[15:31:16.272] Chunk #2 of 2 ...
[15:31:16.272]  - Finding globals in 'X' for chunk #2 ...
[15:31:16.272] getGlobalsAndPackages() ...
[15:31:16.272] Searching for globals...
[15:31:16.273] 
[15:31:16.273] Searching for globals ... DONE
[15:31:16.273] - globals: [0] <none>
[15:31:16.273] getGlobalsAndPackages() ... DONE
[15:31:16.274]    + additional globals found: [n=0] 
[15:31:16.274]    + additional namespaces needed: [n=0] 
[15:31:16.274]  - Finding globals in 'X' for chunk #2 ... DONE
[15:31:16.274]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:31:16.275]  - seeds: <none>
[15:31:16.275]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:16.275] getGlobalsAndPackages() ...
[15:31:16.275] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:16.275] Resolving globals: FALSE
[15:31:16.276] Tweak future expression to call with '...' arguments ...
[15:31:16.276] {
[15:31:16.276]     do.call(function(...) {
[15:31:16.276]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:16.276]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:16.276]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:16.276]             on.exit(options(oopts), add = TRUE)
[15:31:16.276]         }
[15:31:16.276]         {
[15:31:16.276]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:16.276]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:16.276]                 ...future.FUN(...future.X_jj, ...)
[15:31:16.276]             })
[15:31:16.276]         }
[15:31:16.276]     }, args = future.call.arguments)
[15:31:16.276] }
[15:31:16.276] Tweak future expression to call with '...' arguments ... DONE
[15:31:16.277] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:16.277] 
[15:31:16.278] getGlobalsAndPackages() ... DONE
[15:31:16.278] run() for 'Future' ...
[15:31:16.278] - state: 'created'
[15:31:16.279] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:16.295] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:16.295] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:31:16.295]   - Field: 'node'
[15:31:16.296]   - Field: 'label'
[15:31:16.296]   - Field: 'local'
[15:31:16.296]   - Field: 'owner'
[15:31:16.296]   - Field: 'envir'
[15:31:16.296]   - Field: 'workers'
[15:31:16.297]   - Field: 'packages'
[15:31:16.297]   - Field: 'gc'
[15:31:16.297]   - Field: 'conditions'
[15:31:16.297]   - Field: 'persistent'
[15:31:16.298]   - Field: 'expr'
[15:31:16.298]   - Field: 'uuid'
[15:31:16.298]   - Field: 'seed'
[15:31:16.298]   - Field: 'version'
[15:31:16.298]   - Field: 'result'
[15:31:16.299]   - Field: 'asynchronous'
[15:31:16.299]   - Field: 'calls'
[15:31:16.299]   - Field: 'globals'
[15:31:16.299]   - Field: 'stdout'
[15:31:16.299]   - Field: 'earlySignal'
[15:31:16.300]   - Field: 'lazy'
[15:31:16.300]   - Field: 'state'
[15:31:16.300] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:31:16.300] - Launch lazy future ...
[15:31:16.301] Packages needed by the future expression (n = 0): <none>
[15:31:16.301] Packages needed by future strategies (n = 0): <none>
[15:31:16.302] {
[15:31:16.302]     {
[15:31:16.302]         {
[15:31:16.302]             ...future.startTime <- base::Sys.time()
[15:31:16.302]             {
[15:31:16.302]                 {
[15:31:16.302]                   {
[15:31:16.302]                     {
[15:31:16.302]                       base::local({
[15:31:16.302]                         has_future <- base::requireNamespace("future", 
[15:31:16.302]                           quietly = TRUE)
[15:31:16.302]                         if (has_future) {
[15:31:16.302]                           ns <- base::getNamespace("future")
[15:31:16.302]                           version <- ns[[".package"]][["version"]]
[15:31:16.302]                           if (is.null(version)) 
[15:31:16.302]                             version <- utils::packageVersion("future")
[15:31:16.302]                         }
[15:31:16.302]                         else {
[15:31:16.302]                           version <- NULL
[15:31:16.302]                         }
[15:31:16.302]                         if (!has_future || version < "1.8.0") {
[15:31:16.302]                           info <- base::c(r_version = base::gsub("R version ", 
[15:31:16.302]                             "", base::R.version$version.string), 
[15:31:16.302]                             platform = base::sprintf("%s (%s-bit)", 
[15:31:16.302]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[15:31:16.302]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:16.302]                               "release", "version")], collapse = " "), 
[15:31:16.302]                             hostname = base::Sys.info()[["nodename"]])
[15:31:16.302]                           info <- base::sprintf("%s: %s", base::names(info), 
[15:31:16.302]                             info)
[15:31:16.302]                           info <- base::paste(info, collapse = "; ")
[15:31:16.302]                           if (!has_future) {
[15:31:16.302]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:16.302]                               info)
[15:31:16.302]                           }
[15:31:16.302]                           else {
[15:31:16.302]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:16.302]                               info, version)
[15:31:16.302]                           }
[15:31:16.302]                           base::stop(msg)
[15:31:16.302]                         }
[15:31:16.302]                       })
[15:31:16.302]                     }
[15:31:16.302]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:16.302]                     base::options(mc.cores = 1L)
[15:31:16.302]                   }
[15:31:16.302]                   ...future.strategy.old <- future::plan("list")
[15:31:16.302]                   options(future.plan = NULL)
[15:31:16.302]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:16.302]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:16.302]                 }
[15:31:16.302]                 ...future.workdir <- getwd()
[15:31:16.302]             }
[15:31:16.302]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:16.302]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:16.302]         }
[15:31:16.302]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:16.302]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:31:16.302]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:16.302]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:16.302]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:16.302]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:16.302]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:16.302]             base::names(...future.oldOptions))
[15:31:16.302]     }
[15:31:16.302]     if (FALSE) {
[15:31:16.302]     }
[15:31:16.302]     else {
[15:31:16.302]         if (TRUE) {
[15:31:16.302]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:16.302]                 open = "w")
[15:31:16.302]         }
[15:31:16.302]         else {
[15:31:16.302]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:16.302]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:16.302]         }
[15:31:16.302]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:16.302]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:16.302]             base::sink(type = "output", split = FALSE)
[15:31:16.302]             base::close(...future.stdout)
[15:31:16.302]         }, add = TRUE)
[15:31:16.302]     }
[15:31:16.302]     ...future.frame <- base::sys.nframe()
[15:31:16.302]     ...future.conditions <- base::list()
[15:31:16.302]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:16.302]     if (FALSE) {
[15:31:16.302]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:16.302]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:16.302]     }
[15:31:16.302]     ...future.result <- base::tryCatch({
[15:31:16.302]         base::withCallingHandlers({
[15:31:16.302]             ...future.value <- base::withVisible(base::local({
[15:31:16.302]                 ...future.makeSendCondition <- base::local({
[15:31:16.302]                   sendCondition <- NULL
[15:31:16.302]                   function(frame = 1L) {
[15:31:16.302]                     if (is.function(sendCondition)) 
[15:31:16.302]                       return(sendCondition)
[15:31:16.302]                     ns <- getNamespace("parallel")
[15:31:16.302]                     if (exists("sendData", mode = "function", 
[15:31:16.302]                       envir = ns)) {
[15:31:16.302]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:16.302]                         envir = ns)
[15:31:16.302]                       envir <- sys.frame(frame)
[15:31:16.302]                       master <- NULL
[15:31:16.302]                       while (!identical(envir, .GlobalEnv) && 
[15:31:16.302]                         !identical(envir, emptyenv())) {
[15:31:16.302]                         if (exists("master", mode = "list", envir = envir, 
[15:31:16.302]                           inherits = FALSE)) {
[15:31:16.302]                           master <- get("master", mode = "list", 
[15:31:16.302]                             envir = envir, inherits = FALSE)
[15:31:16.302]                           if (inherits(master, c("SOCKnode", 
[15:31:16.302]                             "SOCK0node"))) {
[15:31:16.302]                             sendCondition <<- function(cond) {
[15:31:16.302]                               data <- list(type = "VALUE", value = cond, 
[15:31:16.302]                                 success = TRUE)
[15:31:16.302]                               parallel_sendData(master, data)
[15:31:16.302]                             }
[15:31:16.302]                             return(sendCondition)
[15:31:16.302]                           }
[15:31:16.302]                         }
[15:31:16.302]                         frame <- frame + 1L
[15:31:16.302]                         envir <- sys.frame(frame)
[15:31:16.302]                       }
[15:31:16.302]                     }
[15:31:16.302]                     sendCondition <<- function(cond) NULL
[15:31:16.302]                   }
[15:31:16.302]                 })
[15:31:16.302]                 withCallingHandlers({
[15:31:16.302]                   {
[15:31:16.302]                     do.call(function(...) {
[15:31:16.302]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:16.302]                       if (!identical(...future.globals.maxSize.org, 
[15:31:16.302]                         ...future.globals.maxSize)) {
[15:31:16.302]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:16.302]                         on.exit(options(oopts), add = TRUE)
[15:31:16.302]                       }
[15:31:16.302]                       {
[15:31:16.302]                         lapply(seq_along(...future.elements_ii), 
[15:31:16.302]                           FUN = function(jj) {
[15:31:16.302]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:16.302]                             ...future.FUN(...future.X_jj, ...)
[15:31:16.302]                           })
[15:31:16.302]                       }
[15:31:16.302]                     }, args = future.call.arguments)
[15:31:16.302]                   }
[15:31:16.302]                 }, immediateCondition = function(cond) {
[15:31:16.302]                   sendCondition <- ...future.makeSendCondition()
[15:31:16.302]                   sendCondition(cond)
[15:31:16.302]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:16.302]                   {
[15:31:16.302]                     inherits <- base::inherits
[15:31:16.302]                     invokeRestart <- base::invokeRestart
[15:31:16.302]                     is.null <- base::is.null
[15:31:16.302]                     muffled <- FALSE
[15:31:16.302]                     if (inherits(cond, "message")) {
[15:31:16.302]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:16.302]                       if (muffled) 
[15:31:16.302]                         invokeRestart("muffleMessage")
[15:31:16.302]                     }
[15:31:16.302]                     else if (inherits(cond, "warning")) {
[15:31:16.302]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:16.302]                       if (muffled) 
[15:31:16.302]                         invokeRestart("muffleWarning")
[15:31:16.302]                     }
[15:31:16.302]                     else if (inherits(cond, "condition")) {
[15:31:16.302]                       if (!is.null(pattern)) {
[15:31:16.302]                         computeRestarts <- base::computeRestarts
[15:31:16.302]                         grepl <- base::grepl
[15:31:16.302]                         restarts <- computeRestarts(cond)
[15:31:16.302]                         for (restart in restarts) {
[15:31:16.302]                           name <- restart$name
[15:31:16.302]                           if (is.null(name)) 
[15:31:16.302]                             next
[15:31:16.302]                           if (!grepl(pattern, name)) 
[15:31:16.302]                             next
[15:31:16.302]                           invokeRestart(restart)
[15:31:16.302]                           muffled <- TRUE
[15:31:16.302]                           break
[15:31:16.302]                         }
[15:31:16.302]                       }
[15:31:16.302]                     }
[15:31:16.302]                     invisible(muffled)
[15:31:16.302]                   }
[15:31:16.302]                   muffleCondition(cond)
[15:31:16.302]                 })
[15:31:16.302]             }))
[15:31:16.302]             future::FutureResult(value = ...future.value$value, 
[15:31:16.302]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:16.302]                   ...future.rng), globalenv = if (FALSE) 
[15:31:16.302]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:16.302]                     ...future.globalenv.names))
[15:31:16.302]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:16.302]         }, condition = base::local({
[15:31:16.302]             c <- base::c
[15:31:16.302]             inherits <- base::inherits
[15:31:16.302]             invokeRestart <- base::invokeRestart
[15:31:16.302]             length <- base::length
[15:31:16.302]             list <- base::list
[15:31:16.302]             seq.int <- base::seq.int
[15:31:16.302]             signalCondition <- base::signalCondition
[15:31:16.302]             sys.calls <- base::sys.calls
[15:31:16.302]             `[[` <- base::`[[`
[15:31:16.302]             `+` <- base::`+`
[15:31:16.302]             `<<-` <- base::`<<-`
[15:31:16.302]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:16.302]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:16.302]                   3L)]
[15:31:16.302]             }
[15:31:16.302]             function(cond) {
[15:31:16.302]                 is_error <- inherits(cond, "error")
[15:31:16.302]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:16.302]                   NULL)
[15:31:16.302]                 if (is_error) {
[15:31:16.302]                   sessionInformation <- function() {
[15:31:16.302]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:16.302]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:16.302]                       search = base::search(), system = base::Sys.info())
[15:31:16.302]                   }
[15:31:16.302]                   ...future.conditions[[length(...future.conditions) + 
[15:31:16.302]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:16.302]                     cond$call), session = sessionInformation(), 
[15:31:16.302]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:16.302]                   signalCondition(cond)
[15:31:16.302]                 }
[15:31:16.302]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:16.302]                 "immediateCondition"))) {
[15:31:16.302]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:16.302]                   ...future.conditions[[length(...future.conditions) + 
[15:31:16.302]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:16.302]                   if (TRUE && !signal) {
[15:31:16.302]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:16.302]                     {
[15:31:16.302]                       inherits <- base::inherits
[15:31:16.302]                       invokeRestart <- base::invokeRestart
[15:31:16.302]                       is.null <- base::is.null
[15:31:16.302]                       muffled <- FALSE
[15:31:16.302]                       if (inherits(cond, "message")) {
[15:31:16.302]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:16.302]                         if (muffled) 
[15:31:16.302]                           invokeRestart("muffleMessage")
[15:31:16.302]                       }
[15:31:16.302]                       else if (inherits(cond, "warning")) {
[15:31:16.302]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:16.302]                         if (muffled) 
[15:31:16.302]                           invokeRestart("muffleWarning")
[15:31:16.302]                       }
[15:31:16.302]                       else if (inherits(cond, "condition")) {
[15:31:16.302]                         if (!is.null(pattern)) {
[15:31:16.302]                           computeRestarts <- base::computeRestarts
[15:31:16.302]                           grepl <- base::grepl
[15:31:16.302]                           restarts <- computeRestarts(cond)
[15:31:16.302]                           for (restart in restarts) {
[15:31:16.302]                             name <- restart$name
[15:31:16.302]                             if (is.null(name)) 
[15:31:16.302]                               next
[15:31:16.302]                             if (!grepl(pattern, name)) 
[15:31:16.302]                               next
[15:31:16.302]                             invokeRestart(restart)
[15:31:16.302]                             muffled <- TRUE
[15:31:16.302]                             break
[15:31:16.302]                           }
[15:31:16.302]                         }
[15:31:16.302]                       }
[15:31:16.302]                       invisible(muffled)
[15:31:16.302]                     }
[15:31:16.302]                     muffleCondition(cond, pattern = "^muffle")
[15:31:16.302]                   }
[15:31:16.302]                 }
[15:31:16.302]                 else {
[15:31:16.302]                   if (TRUE) {
[15:31:16.302]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:16.302]                     {
[15:31:16.302]                       inherits <- base::inherits
[15:31:16.302]                       invokeRestart <- base::invokeRestart
[15:31:16.302]                       is.null <- base::is.null
[15:31:16.302]                       muffled <- FALSE
[15:31:16.302]                       if (inherits(cond, "message")) {
[15:31:16.302]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:16.302]                         if (muffled) 
[15:31:16.302]                           invokeRestart("muffleMessage")
[15:31:16.302]                       }
[15:31:16.302]                       else if (inherits(cond, "warning")) {
[15:31:16.302]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:16.302]                         if (muffled) 
[15:31:16.302]                           invokeRestart("muffleWarning")
[15:31:16.302]                       }
[15:31:16.302]                       else if (inherits(cond, "condition")) {
[15:31:16.302]                         if (!is.null(pattern)) {
[15:31:16.302]                           computeRestarts <- base::computeRestarts
[15:31:16.302]                           grepl <- base::grepl
[15:31:16.302]                           restarts <- computeRestarts(cond)
[15:31:16.302]                           for (restart in restarts) {
[15:31:16.302]                             name <- restart$name
[15:31:16.302]                             if (is.null(name)) 
[15:31:16.302]                               next
[15:31:16.302]                             if (!grepl(pattern, name)) 
[15:31:16.302]                               next
[15:31:16.302]                             invokeRestart(restart)
[15:31:16.302]                             muffled <- TRUE
[15:31:16.302]                             break
[15:31:16.302]                           }
[15:31:16.302]                         }
[15:31:16.302]                       }
[15:31:16.302]                       invisible(muffled)
[15:31:16.302]                     }
[15:31:16.302]                     muffleCondition(cond, pattern = "^muffle")
[15:31:16.302]                   }
[15:31:16.302]                 }
[15:31:16.302]             }
[15:31:16.302]         }))
[15:31:16.302]     }, error = function(ex) {
[15:31:16.302]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:16.302]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:16.302]                 ...future.rng), started = ...future.startTime, 
[15:31:16.302]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:16.302]             version = "1.8"), class = "FutureResult")
[15:31:16.302]     }, finally = {
[15:31:16.302]         if (!identical(...future.workdir, getwd())) 
[15:31:16.302]             setwd(...future.workdir)
[15:31:16.302]         {
[15:31:16.302]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:16.302]                 ...future.oldOptions$nwarnings <- NULL
[15:31:16.302]             }
[15:31:16.302]             base::options(...future.oldOptions)
[15:31:16.302]             if (.Platform$OS.type == "windows") {
[15:31:16.302]                 old_names <- names(...future.oldEnvVars)
[15:31:16.302]                 envs <- base::Sys.getenv()
[15:31:16.302]                 names <- names(envs)
[15:31:16.302]                 common <- intersect(names, old_names)
[15:31:16.302]                 added <- setdiff(names, old_names)
[15:31:16.302]                 removed <- setdiff(old_names, names)
[15:31:16.302]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:16.302]                   envs[common]]
[15:31:16.302]                 NAMES <- toupper(changed)
[15:31:16.302]                 args <- list()
[15:31:16.302]                 for (kk in seq_along(NAMES)) {
[15:31:16.302]                   name <- changed[[kk]]
[15:31:16.302]                   NAME <- NAMES[[kk]]
[15:31:16.302]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:16.302]                     next
[15:31:16.302]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:16.302]                 }
[15:31:16.302]                 NAMES <- toupper(added)
[15:31:16.302]                 for (kk in seq_along(NAMES)) {
[15:31:16.302]                   name <- added[[kk]]
[15:31:16.302]                   NAME <- NAMES[[kk]]
[15:31:16.302]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:16.302]                     next
[15:31:16.302]                   args[[name]] <- ""
[15:31:16.302]                 }
[15:31:16.302]                 NAMES <- toupper(removed)
[15:31:16.302]                 for (kk in seq_along(NAMES)) {
[15:31:16.302]                   name <- removed[[kk]]
[15:31:16.302]                   NAME <- NAMES[[kk]]
[15:31:16.302]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:16.302]                     next
[15:31:16.302]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:16.302]                 }
[15:31:16.302]                 if (length(args) > 0) 
[15:31:16.302]                   base::do.call(base::Sys.setenv, args = args)
[15:31:16.302]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:16.302]             }
[15:31:16.302]             else {
[15:31:16.302]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:16.302]             }
[15:31:16.302]             {
[15:31:16.302]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:16.302]                   0L) {
[15:31:16.302]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:16.302]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:16.302]                   base::options(opts)
[15:31:16.302]                 }
[15:31:16.302]                 {
[15:31:16.302]                   {
[15:31:16.302]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:16.302]                     NULL
[15:31:16.302]                   }
[15:31:16.302]                   options(future.plan = NULL)
[15:31:16.302]                   if (is.na(NA_character_)) 
[15:31:16.302]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:16.302]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:16.302]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:16.302]                     .init = FALSE)
[15:31:16.302]                 }
[15:31:16.302]             }
[15:31:16.302]         }
[15:31:16.302]     })
[15:31:16.302]     if (TRUE) {
[15:31:16.302]         base::sink(type = "output", split = FALSE)
[15:31:16.302]         if (TRUE) {
[15:31:16.302]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:16.302]         }
[15:31:16.302]         else {
[15:31:16.302]             ...future.result["stdout"] <- base::list(NULL)
[15:31:16.302]         }
[15:31:16.302]         base::close(...future.stdout)
[15:31:16.302]         ...future.stdout <- NULL
[15:31:16.302]     }
[15:31:16.302]     ...future.result$conditions <- ...future.conditions
[15:31:16.302]     ...future.result$finished <- base::Sys.time()
[15:31:16.302]     ...future.result
[15:31:16.302] }
[15:31:16.308] Exporting 5 global objects (1.21 KiB) to cluster node #1 ...
[15:31:16.308] Exporting '...future.FUN' (1.21 KiB) to cluster node #1 ...
[15:31:16.309] Exporting '...future.FUN' (1.21 KiB) to cluster node #1 ... DONE
[15:31:16.309] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:31:16.310] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:31:16.310] Exporting '...future.elements_ii' (208 bytes) to cluster node #1 ...
[15:31:16.311] Exporting '...future.elements_ii' (208 bytes) to cluster node #1 ... DONE
[15:31:16.311] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:31:16.312] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:31:16.312] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:31:16.313] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:31:16.313] Exporting 5 global objects (1.21 KiB) to cluster node #1 ... DONE
[15:31:16.314] MultisessionFuture started
[15:31:16.314] - Launch lazy future ... done
[15:31:16.315] run() for 'MultisessionFuture' ... done
[15:31:16.315] Created future:
[15:31:16.341] receiveMessageFromWorker() for ClusterFuture ...
[15:31:16.341] - Validating connection of MultisessionFuture
[15:31:16.342] - received message: FutureResult
[15:31:16.342] - Received FutureResult
[15:31:16.342] - Erased future from FutureRegistry
[15:31:16.343] result() for ClusterFuture ...
[15:31:16.343] - result already collected: FutureResult
[15:31:16.343] result() for ClusterFuture ... done
[15:31:16.343] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:16.315] MultisessionFuture:
[15:31:16.315] Label: 'future_eapply-2'
[15:31:16.315] Expression:
[15:31:16.315] {
[15:31:16.315]     do.call(function(...) {
[15:31:16.315]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:16.315]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:16.315]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:16.315]             on.exit(options(oopts), add = TRUE)
[15:31:16.315]         }
[15:31:16.315]         {
[15:31:16.315]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:16.315]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:16.315]                 ...future.FUN(...future.X_jj, ...)
[15:31:16.315]             })
[15:31:16.315]         }
[15:31:16.315]     }, args = future.call.arguments)
[15:31:16.315] }
[15:31:16.315] Lazy evaluation: FALSE
[15:31:16.315] Asynchronous evaluation: TRUE
[15:31:16.315] Local evaluation: TRUE
[15:31:16.315] Environment: R_GlobalEnv
[15:31:16.315] Capture standard output: TRUE
[15:31:16.315] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:16.315] Globals: 5 objects totaling 1.41 KiB (function '...future.FUN' of 1.21 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 208 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:31:16.315] Packages: <none>
[15:31:16.315] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:16.315] Resolved: TRUE
[15:31:16.315] Value: <not collected>
[15:31:16.315] Conditions captured: <none>
[15:31:16.315] Early signaling: FALSE
[15:31:16.315] Owner process: 1f501b3c-5bdf-35ad-4a62-196ce98a2fc6
[15:31:16.315] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:16.344] Chunk #2 of 2 ... DONE
[15:31:16.344] Launching 2 futures (chunks) ... DONE
[15:31:16.344] Resolving 2 futures (chunks) ...
[15:31:16.344] resolve() on list ...
[15:31:16.344]  recursive: 0
[15:31:16.345]  length: 2
[15:31:16.345] 
[15:31:16.345] Future #1
[15:31:16.345] result() for ClusterFuture ...
[15:31:16.345] - result already collected: FutureResult
[15:31:16.346] result() for ClusterFuture ... done
[15:31:16.346] result() for ClusterFuture ...
[15:31:16.346] - result already collected: FutureResult
[15:31:16.346] result() for ClusterFuture ... done
[15:31:16.347] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:31:16.347] - nx: 2
[15:31:16.347] - relay: TRUE
[15:31:16.347] - stdout: TRUE
[15:31:16.347] - signal: TRUE
[15:31:16.348] - resignal: FALSE
[15:31:16.348] - force: TRUE
[15:31:16.348] - relayed: [n=2] FALSE, FALSE
[15:31:16.348] - queued futures: [n=2] FALSE, FALSE
[15:31:16.348]  - until=1
[15:31:16.348]  - relaying element #1
[15:31:16.349] result() for ClusterFuture ...
[15:31:16.349] - result already collected: FutureResult
[15:31:16.349] result() for ClusterFuture ... done
[15:31:16.349] result() for ClusterFuture ...
[15:31:16.349] - result already collected: FutureResult
[15:31:16.349] result() for ClusterFuture ... done
[15:31:16.350] result() for ClusterFuture ...
[15:31:16.350] - result already collected: FutureResult
[15:31:16.350] result() for ClusterFuture ... done
[15:31:16.350] result() for ClusterFuture ...
[15:31:16.350] - result already collected: FutureResult
[15:31:16.351] result() for ClusterFuture ... done
[15:31:16.351] - relayed: [n=2] TRUE, FALSE
[15:31:16.351] - queued futures: [n=2] TRUE, FALSE
[15:31:16.351] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:31:16.351]  length: 1 (resolved future 1)
[15:31:16.351] Future #2
[15:31:16.352] result() for ClusterFuture ...
[15:31:16.352] - result already collected: FutureResult
[15:31:16.352] result() for ClusterFuture ... done
[15:31:16.352] result() for ClusterFuture ...
[15:31:16.353] - result already collected: FutureResult
[15:31:16.353] result() for ClusterFuture ... done
[15:31:16.353] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:31:16.353] - nx: 2
[15:31:16.354] - relay: TRUE
[15:31:16.354] - stdout: TRUE
[15:31:16.354] - signal: TRUE
[15:31:16.355] - resignal: FALSE
[15:31:16.355] - force: TRUE
[15:31:16.355] - relayed: [n=2] TRUE, FALSE
[15:31:16.355] - queued futures: [n=2] TRUE, FALSE
[15:31:16.356]  - until=2
[15:31:16.356]  - relaying element #2
[15:31:16.356] result() for ClusterFuture ...
[15:31:16.357] - result already collected: FutureResult
[15:31:16.357] result() for ClusterFuture ... done
[15:31:16.357] result() for ClusterFuture ...
[15:31:16.358] - result already collected: FutureResult
[15:31:16.358] result() for ClusterFuture ... done
[15:31:16.358] result() for ClusterFuture ...
[15:31:16.359] - result already collected: FutureResult
[15:31:16.359] result() for ClusterFuture ... done
[15:31:16.359] result() for ClusterFuture ...
[15:31:16.359] - result already collected: FutureResult
[15:31:16.360] result() for ClusterFuture ... done
[15:31:16.360] - relayed: [n=2] TRUE, TRUE
[15:31:16.360] - queued futures: [n=2] TRUE, TRUE
[15:31:16.361] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:31:16.361]  length: 0 (resolved future 2)
[15:31:16.361] Relaying remaining futures
[15:31:16.362] signalConditionsASAP(NULL, pos=0) ...
[15:31:16.362] - nx: 2
[15:31:16.362] - relay: TRUE
[15:31:16.362] - stdout: TRUE
[15:31:16.363] - signal: TRUE
[15:31:16.363] - resignal: FALSE
[15:31:16.363] - force: TRUE
[15:31:16.364] - relayed: [n=2] TRUE, TRUE
[15:31:16.364] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:31:16.364] - relayed: [n=2] TRUE, TRUE
[15:31:16.364] - queued futures: [n=2] TRUE, TRUE
[15:31:16.364] signalConditionsASAP(NULL, pos=0) ... done
[15:31:16.365] resolve() on list ... DONE
[15:31:16.365] result() for ClusterFuture ...
[15:31:16.365] - result already collected: FutureResult
[15:31:16.365] result() for ClusterFuture ... done
[15:31:16.365] result() for ClusterFuture ...
[15:31:16.366] - result already collected: FutureResult
[15:31:16.366] result() for ClusterFuture ... done
[15:31:16.366] result() for ClusterFuture ...
[15:31:16.366] - result already collected: FutureResult
[15:31:16.366] result() for ClusterFuture ... done
[15:31:16.367] result() for ClusterFuture ...
[15:31:16.367] - result already collected: FutureResult
[15:31:16.367] result() for ClusterFuture ... done
[15:31:16.367]  - Number of value chunks collected: 2
[15:31:16.367] Resolving 2 futures (chunks) ... DONE
[15:31:16.367] Reducing values from 2 chunks ...
[15:31:16.368]  - Number of values collected after concatenation: 3
[15:31:16.368]  - Number of values expected: 3
[15:31:16.368] Reducing values from 2 chunks ... DONE
[15:31:16.368] future_lapply() ... DONE
[15:31:16.369] future_lapply() ...
[15:31:16.372] Number of chunks: 2
[15:31:16.372] getGlobalsAndPackagesXApply() ...
[15:31:16.373]  - future.globals: TRUE
[15:31:16.373] getGlobalsAndPackages() ...
[15:31:16.373] Searching for globals...
[15:31:16.374] - globals found: [2] 'FUN', 'UseMethod'
[15:31:16.375] Searching for globals ... DONE
[15:31:16.375] Resolving globals: FALSE
[15:31:16.375] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:31:16.376] The total size of the 1 globals exported for future expression ('FUN(probs = c(0.25, 0.5, 0.75))') 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:16.376] - globals: [1] 'FUN'
[15:31:16.377] - packages: [1] 'stats'
[15:31:16.377] getGlobalsAndPackages() ... DONE
[15:31:16.377]  - globals found/used: [n=1] 'FUN'
[15:31:16.378]  - needed namespaces: [n=1] 'stats'
[15:31:16.378] Finding globals ... DONE
[15:31:16.378]  - use_args: TRUE
[15:31:16.378]  - Getting '...' globals ...
[15:31:16.379] resolve() on list ...
[15:31:16.379]  recursive: 0
[15:31:16.380]  length: 1
[15:31:16.380]  elements: '...'
[15:31:16.380]  length: 0 (resolved future 1)
[15:31:16.380] resolve() on list ... DONE
[15:31:16.381]    - '...' content: [n=1] 'probs'
[15:31:16.381] List of 1
[15:31:16.381]  $ ...:List of 1
[15:31:16.381]   ..$ probs: num [1:3] 0.25 0.5 0.75
[15:31:16.381]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:16.381]  - attr(*, "where")=List of 1
[15:31:16.381]   ..$ ...:<environment: 0x000001b3f9923648> 
[15:31:16.381]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:16.381]  - attr(*, "resolved")= logi TRUE
[15:31:16.381]  - attr(*, "total_size")= num NA
[15:31:16.387]  - Getting '...' globals ... DONE
[15:31:16.387] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:16.387] List of 2
[15:31:16.387]  $ ...future.FUN:function (x, ...)  
[15:31:16.387]  $ ...          :List of 1
[15:31:16.387]   ..$ probs: num [1:3] 0.25 0.5 0.75
[15:31:16.387]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:16.387]  - attr(*, "where")=List of 2
[15:31:16.387]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:16.387]   ..$ ...          :<environment: 0x000001b3f9923648> 
[15:31:16.387]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:16.387]  - attr(*, "resolved")= logi FALSE
[15:31:16.387]  - attr(*, "total_size")= num 1328
[15:31:16.393] Packages to be attached in all futures: [n=1] 'stats'
[15:31:16.393] getGlobalsAndPackagesXApply() ... DONE
[15:31:16.394] Number of futures (= number of chunks): 2
[15:31:16.394] Launching 2 futures (chunks) ...
[15:31:16.395] Chunk #1 of 2 ...
[15:31:16.395]  - Finding globals in 'X' for chunk #1 ...
[15:31:16.395] getGlobalsAndPackages() ...
[15:31:16.395] Searching for globals...
[15:31:16.396] 
[15:31:16.396] Searching for globals ... DONE
[15:31:16.396] - globals: [0] <none>
[15:31:16.397] getGlobalsAndPackages() ... DONE
[15:31:16.397]    + additional globals found: [n=0] 
[15:31:16.397]    + additional namespaces needed: [n=0] 
[15:31:16.397]  - Finding globals in 'X' for chunk #1 ... DONE
[15:31:16.398]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:31:16.398]  - seeds: <none>
[15:31:16.398]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:16.399] getGlobalsAndPackages() ...
[15:31:16.399] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:16.399] Resolving globals: FALSE
[15:31:16.399] Tweak future expression to call with '...' arguments ...
[15:31:16.400] {
[15:31:16.400]     do.call(function(...) {
[15:31:16.400]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:16.400]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:16.400]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:16.400]             on.exit(options(oopts), add = TRUE)
[15:31:16.400]         }
[15:31:16.400]         {
[15:31:16.400]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:16.400]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:16.400]                 ...future.FUN(...future.X_jj, ...)
[15:31:16.400]             })
[15:31:16.400]         }
[15:31:16.400]     }, args = future.call.arguments)
[15:31:16.400] }
[15:31:16.400] Tweak future expression to call with '...' arguments ... DONE
[15:31:16.401] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:16.402] - packages: [1] 'stats'
[15:31:16.402] getGlobalsAndPackages() ... DONE
[15:31:16.403] run() for 'Future' ...
[15:31:16.403] - state: 'created'
[15:31:16.403] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:16.422] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:16.423] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:31:16.423]   - Field: 'node'
[15:31:16.424]   - Field: 'label'
[15:31:16.424]   - Field: 'local'
[15:31:16.424]   - Field: 'owner'
[15:31:16.425]   - Field: 'envir'
[15:31:16.425]   - Field: 'workers'
[15:31:16.425]   - Field: 'packages'
[15:31:16.426]   - Field: 'gc'
[15:31:16.426]   - Field: 'conditions'
[15:31:16.426]   - Field: 'persistent'
[15:31:16.427]   - Field: 'expr'
[15:31:16.427]   - Field: 'uuid'
[15:31:16.427]   - Field: 'seed'
[15:31:16.428]   - Field: 'version'
[15:31:16.428]   - Field: 'result'
[15:31:16.428]   - Field: 'asynchronous'
[15:31:16.428]   - Field: 'calls'
[15:31:16.429]   - Field: 'globals'
[15:31:16.429]   - Field: 'stdout'
[15:31:16.429]   - Field: 'earlySignal'
[15:31:16.430]   - Field: 'lazy'
[15:31:16.430]   - Field: 'state'
[15:31:16.430] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:31:16.431] - Launch lazy future ...
[15:31:16.431] Packages needed by the future expression (n = 1): 'stats'
[15:31:16.432] Packages needed by future strategies (n = 0): <none>
[15:31:16.433] {
[15:31:16.433]     {
[15:31:16.433]         {
[15:31:16.433]             ...future.startTime <- base::Sys.time()
[15:31:16.433]             {
[15:31:16.433]                 {
[15:31:16.433]                   {
[15:31:16.433]                     {
[15:31:16.433]                       {
[15:31:16.433]                         base::local({
[15:31:16.433]                           has_future <- base::requireNamespace("future", 
[15:31:16.433]                             quietly = TRUE)
[15:31:16.433]                           if (has_future) {
[15:31:16.433]                             ns <- base::getNamespace("future")
[15:31:16.433]                             version <- ns[[".package"]][["version"]]
[15:31:16.433]                             if (is.null(version)) 
[15:31:16.433]                               version <- utils::packageVersion("future")
[15:31:16.433]                           }
[15:31:16.433]                           else {
[15:31:16.433]                             version <- NULL
[15:31:16.433]                           }
[15:31:16.433]                           if (!has_future || version < "1.8.0") {
[15:31:16.433]                             info <- base::c(r_version = base::gsub("R version ", 
[15:31:16.433]                               "", base::R.version$version.string), 
[15:31:16.433]                               platform = base::sprintf("%s (%s-bit)", 
[15:31:16.433]                                 base::R.version$platform, 8 * 
[15:31:16.433]                                   base::.Machine$sizeof.pointer), 
[15:31:16.433]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:16.433]                                 "release", "version")], collapse = " "), 
[15:31:16.433]                               hostname = base::Sys.info()[["nodename"]])
[15:31:16.433]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:31:16.433]                               info)
[15:31:16.433]                             info <- base::paste(info, collapse = "; ")
[15:31:16.433]                             if (!has_future) {
[15:31:16.433]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:16.433]                                 info)
[15:31:16.433]                             }
[15:31:16.433]                             else {
[15:31:16.433]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:16.433]                                 info, version)
[15:31:16.433]                             }
[15:31:16.433]                             base::stop(msg)
[15:31:16.433]                           }
[15:31:16.433]                         })
[15:31:16.433]                       }
[15:31:16.433]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:16.433]                       base::options(mc.cores = 1L)
[15:31:16.433]                     }
[15:31:16.433]                     base::local({
[15:31:16.433]                       for (pkg in "stats") {
[15:31:16.433]                         base::loadNamespace(pkg)
[15:31:16.433]                         base::library(pkg, character.only = TRUE)
[15:31:16.433]                       }
[15:31:16.433]                     })
[15:31:16.433]                   }
[15:31:16.433]                   ...future.strategy.old <- future::plan("list")
[15:31:16.433]                   options(future.plan = NULL)
[15:31:16.433]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:16.433]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:16.433]                 }
[15:31:16.433]                 ...future.workdir <- getwd()
[15:31:16.433]             }
[15:31:16.433]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:16.433]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:16.433]         }
[15:31:16.433]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:16.433]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:31:16.433]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:16.433]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:16.433]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:16.433]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:16.433]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:16.433]             base::names(...future.oldOptions))
[15:31:16.433]     }
[15:31:16.433]     if (FALSE) {
[15:31:16.433]     }
[15:31:16.433]     else {
[15:31:16.433]         if (TRUE) {
[15:31:16.433]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:16.433]                 open = "w")
[15:31:16.433]         }
[15:31:16.433]         else {
[15:31:16.433]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:16.433]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:16.433]         }
[15:31:16.433]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:16.433]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:16.433]             base::sink(type = "output", split = FALSE)
[15:31:16.433]             base::close(...future.stdout)
[15:31:16.433]         }, add = TRUE)
[15:31:16.433]     }
[15:31:16.433]     ...future.frame <- base::sys.nframe()
[15:31:16.433]     ...future.conditions <- base::list()
[15:31:16.433]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:16.433]     if (FALSE) {
[15:31:16.433]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:16.433]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:16.433]     }
[15:31:16.433]     ...future.result <- base::tryCatch({
[15:31:16.433]         base::withCallingHandlers({
[15:31:16.433]             ...future.value <- base::withVisible(base::local({
[15:31:16.433]                 ...future.makeSendCondition <- base::local({
[15:31:16.433]                   sendCondition <- NULL
[15:31:16.433]                   function(frame = 1L) {
[15:31:16.433]                     if (is.function(sendCondition)) 
[15:31:16.433]                       return(sendCondition)
[15:31:16.433]                     ns <- getNamespace("parallel")
[15:31:16.433]                     if (exists("sendData", mode = "function", 
[15:31:16.433]                       envir = ns)) {
[15:31:16.433]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:16.433]                         envir = ns)
[15:31:16.433]                       envir <- sys.frame(frame)
[15:31:16.433]                       master <- NULL
[15:31:16.433]                       while (!identical(envir, .GlobalEnv) && 
[15:31:16.433]                         !identical(envir, emptyenv())) {
[15:31:16.433]                         if (exists("master", mode = "list", envir = envir, 
[15:31:16.433]                           inherits = FALSE)) {
[15:31:16.433]                           master <- get("master", mode = "list", 
[15:31:16.433]                             envir = envir, inherits = FALSE)
[15:31:16.433]                           if (inherits(master, c("SOCKnode", 
[15:31:16.433]                             "SOCK0node"))) {
[15:31:16.433]                             sendCondition <<- function(cond) {
[15:31:16.433]                               data <- list(type = "VALUE", value = cond, 
[15:31:16.433]                                 success = TRUE)
[15:31:16.433]                               parallel_sendData(master, data)
[15:31:16.433]                             }
[15:31:16.433]                             return(sendCondition)
[15:31:16.433]                           }
[15:31:16.433]                         }
[15:31:16.433]                         frame <- frame + 1L
[15:31:16.433]                         envir <- sys.frame(frame)
[15:31:16.433]                       }
[15:31:16.433]                     }
[15:31:16.433]                     sendCondition <<- function(cond) NULL
[15:31:16.433]                   }
[15:31:16.433]                 })
[15:31:16.433]                 withCallingHandlers({
[15:31:16.433]                   {
[15:31:16.433]                     do.call(function(...) {
[15:31:16.433]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:16.433]                       if (!identical(...future.globals.maxSize.org, 
[15:31:16.433]                         ...future.globals.maxSize)) {
[15:31:16.433]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:16.433]                         on.exit(options(oopts), add = TRUE)
[15:31:16.433]                       }
[15:31:16.433]                       {
[15:31:16.433]                         lapply(seq_along(...future.elements_ii), 
[15:31:16.433]                           FUN = function(jj) {
[15:31:16.433]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:16.433]                             ...future.FUN(...future.X_jj, ...)
[15:31:16.433]                           })
[15:31:16.433]                       }
[15:31:16.433]                     }, args = future.call.arguments)
[15:31:16.433]                   }
[15:31:16.433]                 }, immediateCondition = function(cond) {
[15:31:16.433]                   sendCondition <- ...future.makeSendCondition()
[15:31:16.433]                   sendCondition(cond)
[15:31:16.433]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:16.433]                   {
[15:31:16.433]                     inherits <- base::inherits
[15:31:16.433]                     invokeRestart <- base::invokeRestart
[15:31:16.433]                     is.null <- base::is.null
[15:31:16.433]                     muffled <- FALSE
[15:31:16.433]                     if (inherits(cond, "message")) {
[15:31:16.433]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:16.433]                       if (muffled) 
[15:31:16.433]                         invokeRestart("muffleMessage")
[15:31:16.433]                     }
[15:31:16.433]                     else if (inherits(cond, "warning")) {
[15:31:16.433]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:16.433]                       if (muffled) 
[15:31:16.433]                         invokeRestart("muffleWarning")
[15:31:16.433]                     }
[15:31:16.433]                     else if (inherits(cond, "condition")) {
[15:31:16.433]                       if (!is.null(pattern)) {
[15:31:16.433]                         computeRestarts <- base::computeRestarts
[15:31:16.433]                         grepl <- base::grepl
[15:31:16.433]                         restarts <- computeRestarts(cond)
[15:31:16.433]                         for (restart in restarts) {
[15:31:16.433]                           name <- restart$name
[15:31:16.433]                           if (is.null(name)) 
[15:31:16.433]                             next
[15:31:16.433]                           if (!grepl(pattern, name)) 
[15:31:16.433]                             next
[15:31:16.433]                           invokeRestart(restart)
[15:31:16.433]                           muffled <- TRUE
[15:31:16.433]                           break
[15:31:16.433]                         }
[15:31:16.433]                       }
[15:31:16.433]                     }
[15:31:16.433]                     invisible(muffled)
[15:31:16.433]                   }
[15:31:16.433]                   muffleCondition(cond)
[15:31:16.433]                 })
[15:31:16.433]             }))
[15:31:16.433]             future::FutureResult(value = ...future.value$value, 
[15:31:16.433]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:16.433]                   ...future.rng), globalenv = if (FALSE) 
[15:31:16.433]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:16.433]                     ...future.globalenv.names))
[15:31:16.433]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:16.433]         }, condition = base::local({
[15:31:16.433]             c <- base::c
[15:31:16.433]             inherits <- base::inherits
[15:31:16.433]             invokeRestart <- base::invokeRestart
[15:31:16.433]             length <- base::length
[15:31:16.433]             list <- base::list
[15:31:16.433]             seq.int <- base::seq.int
[15:31:16.433]             signalCondition <- base::signalCondition
[15:31:16.433]             sys.calls <- base::sys.calls
[15:31:16.433]             `[[` <- base::`[[`
[15:31:16.433]             `+` <- base::`+`
[15:31:16.433]             `<<-` <- base::`<<-`
[15:31:16.433]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:16.433]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:16.433]                   3L)]
[15:31:16.433]             }
[15:31:16.433]             function(cond) {
[15:31:16.433]                 is_error <- inherits(cond, "error")
[15:31:16.433]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:16.433]                   NULL)
[15:31:16.433]                 if (is_error) {
[15:31:16.433]                   sessionInformation <- function() {
[15:31:16.433]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:16.433]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:16.433]                       search = base::search(), system = base::Sys.info())
[15:31:16.433]                   }
[15:31:16.433]                   ...future.conditions[[length(...future.conditions) + 
[15:31:16.433]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:16.433]                     cond$call), session = sessionInformation(), 
[15:31:16.433]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:16.433]                   signalCondition(cond)
[15:31:16.433]                 }
[15:31:16.433]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:16.433]                 "immediateCondition"))) {
[15:31:16.433]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:16.433]                   ...future.conditions[[length(...future.conditions) + 
[15:31:16.433]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:16.433]                   if (TRUE && !signal) {
[15:31:16.433]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:16.433]                     {
[15:31:16.433]                       inherits <- base::inherits
[15:31:16.433]                       invokeRestart <- base::invokeRestart
[15:31:16.433]                       is.null <- base::is.null
[15:31:16.433]                       muffled <- FALSE
[15:31:16.433]                       if (inherits(cond, "message")) {
[15:31:16.433]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:16.433]                         if (muffled) 
[15:31:16.433]                           invokeRestart("muffleMessage")
[15:31:16.433]                       }
[15:31:16.433]                       else if (inherits(cond, "warning")) {
[15:31:16.433]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:16.433]                         if (muffled) 
[15:31:16.433]                           invokeRestart("muffleWarning")
[15:31:16.433]                       }
[15:31:16.433]                       else if (inherits(cond, "condition")) {
[15:31:16.433]                         if (!is.null(pattern)) {
[15:31:16.433]                           computeRestarts <- base::computeRestarts
[15:31:16.433]                           grepl <- base::grepl
[15:31:16.433]                           restarts <- computeRestarts(cond)
[15:31:16.433]                           for (restart in restarts) {
[15:31:16.433]                             name <- restart$name
[15:31:16.433]                             if (is.null(name)) 
[15:31:16.433]                               next
[15:31:16.433]                             if (!grepl(pattern, name)) 
[15:31:16.433]                               next
[15:31:16.433]                             invokeRestart(restart)
[15:31:16.433]                             muffled <- TRUE
[15:31:16.433]                             break
[15:31:16.433]                           }
[15:31:16.433]                         }
[15:31:16.433]                       }
[15:31:16.433]                       invisible(muffled)
[15:31:16.433]                     }
[15:31:16.433]                     muffleCondition(cond, pattern = "^muffle")
[15:31:16.433]                   }
[15:31:16.433]                 }
[15:31:16.433]                 else {
[15:31:16.433]                   if (TRUE) {
[15:31:16.433]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:16.433]                     {
[15:31:16.433]                       inherits <- base::inherits
[15:31:16.433]                       invokeRestart <- base::invokeRestart
[15:31:16.433]                       is.null <- base::is.null
[15:31:16.433]                       muffled <- FALSE
[15:31:16.433]                       if (inherits(cond, "message")) {
[15:31:16.433]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:16.433]                         if (muffled) 
[15:31:16.433]                           invokeRestart("muffleMessage")
[15:31:16.433]                       }
[15:31:16.433]                       else if (inherits(cond, "warning")) {
[15:31:16.433]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:16.433]                         if (muffled) 
[15:31:16.433]                           invokeRestart("muffleWarning")
[15:31:16.433]                       }
[15:31:16.433]                       else if (inherits(cond, "condition")) {
[15:31:16.433]                         if (!is.null(pattern)) {
[15:31:16.433]                           computeRestarts <- base::computeRestarts
[15:31:16.433]                           grepl <- base::grepl
[15:31:16.433]                           restarts <- computeRestarts(cond)
[15:31:16.433]                           for (restart in restarts) {
[15:31:16.433]                             name <- restart$name
[15:31:16.433]                             if (is.null(name)) 
[15:31:16.433]                               next
[15:31:16.433]                             if (!grepl(pattern, name)) 
[15:31:16.433]                               next
[15:31:16.433]                             invokeRestart(restart)
[15:31:16.433]                             muffled <- TRUE
[15:31:16.433]                             break
[15:31:16.433]                           }
[15:31:16.433]                         }
[15:31:16.433]                       }
[15:31:16.433]                       invisible(muffled)
[15:31:16.433]                     }
[15:31:16.433]                     muffleCondition(cond, pattern = "^muffle")
[15:31:16.433]                   }
[15:31:16.433]                 }
[15:31:16.433]             }
[15:31:16.433]         }))
[15:31:16.433]     }, error = function(ex) {
[15:31:16.433]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:16.433]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:16.433]                 ...future.rng), started = ...future.startTime, 
[15:31:16.433]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:16.433]             version = "1.8"), class = "FutureResult")
[15:31:16.433]     }, finally = {
[15:31:16.433]         if (!identical(...future.workdir, getwd())) 
[15:31:16.433]             setwd(...future.workdir)
[15:31:16.433]         {
[15:31:16.433]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:16.433]                 ...future.oldOptions$nwarnings <- NULL
[15:31:16.433]             }
[15:31:16.433]             base::options(...future.oldOptions)
[15:31:16.433]             if (.Platform$OS.type == "windows") {
[15:31:16.433]                 old_names <- names(...future.oldEnvVars)
[15:31:16.433]                 envs <- base::Sys.getenv()
[15:31:16.433]                 names <- names(envs)
[15:31:16.433]                 common <- intersect(names, old_names)
[15:31:16.433]                 added <- setdiff(names, old_names)
[15:31:16.433]                 removed <- setdiff(old_names, names)
[15:31:16.433]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:16.433]                   envs[common]]
[15:31:16.433]                 NAMES <- toupper(changed)
[15:31:16.433]                 args <- list()
[15:31:16.433]                 for (kk in seq_along(NAMES)) {
[15:31:16.433]                   name <- changed[[kk]]
[15:31:16.433]                   NAME <- NAMES[[kk]]
[15:31:16.433]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:16.433]                     next
[15:31:16.433]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:16.433]                 }
[15:31:16.433]                 NAMES <- toupper(added)
[15:31:16.433]                 for (kk in seq_along(NAMES)) {
[15:31:16.433]                   name <- added[[kk]]
[15:31:16.433]                   NAME <- NAMES[[kk]]
[15:31:16.433]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:16.433]                     next
[15:31:16.433]                   args[[name]] <- ""
[15:31:16.433]                 }
[15:31:16.433]                 NAMES <- toupper(removed)
[15:31:16.433]                 for (kk in seq_along(NAMES)) {
[15:31:16.433]                   name <- removed[[kk]]
[15:31:16.433]                   NAME <- NAMES[[kk]]
[15:31:16.433]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:16.433]                     next
[15:31:16.433]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:16.433]                 }
[15:31:16.433]                 if (length(args) > 0) 
[15:31:16.433]                   base::do.call(base::Sys.setenv, args = args)
[15:31:16.433]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:16.433]             }
[15:31:16.433]             else {
[15:31:16.433]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:16.433]             }
[15:31:16.433]             {
[15:31:16.433]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:16.433]                   0L) {
[15:31:16.433]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:16.433]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:16.433]                   base::options(opts)
[15:31:16.433]                 }
[15:31:16.433]                 {
[15:31:16.433]                   {
[15:31:16.433]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:16.433]                     NULL
[15:31:16.433]                   }
[15:31:16.433]                   options(future.plan = NULL)
[15:31:16.433]                   if (is.na(NA_character_)) 
[15:31:16.433]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:16.433]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:16.433]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:16.433]                     .init = FALSE)
[15:31:16.433]                 }
[15:31:16.433]             }
[15:31:16.433]         }
[15:31:16.433]     })
[15:31:16.433]     if (TRUE) {
[15:31:16.433]         base::sink(type = "output", split = FALSE)
[15:31:16.433]         if (TRUE) {
[15:31:16.433]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:16.433]         }
[15:31:16.433]         else {
[15:31:16.433]             ...future.result["stdout"] <- base::list(NULL)
[15:31:16.433]         }
[15:31:16.433]         base::close(...future.stdout)
[15:31:16.433]         ...future.stdout <- NULL
[15:31:16.433]     }
[15:31:16.433]     ...future.result$conditions <- ...future.conditions
[15:31:16.433]     ...future.result$finished <- base::Sys.time()
[15:31:16.433]     ...future.result
[15:31:16.433] }
[15:31:16.442] Exporting 5 global objects (1.30 KiB) to cluster node #1 ...
[15:31:16.443] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:31:16.444] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:31:16.445] Exporting 'future.call.arguments' (80 bytes) to cluster node #1 ...
[15:31:16.446] Exporting 'future.call.arguments' (80 bytes) to cluster node #1 ... DONE
[15:31:16.446] Exporting '...future.elements_ii' (64 bytes) to cluster node #1 ...
[15:31:16.447] Exporting '...future.elements_ii' (64 bytes) to cluster node #1 ... DONE
[15:31:16.447] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:31:16.448] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:31:16.448] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:31:16.451] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:31:16.451] Exporting 5 global objects (1.30 KiB) to cluster node #1 ... DONE
[15:31:16.452] MultisessionFuture started
[15:31:16.453] - Launch lazy future ... done
[15:31:16.453] run() for 'MultisessionFuture' ... done
[15:31:16.453] Created future:
[15:31:16.479] receiveMessageFromWorker() for ClusterFuture ...
[15:31:16.480] - Validating connection of MultisessionFuture
[15:31:16.480] - received message: FutureResult
[15:31:16.480] - Received FutureResult
[15:31:16.481] - Erased future from FutureRegistry
[15:31:16.481] result() for ClusterFuture ...
[15:31:16.481] - result already collected: FutureResult
[15:31:16.481] result() for ClusterFuture ... done
[15:31:16.481] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:16.454] MultisessionFuture:
[15:31:16.454] Label: 'future_eapply-1'
[15:31:16.454] Expression:
[15:31:16.454] {
[15:31:16.454]     do.call(function(...) {
[15:31:16.454]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:16.454]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:16.454]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:16.454]             on.exit(options(oopts), add = TRUE)
[15:31:16.454]         }
[15:31:16.454]         {
[15:31:16.454]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:16.454]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:16.454]                 ...future.FUN(...future.X_jj, ...)
[15:31:16.454]             })
[15:31:16.454]         }
[15:31:16.454]     }, args = future.call.arguments)
[15:31:16.454] }
[15:31:16.454] Lazy evaluation: FALSE
[15:31:16.454] Asynchronous evaluation: TRUE
[15:31:16.454] Local evaluation: TRUE
[15:31:16.454] Environment: R_GlobalEnv
[15:31:16.454] Capture standard output: TRUE
[15:31:16.454] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:16.454] Globals: 5 objects totaling 1.36 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 80 bytes, list '...future.elements_ii' of 64 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:31:16.454] Packages: 1 packages ('stats')
[15:31:16.454] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:16.454] Resolved: TRUE
[15:31:16.454] Value: <not collected>
[15:31:16.454] Conditions captured: <none>
[15:31:16.454] Early signaling: FALSE
[15:31:16.454] Owner process: 1f501b3c-5bdf-35ad-4a62-196ce98a2fc6
[15:31:16.454] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:16.482] Chunk #1 of 2 ... DONE
[15:31:16.482] Chunk #2 of 2 ...
[15:31:16.482]  - Finding globals in 'X' for chunk #2 ...
[15:31:16.483] getGlobalsAndPackages() ...
[15:31:16.483] Searching for globals...
[15:31:16.484] 
[15:31:16.484] Searching for globals ... DONE
[15:31:16.484] - globals: [0] <none>
[15:31:16.484] getGlobalsAndPackages() ... DONE
[15:31:16.484]    + additional globals found: [n=0] 
[15:31:16.484]    + additional namespaces needed: [n=0] 
[15:31:16.485]  - Finding globals in 'X' for chunk #2 ... DONE
[15:31:16.485]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:31:16.485]  - seeds: <none>
[15:31:16.485]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:16.485] getGlobalsAndPackages() ...
[15:31:16.486] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:16.486] Resolving globals: FALSE
[15:31:16.486] Tweak future expression to call with '...' arguments ...
[15:31:16.486] {
[15:31:16.486]     do.call(function(...) {
[15:31:16.486]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:16.486]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:16.486]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:16.486]             on.exit(options(oopts), add = TRUE)
[15:31:16.486]         }
[15:31:16.486]         {
[15:31:16.486]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:16.486]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:16.486]                 ...future.FUN(...future.X_jj, ...)
[15:31:16.486]             })
[15:31:16.486]         }
[15:31:16.486]     }, args = future.call.arguments)
[15:31:16.486] }
[15:31:16.487] Tweak future expression to call with '...' arguments ... DONE
[15:31:16.487] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:16.487] - packages: [1] 'stats'
[15:31:16.488] getGlobalsAndPackages() ... DONE
[15:31:16.488] run() for 'Future' ...
[15:31:16.488] - state: 'created'
[15:31:16.488] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:16.504] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:16.504] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:31:16.505]   - Field: 'node'
[15:31:16.505]   - Field: 'label'
[15:31:16.505]   - Field: 'local'
[15:31:16.506]   - Field: 'owner'
[15:31:16.506]   - Field: 'envir'
[15:31:16.506]   - Field: 'workers'
[15:31:16.506]   - Field: 'packages'
[15:31:16.507]   - Field: 'gc'
[15:31:16.507]   - Field: 'conditions'
[15:31:16.507]   - Field: 'persistent'
[15:31:16.508]   - Field: 'expr'
[15:31:16.508]   - Field: 'uuid'
[15:31:16.508]   - Field: 'seed'
[15:31:16.508]   - Field: 'version'
[15:31:16.509]   - Field: 'result'
[15:31:16.509]   - Field: 'asynchronous'
[15:31:16.509]   - Field: 'calls'
[15:31:16.510]   - Field: 'globals'
[15:31:16.510]   - Field: 'stdout'
[15:31:16.510]   - Field: 'earlySignal'
[15:31:16.510]   - Field: 'lazy'
[15:31:16.511]   - Field: 'state'
[15:31:16.511] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:31:16.511] - Launch lazy future ...
[15:31:16.512] Packages needed by the future expression (n = 1): 'stats'
[15:31:16.512] Packages needed by future strategies (n = 0): <none>
[15:31:16.514] {
[15:31:16.514]     {
[15:31:16.514]         {
[15:31:16.514]             ...future.startTime <- base::Sys.time()
[15:31:16.514]             {
[15:31:16.514]                 {
[15:31:16.514]                   {
[15:31:16.514]                     {
[15:31:16.514]                       {
[15:31:16.514]                         base::local({
[15:31:16.514]                           has_future <- base::requireNamespace("future", 
[15:31:16.514]                             quietly = TRUE)
[15:31:16.514]                           if (has_future) {
[15:31:16.514]                             ns <- base::getNamespace("future")
[15:31:16.514]                             version <- ns[[".package"]][["version"]]
[15:31:16.514]                             if (is.null(version)) 
[15:31:16.514]                               version <- utils::packageVersion("future")
[15:31:16.514]                           }
[15:31:16.514]                           else {
[15:31:16.514]                             version <- NULL
[15:31:16.514]                           }
[15:31:16.514]                           if (!has_future || version < "1.8.0") {
[15:31:16.514]                             info <- base::c(r_version = base::gsub("R version ", 
[15:31:16.514]                               "", base::R.version$version.string), 
[15:31:16.514]                               platform = base::sprintf("%s (%s-bit)", 
[15:31:16.514]                                 base::R.version$platform, 8 * 
[15:31:16.514]                                   base::.Machine$sizeof.pointer), 
[15:31:16.514]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:16.514]                                 "release", "version")], collapse = " "), 
[15:31:16.514]                               hostname = base::Sys.info()[["nodename"]])
[15:31:16.514]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:31:16.514]                               info)
[15:31:16.514]                             info <- base::paste(info, collapse = "; ")
[15:31:16.514]                             if (!has_future) {
[15:31:16.514]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:16.514]                                 info)
[15:31:16.514]                             }
[15:31:16.514]                             else {
[15:31:16.514]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:16.514]                                 info, version)
[15:31:16.514]                             }
[15:31:16.514]                             base::stop(msg)
[15:31:16.514]                           }
[15:31:16.514]                         })
[15:31:16.514]                       }
[15:31:16.514]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:16.514]                       base::options(mc.cores = 1L)
[15:31:16.514]                     }
[15:31:16.514]                     base::local({
[15:31:16.514]                       for (pkg in "stats") {
[15:31:16.514]                         base::loadNamespace(pkg)
[15:31:16.514]                         base::library(pkg, character.only = TRUE)
[15:31:16.514]                       }
[15:31:16.514]                     })
[15:31:16.514]                   }
[15:31:16.514]                   ...future.strategy.old <- future::plan("list")
[15:31:16.514]                   options(future.plan = NULL)
[15:31:16.514]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:16.514]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:16.514]                 }
[15:31:16.514]                 ...future.workdir <- getwd()
[15:31:16.514]             }
[15:31:16.514]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:16.514]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:16.514]         }
[15:31:16.514]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:16.514]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:31:16.514]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:16.514]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:16.514]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:16.514]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:16.514]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:16.514]             base::names(...future.oldOptions))
[15:31:16.514]     }
[15:31:16.514]     if (FALSE) {
[15:31:16.514]     }
[15:31:16.514]     else {
[15:31:16.514]         if (TRUE) {
[15:31:16.514]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:16.514]                 open = "w")
[15:31:16.514]         }
[15:31:16.514]         else {
[15:31:16.514]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:16.514]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:16.514]         }
[15:31:16.514]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:16.514]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:16.514]             base::sink(type = "output", split = FALSE)
[15:31:16.514]             base::close(...future.stdout)
[15:31:16.514]         }, add = TRUE)
[15:31:16.514]     }
[15:31:16.514]     ...future.frame <- base::sys.nframe()
[15:31:16.514]     ...future.conditions <- base::list()
[15:31:16.514]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:16.514]     if (FALSE) {
[15:31:16.514]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:16.514]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:16.514]     }
[15:31:16.514]     ...future.result <- base::tryCatch({
[15:31:16.514]         base::withCallingHandlers({
[15:31:16.514]             ...future.value <- base::withVisible(base::local({
[15:31:16.514]                 ...future.makeSendCondition <- base::local({
[15:31:16.514]                   sendCondition <- NULL
[15:31:16.514]                   function(frame = 1L) {
[15:31:16.514]                     if (is.function(sendCondition)) 
[15:31:16.514]                       return(sendCondition)
[15:31:16.514]                     ns <- getNamespace("parallel")
[15:31:16.514]                     if (exists("sendData", mode = "function", 
[15:31:16.514]                       envir = ns)) {
[15:31:16.514]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:16.514]                         envir = ns)
[15:31:16.514]                       envir <- sys.frame(frame)
[15:31:16.514]                       master <- NULL
[15:31:16.514]                       while (!identical(envir, .GlobalEnv) && 
[15:31:16.514]                         !identical(envir, emptyenv())) {
[15:31:16.514]                         if (exists("master", mode = "list", envir = envir, 
[15:31:16.514]                           inherits = FALSE)) {
[15:31:16.514]                           master <- get("master", mode = "list", 
[15:31:16.514]                             envir = envir, inherits = FALSE)
[15:31:16.514]                           if (inherits(master, c("SOCKnode", 
[15:31:16.514]                             "SOCK0node"))) {
[15:31:16.514]                             sendCondition <<- function(cond) {
[15:31:16.514]                               data <- list(type = "VALUE", value = cond, 
[15:31:16.514]                                 success = TRUE)
[15:31:16.514]                               parallel_sendData(master, data)
[15:31:16.514]                             }
[15:31:16.514]                             return(sendCondition)
[15:31:16.514]                           }
[15:31:16.514]                         }
[15:31:16.514]                         frame <- frame + 1L
[15:31:16.514]                         envir <- sys.frame(frame)
[15:31:16.514]                       }
[15:31:16.514]                     }
[15:31:16.514]                     sendCondition <<- function(cond) NULL
[15:31:16.514]                   }
[15:31:16.514]                 })
[15:31:16.514]                 withCallingHandlers({
[15:31:16.514]                   {
[15:31:16.514]                     do.call(function(...) {
[15:31:16.514]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:16.514]                       if (!identical(...future.globals.maxSize.org, 
[15:31:16.514]                         ...future.globals.maxSize)) {
[15:31:16.514]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:16.514]                         on.exit(options(oopts), add = TRUE)
[15:31:16.514]                       }
[15:31:16.514]                       {
[15:31:16.514]                         lapply(seq_along(...future.elements_ii), 
[15:31:16.514]                           FUN = function(jj) {
[15:31:16.514]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:16.514]                             ...future.FUN(...future.X_jj, ...)
[15:31:16.514]                           })
[15:31:16.514]                       }
[15:31:16.514]                     }, args = future.call.arguments)
[15:31:16.514]                   }
[15:31:16.514]                 }, immediateCondition = function(cond) {
[15:31:16.514]                   sendCondition <- ...future.makeSendCondition()
[15:31:16.514]                   sendCondition(cond)
[15:31:16.514]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:16.514]                   {
[15:31:16.514]                     inherits <- base::inherits
[15:31:16.514]                     invokeRestart <- base::invokeRestart
[15:31:16.514]                     is.null <- base::is.null
[15:31:16.514]                     muffled <- FALSE
[15:31:16.514]                     if (inherits(cond, "message")) {
[15:31:16.514]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:16.514]                       if (muffled) 
[15:31:16.514]                         invokeRestart("muffleMessage")
[15:31:16.514]                     }
[15:31:16.514]                     else if (inherits(cond, "warning")) {
[15:31:16.514]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:16.514]                       if (muffled) 
[15:31:16.514]                         invokeRestart("muffleWarning")
[15:31:16.514]                     }
[15:31:16.514]                     else if (inherits(cond, "condition")) {
[15:31:16.514]                       if (!is.null(pattern)) {
[15:31:16.514]                         computeRestarts <- base::computeRestarts
[15:31:16.514]                         grepl <- base::grepl
[15:31:16.514]                         restarts <- computeRestarts(cond)
[15:31:16.514]                         for (restart in restarts) {
[15:31:16.514]                           name <- restart$name
[15:31:16.514]                           if (is.null(name)) 
[15:31:16.514]                             next
[15:31:16.514]                           if (!grepl(pattern, name)) 
[15:31:16.514]                             next
[15:31:16.514]                           invokeRestart(restart)
[15:31:16.514]                           muffled <- TRUE
[15:31:16.514]                           break
[15:31:16.514]                         }
[15:31:16.514]                       }
[15:31:16.514]                     }
[15:31:16.514]                     invisible(muffled)
[15:31:16.514]                   }
[15:31:16.514]                   muffleCondition(cond)
[15:31:16.514]                 })
[15:31:16.514]             }))
[15:31:16.514]             future::FutureResult(value = ...future.value$value, 
[15:31:16.514]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:16.514]                   ...future.rng), globalenv = if (FALSE) 
[15:31:16.514]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:16.514]                     ...future.globalenv.names))
[15:31:16.514]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:16.514]         }, condition = base::local({
[15:31:16.514]             c <- base::c
[15:31:16.514]             inherits <- base::inherits
[15:31:16.514]             invokeRestart <- base::invokeRestart
[15:31:16.514]             length <- base::length
[15:31:16.514]             list <- base::list
[15:31:16.514]             seq.int <- base::seq.int
[15:31:16.514]             signalCondition <- base::signalCondition
[15:31:16.514]             sys.calls <- base::sys.calls
[15:31:16.514]             `[[` <- base::`[[`
[15:31:16.514]             `+` <- base::`+`
[15:31:16.514]             `<<-` <- base::`<<-`
[15:31:16.514]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:16.514]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:16.514]                   3L)]
[15:31:16.514]             }
[15:31:16.514]             function(cond) {
[15:31:16.514]                 is_error <- inherits(cond, "error")
[15:31:16.514]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:16.514]                   NULL)
[15:31:16.514]                 if (is_error) {
[15:31:16.514]                   sessionInformation <- function() {
[15:31:16.514]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:16.514]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:16.514]                       search = base::search(), system = base::Sys.info())
[15:31:16.514]                   }
[15:31:16.514]                   ...future.conditions[[length(...future.conditions) + 
[15:31:16.514]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:16.514]                     cond$call), session = sessionInformation(), 
[15:31:16.514]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:16.514]                   signalCondition(cond)
[15:31:16.514]                 }
[15:31:16.514]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:16.514]                 "immediateCondition"))) {
[15:31:16.514]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:16.514]                   ...future.conditions[[length(...future.conditions) + 
[15:31:16.514]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:16.514]                   if (TRUE && !signal) {
[15:31:16.514]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:16.514]                     {
[15:31:16.514]                       inherits <- base::inherits
[15:31:16.514]                       invokeRestart <- base::invokeRestart
[15:31:16.514]                       is.null <- base::is.null
[15:31:16.514]                       muffled <- FALSE
[15:31:16.514]                       if (inherits(cond, "message")) {
[15:31:16.514]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:16.514]                         if (muffled) 
[15:31:16.514]                           invokeRestart("muffleMessage")
[15:31:16.514]                       }
[15:31:16.514]                       else if (inherits(cond, "warning")) {
[15:31:16.514]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:16.514]                         if (muffled) 
[15:31:16.514]                           invokeRestart("muffleWarning")
[15:31:16.514]                       }
[15:31:16.514]                       else if (inherits(cond, "condition")) {
[15:31:16.514]                         if (!is.null(pattern)) {
[15:31:16.514]                           computeRestarts <- base::computeRestarts
[15:31:16.514]                           grepl <- base::grepl
[15:31:16.514]                           restarts <- computeRestarts(cond)
[15:31:16.514]                           for (restart in restarts) {
[15:31:16.514]                             name <- restart$name
[15:31:16.514]                             if (is.null(name)) 
[15:31:16.514]                               next
[15:31:16.514]                             if (!grepl(pattern, name)) 
[15:31:16.514]                               next
[15:31:16.514]                             invokeRestart(restart)
[15:31:16.514]                             muffled <- TRUE
[15:31:16.514]                             break
[15:31:16.514]                           }
[15:31:16.514]                         }
[15:31:16.514]                       }
[15:31:16.514]                       invisible(muffled)
[15:31:16.514]                     }
[15:31:16.514]                     muffleCondition(cond, pattern = "^muffle")
[15:31:16.514]                   }
[15:31:16.514]                 }
[15:31:16.514]                 else {
[15:31:16.514]                   if (TRUE) {
[15:31:16.514]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:16.514]                     {
[15:31:16.514]                       inherits <- base::inherits
[15:31:16.514]                       invokeRestart <- base::invokeRestart
[15:31:16.514]                       is.null <- base::is.null
[15:31:16.514]                       muffled <- FALSE
[15:31:16.514]                       if (inherits(cond, "message")) {
[15:31:16.514]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:16.514]                         if (muffled) 
[15:31:16.514]                           invokeRestart("muffleMessage")
[15:31:16.514]                       }
[15:31:16.514]                       else if (inherits(cond, "warning")) {
[15:31:16.514]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:16.514]                         if (muffled) 
[15:31:16.514]                           invokeRestart("muffleWarning")
[15:31:16.514]                       }
[15:31:16.514]                       else if (inherits(cond, "condition")) {
[15:31:16.514]                         if (!is.null(pattern)) {
[15:31:16.514]                           computeRestarts <- base::computeRestarts
[15:31:16.514]                           grepl <- base::grepl
[15:31:16.514]                           restarts <- computeRestarts(cond)
[15:31:16.514]                           for (restart in restarts) {
[15:31:16.514]                             name <- restart$name
[15:31:16.514]                             if (is.null(name)) 
[15:31:16.514]                               next
[15:31:16.514]                             if (!grepl(pattern, name)) 
[15:31:16.514]                               next
[15:31:16.514]                             invokeRestart(restart)
[15:31:16.514]                             muffled <- TRUE
[15:31:16.514]                             break
[15:31:16.514]                           }
[15:31:16.514]                         }
[15:31:16.514]                       }
[15:31:16.514]                       invisible(muffled)
[15:31:16.514]                     }
[15:31:16.514]                     muffleCondition(cond, pattern = "^muffle")
[15:31:16.514]                   }
[15:31:16.514]                 }
[15:31:16.514]             }
[15:31:16.514]         }))
[15:31:16.514]     }, error = function(ex) {
[15:31:16.514]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:16.514]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:16.514]                 ...future.rng), started = ...future.startTime, 
[15:31:16.514]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:16.514]             version = "1.8"), class = "FutureResult")
[15:31:16.514]     }, finally = {
[15:31:16.514]         if (!identical(...future.workdir, getwd())) 
[15:31:16.514]             setwd(...future.workdir)
[15:31:16.514]         {
[15:31:16.514]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:16.514]                 ...future.oldOptions$nwarnings <- NULL
[15:31:16.514]             }
[15:31:16.514]             base::options(...future.oldOptions)
[15:31:16.514]             if (.Platform$OS.type == "windows") {
[15:31:16.514]                 old_names <- names(...future.oldEnvVars)
[15:31:16.514]                 envs <- base::Sys.getenv()
[15:31:16.514]                 names <- names(envs)
[15:31:16.514]                 common <- intersect(names, old_names)
[15:31:16.514]                 added <- setdiff(names, old_names)
[15:31:16.514]                 removed <- setdiff(old_names, names)
[15:31:16.514]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:16.514]                   envs[common]]
[15:31:16.514]                 NAMES <- toupper(changed)
[15:31:16.514]                 args <- list()
[15:31:16.514]                 for (kk in seq_along(NAMES)) {
[15:31:16.514]                   name <- changed[[kk]]
[15:31:16.514]                   NAME <- NAMES[[kk]]
[15:31:16.514]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:16.514]                     next
[15:31:16.514]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:16.514]                 }
[15:31:16.514]                 NAMES <- toupper(added)
[15:31:16.514]                 for (kk in seq_along(NAMES)) {
[15:31:16.514]                   name <- added[[kk]]
[15:31:16.514]                   NAME <- NAMES[[kk]]
[15:31:16.514]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:16.514]                     next
[15:31:16.514]                   args[[name]] <- ""
[15:31:16.514]                 }
[15:31:16.514]                 NAMES <- toupper(removed)
[15:31:16.514]                 for (kk in seq_along(NAMES)) {
[15:31:16.514]                   name <- removed[[kk]]
[15:31:16.514]                   NAME <- NAMES[[kk]]
[15:31:16.514]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:16.514]                     next
[15:31:16.514]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:16.514]                 }
[15:31:16.514]                 if (length(args) > 0) 
[15:31:16.514]                   base::do.call(base::Sys.setenv, args = args)
[15:31:16.514]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:16.514]             }
[15:31:16.514]             else {
[15:31:16.514]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:16.514]             }
[15:31:16.514]             {
[15:31:16.514]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:16.514]                   0L) {
[15:31:16.514]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:16.514]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:16.514]                   base::options(opts)
[15:31:16.514]                 }
[15:31:16.514]                 {
[15:31:16.514]                   {
[15:31:16.514]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:16.514]                     NULL
[15:31:16.514]                   }
[15:31:16.514]                   options(future.plan = NULL)
[15:31:16.514]                   if (is.na(NA_character_)) 
[15:31:16.514]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:16.514]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:16.514]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:16.514]                     .init = FALSE)
[15:31:16.514]                 }
[15:31:16.514]             }
[15:31:16.514]         }
[15:31:16.514]     })
[15:31:16.514]     if (TRUE) {
[15:31:16.514]         base::sink(type = "output", split = FALSE)
[15:31:16.514]         if (TRUE) {
[15:31:16.514]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:16.514]         }
[15:31:16.514]         else {
[15:31:16.514]             ...future.result["stdout"] <- base::list(NULL)
[15:31:16.514]         }
[15:31:16.514]         base::close(...future.stdout)
[15:31:16.514]         ...future.stdout <- NULL
[15:31:16.514]     }
[15:31:16.514]     ...future.result$conditions <- ...future.conditions
[15:31:16.514]     ...future.result$finished <- base::Sys.time()
[15:31:16.514]     ...future.result
[15:31:16.514] }
[15:31:16.523] Exporting 5 global objects (1.30 KiB) to cluster node #1 ...
[15:31:16.523] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:31:16.524] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:31:16.524] Exporting 'future.call.arguments' (80 bytes) to cluster node #1 ...
[15:31:16.525] Exporting 'future.call.arguments' (80 bytes) to cluster node #1 ... DONE
[15:31:16.525] Exporting '...future.elements_ii' (208 bytes) to cluster node #1 ...
[15:31:16.526] Exporting '...future.elements_ii' (208 bytes) to cluster node #1 ... DONE
[15:31:16.526] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:31:16.527] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:31:16.527] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:31:16.528] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:31:16.528] Exporting 5 global objects (1.30 KiB) to cluster node #1 ... DONE
[15:31:16.529] MultisessionFuture started
[15:31:16.529] - Launch lazy future ... done
[15:31:16.530] run() for 'MultisessionFuture' ... done
[15:31:16.530] Created future:
[15:31:16.560] receiveMessageFromWorker() for ClusterFuture ...
[15:31:16.560] - Validating connection of MultisessionFuture
[15:31:16.560] - received message: FutureResult
[15:31:16.561] - Received FutureResult
[15:31:16.561] - Erased future from FutureRegistry
[15:31:16.562] result() for ClusterFuture ...
[15:31:16.562] - result already collected: FutureResult
[15:31:16.562] result() for ClusterFuture ... done
[15:31:16.562] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:16.530] MultisessionFuture:
[15:31:16.530] Label: 'future_eapply-2'
[15:31:16.530] Expression:
[15:31:16.530] {
[15:31:16.530]     do.call(function(...) {
[15:31:16.530]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:16.530]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:16.530]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:16.530]             on.exit(options(oopts), add = TRUE)
[15:31:16.530]         }
[15:31:16.530]         {
[15:31:16.530]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:16.530]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:16.530]                 ...future.FUN(...future.X_jj, ...)
[15:31:16.530]             })
[15:31:16.530]         }
[15:31:16.530]     }, args = future.call.arguments)
[15:31:16.530] }
[15:31:16.530] Lazy evaluation: FALSE
[15:31:16.530] Asynchronous evaluation: TRUE
[15:31:16.530] Local evaluation: TRUE
[15:31:16.530] Environment: R_GlobalEnv
[15:31:16.530] Capture standard output: TRUE
[15:31:16.530] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:16.530] Globals: 5 objects totaling 1.50 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 80 bytes, list '...future.elements_ii' of 208 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:31:16.530] Packages: 1 packages ('stats')
[15:31:16.530] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:16.530] Resolved: TRUE
[15:31:16.530] Value: <not collected>
[15:31:16.530] Conditions captured: <none>
[15:31:16.530] Early signaling: FALSE
[15:31:16.530] Owner process: 1f501b3c-5bdf-35ad-4a62-196ce98a2fc6
[15:31:16.530] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:16.563] Chunk #2 of 2 ... DONE
[15:31:16.563] Launching 2 futures (chunks) ... DONE
[15:31:16.564] Resolving 2 futures (chunks) ...
[15:31:16.564] resolve() on list ...
[15:31:16.564]  recursive: 0
[15:31:16.564]  length: 2
[15:31:16.564] 
[15:31:16.565] Future #1
[15:31:16.565] result() for ClusterFuture ...
[15:31:16.565] - result already collected: FutureResult
[15:31:16.566] result() for ClusterFuture ... done
[15:31:16.566] result() for ClusterFuture ...
[15:31:16.566] - result already collected: FutureResult
[15:31:16.566] result() for ClusterFuture ... done
[15:31:16.567] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:31:16.567] - nx: 2
[15:31:16.567] - relay: TRUE
[15:31:16.567] - stdout: TRUE
[15:31:16.567] - signal: TRUE
[15:31:16.568] - resignal: FALSE
[15:31:16.568] - force: TRUE
[15:31:16.568] - relayed: [n=2] FALSE, FALSE
[15:31:16.568] - queued futures: [n=2] FALSE, FALSE
[15:31:16.569]  - until=1
[15:31:16.569]  - relaying element #1
[15:31:16.569] result() for ClusterFuture ...
[15:31:16.569] - result already collected: FutureResult
[15:31:16.570] result() for ClusterFuture ... done
[15:31:16.570] result() for ClusterFuture ...
[15:31:16.570] - result already collected: FutureResult
[15:31:16.571] result() for ClusterFuture ... done
[15:31:16.571] result() for ClusterFuture ...
[15:31:16.572] - result already collected: FutureResult
[15:31:16.572] result() for ClusterFuture ... done
[15:31:16.572] result() for ClusterFuture ...
[15:31:16.572] - result already collected: FutureResult
[15:31:16.573] result() for ClusterFuture ... done
[15:31:16.573] - relayed: [n=2] TRUE, FALSE
[15:31:16.573] - queued futures: [n=2] TRUE, FALSE
[15:31:16.574] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:31:16.574]  length: 1 (resolved future 1)
[15:31:16.574] Future #2
[15:31:16.575] result() for ClusterFuture ...
[15:31:16.575] - result already collected: FutureResult
[15:31:16.575] result() for ClusterFuture ... done
[15:31:16.576] result() for ClusterFuture ...
[15:31:16.576] - result already collected: FutureResult
[15:31:16.576] result() for ClusterFuture ... done
[15:31:16.576] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:31:16.577] - nx: 2
[15:31:16.577] - relay: TRUE
[15:31:16.577] - stdout: TRUE
[15:31:16.577] - signal: TRUE
[15:31:16.577] - resignal: FALSE
[15:31:16.577] - force: TRUE
[15:31:16.578] - relayed: [n=2] TRUE, FALSE
[15:31:16.578] - queued futures: [n=2] TRUE, FALSE
[15:31:16.578]  - until=2
[15:31:16.578]  - relaying element #2
[15:31:16.578] result() for ClusterFuture ...
[15:31:16.578] - result already collected: FutureResult
[15:31:16.579] result() for ClusterFuture ... done
[15:31:16.579] result() for ClusterFuture ...
[15:31:16.579] - result already collected: FutureResult
[15:31:16.579] result() for ClusterFuture ... done
[15:31:16.580] result() for ClusterFuture ...
[15:31:16.580] - result already collected: FutureResult
[15:31:16.580] result() for ClusterFuture ... done
[15:31:16.580] result() for ClusterFuture ...
[15:31:16.581] - result already collected: FutureResult
[15:31:16.581] result() for ClusterFuture ... done
[15:31:16.581] - relayed: [n=2] TRUE, TRUE
[15:31:16.581] - queued futures: [n=2] TRUE, TRUE
[15:31:16.581] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:31:16.582]  length: 0 (resolved future 2)
[15:31:16.582] Relaying remaining futures
[15:31:16.582] signalConditionsASAP(NULL, pos=0) ...
[15:31:16.582] - nx: 2
[15:31:16.583] - relay: TRUE
[15:31:16.583] - stdout: TRUE
[15:31:16.583] - signal: TRUE
[15:31:16.583] - resignal: FALSE
[15:31:16.583] - force: TRUE
[15:31:16.584] - relayed: [n=2] TRUE, TRUE
[15:31:16.584] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:31:16.584] - relayed: [n=2] TRUE, TRUE
[15:31:16.584] - queued futures: [n=2] TRUE, TRUE
[15:31:16.585] signalConditionsASAP(NULL, pos=0) ... done
[15:31:16.585] resolve() on list ... DONE
[15:31:16.585] result() for ClusterFuture ...
[15:31:16.585] - result already collected: FutureResult
[15:31:16.586] result() for ClusterFuture ... done
[15:31:16.586] result() for ClusterFuture ...
[15:31:16.586] - result already collected: FutureResult
[15:31:16.586] result() for ClusterFuture ... done
[15:31:16.586] result() for ClusterFuture ...
[15:31:16.587] - result already collected: FutureResult
[15:31:16.587] result() for ClusterFuture ... done
[15:31:16.587] result() for ClusterFuture ...
[15:31:16.587] - result already collected: FutureResult
[15:31:16.588] result() for ClusterFuture ... done
[15:31:16.588]  - Number of value chunks collected: 2
[15:31:16.588] Resolving 2 futures (chunks) ... DONE
[15:31:16.588] Reducing values from 2 chunks ...
[15:31:16.588]  - Number of values collected after concatenation: 3
[15:31:16.589]  - Number of values expected: 3
[15:31:16.589] Reducing values from 2 chunks ... DONE
[15:31:16.589] future_lapply() ... DONE
[15:31:16.590] future_lapply() ...
[15:31:16.595] Number of chunks: 2
[15:31:16.595] getGlobalsAndPackagesXApply() ...
[15:31:16.596]  - future.globals: TRUE
[15:31:16.596] getGlobalsAndPackages() ...
[15:31:16.596] Searching for globals...
[15:31:16.598] - globals found: [2] 'FUN', 'UseMethod'
[15:31:16.598] Searching for globals ... DONE
[15:31:16.599] Resolving globals: FALSE
[15:31:16.599] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:31:16.600] The total size of the 1 globals exported for future expression ('FUN()') 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:16.600] - globals: [1] 'FUN'
[15:31:16.600] - packages: [1] 'stats'
[15:31:16.601] getGlobalsAndPackages() ... DONE
[15:31:16.601]  - globals found/used: [n=1] 'FUN'
[15:31:16.601]  - needed namespaces: [n=1] 'stats'
[15:31:16.601] Finding globals ... DONE
[15:31:16.602]  - use_args: TRUE
[15:31:16.602]  - Getting '...' globals ...
[15:31:16.603] resolve() on list ...
[15:31:16.603]  recursive: 0
[15:31:16.603]  length: 1
[15:31:16.603]  elements: '...'
[15:31:16.604]  length: 0 (resolved future 1)
[15:31:16.604] resolve() on list ... DONE
[15:31:16.604]    - '...' content: [n=0] 
[15:31:16.604] List of 1
[15:31:16.604]  $ ...: list()
[15:31:16.604]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:16.604]  - attr(*, "where")=List of 1
[15:31:16.604]   ..$ ...:<environment: 0x000001b3fdd915a0> 
[15:31:16.604]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:16.604]  - attr(*, "resolved")= logi TRUE
[15:31:16.604]  - attr(*, "total_size")= num NA
[15:31:16.609]  - Getting '...' globals ... DONE
[15:31:16.609] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:16.609] List of 2
[15:31:16.609]  $ ...future.FUN:function (x, ...)  
[15:31:16.609]  $ ...          : list()
[15:31:16.609]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:16.609]  - attr(*, "where")=List of 2
[15:31:16.609]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:16.609]   ..$ ...          :<environment: 0x000001b3fdd915a0> 
[15:31:16.609]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:16.609]  - attr(*, "resolved")= logi FALSE
[15:31:16.609]  - attr(*, "total_size")= num 1248
[15:31:16.617] Packages to be attached in all futures: [n=1] 'stats'
[15:31:16.617] getGlobalsAndPackagesXApply() ... DONE
[15:31:16.618] Number of futures (= number of chunks): 2
[15:31:16.618] Launching 2 futures (chunks) ...
[15:31:16.618] Chunk #1 of 2 ...
[15:31:16.618]  - Finding globals in 'X' for chunk #1 ...
[15:31:16.619] getGlobalsAndPackages() ...
[15:31:16.619] Searching for globals...
[15:31:16.619] 
[15:31:16.620] Searching for globals ... DONE
[15:31:16.620] - globals: [0] <none>
[15:31:16.620] getGlobalsAndPackages() ... DONE
[15:31:16.620]    + additional globals found: [n=0] 
[15:31:16.621]    + additional namespaces needed: [n=0] 
[15:31:16.621]  - Finding globals in 'X' for chunk #1 ... DONE
[15:31:16.621]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:31:16.621]  - seeds: <none>
[15:31:16.622]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:16.622] getGlobalsAndPackages() ...
[15:31:16.622] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:16.622] Resolving globals: FALSE
[15:31:16.623] Tweak future expression to call with '...' arguments ...
[15:31:16.623] {
[15:31:16.623]     do.call(function(...) {
[15:31:16.623]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:16.623]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:16.623]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:16.623]             on.exit(options(oopts), add = TRUE)
[15:31:16.623]         }
[15:31:16.623]         {
[15:31:16.623]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:16.623]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:16.623]                 ...future.FUN(...future.X_jj, ...)
[15:31:16.623]             })
[15:31:16.623]         }
[15:31:16.623]     }, args = future.call.arguments)
[15:31:16.623] }
[15:31:16.624] Tweak future expression to call with '...' arguments ... DONE
[15:31:16.624] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:16.625] - packages: [1] 'stats'
[15:31:16.625] getGlobalsAndPackages() ... DONE
[15:31:16.626] run() for 'Future' ...
[15:31:16.626] - state: 'created'
[15:31:16.626] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:16.644] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:16.644] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:31:16.644]   - Field: 'node'
[15:31:16.644]   - Field: 'label'
[15:31:16.645]   - Field: 'local'
[15:31:16.645]   - Field: 'owner'
[15:31:16.645]   - Field: 'envir'
[15:31:16.645]   - Field: 'workers'
[15:31:16.645]   - Field: 'packages'
[15:31:16.646]   - Field: 'gc'
[15:31:16.646]   - Field: 'conditions'
[15:31:16.646]   - Field: 'persistent'
[15:31:16.646]   - Field: 'expr'
[15:31:16.646]   - Field: 'uuid'
[15:31:16.646]   - Field: 'seed'
[15:31:16.647]   - Field: 'version'
[15:31:16.647]   - Field: 'result'
[15:31:16.647]   - Field: 'asynchronous'
[15:31:16.647]   - Field: 'calls'
[15:31:16.647]   - Field: 'globals'
[15:31:16.647]   - Field: 'stdout'
[15:31:16.648]   - Field: 'earlySignal'
[15:31:16.648]   - Field: 'lazy'
[15:31:16.648]   - Field: 'state'
[15:31:16.648] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:31:16.648] - Launch lazy future ...
[15:31:16.649] Packages needed by the future expression (n = 1): 'stats'
[15:31:16.649] Packages needed by future strategies (n = 0): <none>
[15:31:16.650] {
[15:31:16.650]     {
[15:31:16.650]         {
[15:31:16.650]             ...future.startTime <- base::Sys.time()
[15:31:16.650]             {
[15:31:16.650]                 {
[15:31:16.650]                   {
[15:31:16.650]                     {
[15:31:16.650]                       {
[15:31:16.650]                         base::local({
[15:31:16.650]                           has_future <- base::requireNamespace("future", 
[15:31:16.650]                             quietly = TRUE)
[15:31:16.650]                           if (has_future) {
[15:31:16.650]                             ns <- base::getNamespace("future")
[15:31:16.650]                             version <- ns[[".package"]][["version"]]
[15:31:16.650]                             if (is.null(version)) 
[15:31:16.650]                               version <- utils::packageVersion("future")
[15:31:16.650]                           }
[15:31:16.650]                           else {
[15:31:16.650]                             version <- NULL
[15:31:16.650]                           }
[15:31:16.650]                           if (!has_future || version < "1.8.0") {
[15:31:16.650]                             info <- base::c(r_version = base::gsub("R version ", 
[15:31:16.650]                               "", base::R.version$version.string), 
[15:31:16.650]                               platform = base::sprintf("%s (%s-bit)", 
[15:31:16.650]                                 base::R.version$platform, 8 * 
[15:31:16.650]                                   base::.Machine$sizeof.pointer), 
[15:31:16.650]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:16.650]                                 "release", "version")], collapse = " "), 
[15:31:16.650]                               hostname = base::Sys.info()[["nodename"]])
[15:31:16.650]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:31:16.650]                               info)
[15:31:16.650]                             info <- base::paste(info, collapse = "; ")
[15:31:16.650]                             if (!has_future) {
[15:31:16.650]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:16.650]                                 info)
[15:31:16.650]                             }
[15:31:16.650]                             else {
[15:31:16.650]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:16.650]                                 info, version)
[15:31:16.650]                             }
[15:31:16.650]                             base::stop(msg)
[15:31:16.650]                           }
[15:31:16.650]                         })
[15:31:16.650]                       }
[15:31:16.650]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:16.650]                       base::options(mc.cores = 1L)
[15:31:16.650]                     }
[15:31:16.650]                     base::local({
[15:31:16.650]                       for (pkg in "stats") {
[15:31:16.650]                         base::loadNamespace(pkg)
[15:31:16.650]                         base::library(pkg, character.only = TRUE)
[15:31:16.650]                       }
[15:31:16.650]                     })
[15:31:16.650]                   }
[15:31:16.650]                   ...future.strategy.old <- future::plan("list")
[15:31:16.650]                   options(future.plan = NULL)
[15:31:16.650]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:16.650]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:16.650]                 }
[15:31:16.650]                 ...future.workdir <- getwd()
[15:31:16.650]             }
[15:31:16.650]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:16.650]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:16.650]         }
[15:31:16.650]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:16.650]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:31:16.650]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:16.650]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:16.650]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:16.650]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:16.650]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:16.650]             base::names(...future.oldOptions))
[15:31:16.650]     }
[15:31:16.650]     if (FALSE) {
[15:31:16.650]     }
[15:31:16.650]     else {
[15:31:16.650]         if (TRUE) {
[15:31:16.650]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:16.650]                 open = "w")
[15:31:16.650]         }
[15:31:16.650]         else {
[15:31:16.650]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:16.650]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:16.650]         }
[15:31:16.650]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:16.650]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:16.650]             base::sink(type = "output", split = FALSE)
[15:31:16.650]             base::close(...future.stdout)
[15:31:16.650]         }, add = TRUE)
[15:31:16.650]     }
[15:31:16.650]     ...future.frame <- base::sys.nframe()
[15:31:16.650]     ...future.conditions <- base::list()
[15:31:16.650]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:16.650]     if (FALSE) {
[15:31:16.650]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:16.650]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:16.650]     }
[15:31:16.650]     ...future.result <- base::tryCatch({
[15:31:16.650]         base::withCallingHandlers({
[15:31:16.650]             ...future.value <- base::withVisible(base::local({
[15:31:16.650]                 ...future.makeSendCondition <- base::local({
[15:31:16.650]                   sendCondition <- NULL
[15:31:16.650]                   function(frame = 1L) {
[15:31:16.650]                     if (is.function(sendCondition)) 
[15:31:16.650]                       return(sendCondition)
[15:31:16.650]                     ns <- getNamespace("parallel")
[15:31:16.650]                     if (exists("sendData", mode = "function", 
[15:31:16.650]                       envir = ns)) {
[15:31:16.650]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:16.650]                         envir = ns)
[15:31:16.650]                       envir <- sys.frame(frame)
[15:31:16.650]                       master <- NULL
[15:31:16.650]                       while (!identical(envir, .GlobalEnv) && 
[15:31:16.650]                         !identical(envir, emptyenv())) {
[15:31:16.650]                         if (exists("master", mode = "list", envir = envir, 
[15:31:16.650]                           inherits = FALSE)) {
[15:31:16.650]                           master <- get("master", mode = "list", 
[15:31:16.650]                             envir = envir, inherits = FALSE)
[15:31:16.650]                           if (inherits(master, c("SOCKnode", 
[15:31:16.650]                             "SOCK0node"))) {
[15:31:16.650]                             sendCondition <<- function(cond) {
[15:31:16.650]                               data <- list(type = "VALUE", value = cond, 
[15:31:16.650]                                 success = TRUE)
[15:31:16.650]                               parallel_sendData(master, data)
[15:31:16.650]                             }
[15:31:16.650]                             return(sendCondition)
[15:31:16.650]                           }
[15:31:16.650]                         }
[15:31:16.650]                         frame <- frame + 1L
[15:31:16.650]                         envir <- sys.frame(frame)
[15:31:16.650]                       }
[15:31:16.650]                     }
[15:31:16.650]                     sendCondition <<- function(cond) NULL
[15:31:16.650]                   }
[15:31:16.650]                 })
[15:31:16.650]                 withCallingHandlers({
[15:31:16.650]                   {
[15:31:16.650]                     do.call(function(...) {
[15:31:16.650]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:16.650]                       if (!identical(...future.globals.maxSize.org, 
[15:31:16.650]                         ...future.globals.maxSize)) {
[15:31:16.650]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:16.650]                         on.exit(options(oopts), add = TRUE)
[15:31:16.650]                       }
[15:31:16.650]                       {
[15:31:16.650]                         lapply(seq_along(...future.elements_ii), 
[15:31:16.650]                           FUN = function(jj) {
[15:31:16.650]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:16.650]                             ...future.FUN(...future.X_jj, ...)
[15:31:16.650]                           })
[15:31:16.650]                       }
[15:31:16.650]                     }, args = future.call.arguments)
[15:31:16.650]                   }
[15:31:16.650]                 }, immediateCondition = function(cond) {
[15:31:16.650]                   sendCondition <- ...future.makeSendCondition()
[15:31:16.650]                   sendCondition(cond)
[15:31:16.650]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:16.650]                   {
[15:31:16.650]                     inherits <- base::inherits
[15:31:16.650]                     invokeRestart <- base::invokeRestart
[15:31:16.650]                     is.null <- base::is.null
[15:31:16.650]                     muffled <- FALSE
[15:31:16.650]                     if (inherits(cond, "message")) {
[15:31:16.650]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:16.650]                       if (muffled) 
[15:31:16.650]                         invokeRestart("muffleMessage")
[15:31:16.650]                     }
[15:31:16.650]                     else if (inherits(cond, "warning")) {
[15:31:16.650]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:16.650]                       if (muffled) 
[15:31:16.650]                         invokeRestart("muffleWarning")
[15:31:16.650]                     }
[15:31:16.650]                     else if (inherits(cond, "condition")) {
[15:31:16.650]                       if (!is.null(pattern)) {
[15:31:16.650]                         computeRestarts <- base::computeRestarts
[15:31:16.650]                         grepl <- base::grepl
[15:31:16.650]                         restarts <- computeRestarts(cond)
[15:31:16.650]                         for (restart in restarts) {
[15:31:16.650]                           name <- restart$name
[15:31:16.650]                           if (is.null(name)) 
[15:31:16.650]                             next
[15:31:16.650]                           if (!grepl(pattern, name)) 
[15:31:16.650]                             next
[15:31:16.650]                           invokeRestart(restart)
[15:31:16.650]                           muffled <- TRUE
[15:31:16.650]                           break
[15:31:16.650]                         }
[15:31:16.650]                       }
[15:31:16.650]                     }
[15:31:16.650]                     invisible(muffled)
[15:31:16.650]                   }
[15:31:16.650]                   muffleCondition(cond)
[15:31:16.650]                 })
[15:31:16.650]             }))
[15:31:16.650]             future::FutureResult(value = ...future.value$value, 
[15:31:16.650]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:16.650]                   ...future.rng), globalenv = if (FALSE) 
[15:31:16.650]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:16.650]                     ...future.globalenv.names))
[15:31:16.650]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:16.650]         }, condition = base::local({
[15:31:16.650]             c <- base::c
[15:31:16.650]             inherits <- base::inherits
[15:31:16.650]             invokeRestart <- base::invokeRestart
[15:31:16.650]             length <- base::length
[15:31:16.650]             list <- base::list
[15:31:16.650]             seq.int <- base::seq.int
[15:31:16.650]             signalCondition <- base::signalCondition
[15:31:16.650]             sys.calls <- base::sys.calls
[15:31:16.650]             `[[` <- base::`[[`
[15:31:16.650]             `+` <- base::`+`
[15:31:16.650]             `<<-` <- base::`<<-`
[15:31:16.650]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:16.650]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:16.650]                   3L)]
[15:31:16.650]             }
[15:31:16.650]             function(cond) {
[15:31:16.650]                 is_error <- inherits(cond, "error")
[15:31:16.650]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:16.650]                   NULL)
[15:31:16.650]                 if (is_error) {
[15:31:16.650]                   sessionInformation <- function() {
[15:31:16.650]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:16.650]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:16.650]                       search = base::search(), system = base::Sys.info())
[15:31:16.650]                   }
[15:31:16.650]                   ...future.conditions[[length(...future.conditions) + 
[15:31:16.650]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:16.650]                     cond$call), session = sessionInformation(), 
[15:31:16.650]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:16.650]                   signalCondition(cond)
[15:31:16.650]                 }
[15:31:16.650]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:16.650]                 "immediateCondition"))) {
[15:31:16.650]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:16.650]                   ...future.conditions[[length(...future.conditions) + 
[15:31:16.650]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:16.650]                   if (TRUE && !signal) {
[15:31:16.650]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:16.650]                     {
[15:31:16.650]                       inherits <- base::inherits
[15:31:16.650]                       invokeRestart <- base::invokeRestart
[15:31:16.650]                       is.null <- base::is.null
[15:31:16.650]                       muffled <- FALSE
[15:31:16.650]                       if (inherits(cond, "message")) {
[15:31:16.650]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:16.650]                         if (muffled) 
[15:31:16.650]                           invokeRestart("muffleMessage")
[15:31:16.650]                       }
[15:31:16.650]                       else if (inherits(cond, "warning")) {
[15:31:16.650]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:16.650]                         if (muffled) 
[15:31:16.650]                           invokeRestart("muffleWarning")
[15:31:16.650]                       }
[15:31:16.650]                       else if (inherits(cond, "condition")) {
[15:31:16.650]                         if (!is.null(pattern)) {
[15:31:16.650]                           computeRestarts <- base::computeRestarts
[15:31:16.650]                           grepl <- base::grepl
[15:31:16.650]                           restarts <- computeRestarts(cond)
[15:31:16.650]                           for (restart in restarts) {
[15:31:16.650]                             name <- restart$name
[15:31:16.650]                             if (is.null(name)) 
[15:31:16.650]                               next
[15:31:16.650]                             if (!grepl(pattern, name)) 
[15:31:16.650]                               next
[15:31:16.650]                             invokeRestart(restart)
[15:31:16.650]                             muffled <- TRUE
[15:31:16.650]                             break
[15:31:16.650]                           }
[15:31:16.650]                         }
[15:31:16.650]                       }
[15:31:16.650]                       invisible(muffled)
[15:31:16.650]                     }
[15:31:16.650]                     muffleCondition(cond, pattern = "^muffle")
[15:31:16.650]                   }
[15:31:16.650]                 }
[15:31:16.650]                 else {
[15:31:16.650]                   if (TRUE) {
[15:31:16.650]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:16.650]                     {
[15:31:16.650]                       inherits <- base::inherits
[15:31:16.650]                       invokeRestart <- base::invokeRestart
[15:31:16.650]                       is.null <- base::is.null
[15:31:16.650]                       muffled <- FALSE
[15:31:16.650]                       if (inherits(cond, "message")) {
[15:31:16.650]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:16.650]                         if (muffled) 
[15:31:16.650]                           invokeRestart("muffleMessage")
[15:31:16.650]                       }
[15:31:16.650]                       else if (inherits(cond, "warning")) {
[15:31:16.650]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:16.650]                         if (muffled) 
[15:31:16.650]                           invokeRestart("muffleWarning")
[15:31:16.650]                       }
[15:31:16.650]                       else if (inherits(cond, "condition")) {
[15:31:16.650]                         if (!is.null(pattern)) {
[15:31:16.650]                           computeRestarts <- base::computeRestarts
[15:31:16.650]                           grepl <- base::grepl
[15:31:16.650]                           restarts <- computeRestarts(cond)
[15:31:16.650]                           for (restart in restarts) {
[15:31:16.650]                             name <- restart$name
[15:31:16.650]                             if (is.null(name)) 
[15:31:16.650]                               next
[15:31:16.650]                             if (!grepl(pattern, name)) 
[15:31:16.650]                               next
[15:31:16.650]                             invokeRestart(restart)
[15:31:16.650]                             muffled <- TRUE
[15:31:16.650]                             break
[15:31:16.650]                           }
[15:31:16.650]                         }
[15:31:16.650]                       }
[15:31:16.650]                       invisible(muffled)
[15:31:16.650]                     }
[15:31:16.650]                     muffleCondition(cond, pattern = "^muffle")
[15:31:16.650]                   }
[15:31:16.650]                 }
[15:31:16.650]             }
[15:31:16.650]         }))
[15:31:16.650]     }, error = function(ex) {
[15:31:16.650]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:16.650]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:16.650]                 ...future.rng), started = ...future.startTime, 
[15:31:16.650]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:16.650]             version = "1.8"), class = "FutureResult")
[15:31:16.650]     }, finally = {
[15:31:16.650]         if (!identical(...future.workdir, getwd())) 
[15:31:16.650]             setwd(...future.workdir)
[15:31:16.650]         {
[15:31:16.650]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:16.650]                 ...future.oldOptions$nwarnings <- NULL
[15:31:16.650]             }
[15:31:16.650]             base::options(...future.oldOptions)
[15:31:16.650]             if (.Platform$OS.type == "windows") {
[15:31:16.650]                 old_names <- names(...future.oldEnvVars)
[15:31:16.650]                 envs <- base::Sys.getenv()
[15:31:16.650]                 names <- names(envs)
[15:31:16.650]                 common <- intersect(names, old_names)
[15:31:16.650]                 added <- setdiff(names, old_names)
[15:31:16.650]                 removed <- setdiff(old_names, names)
[15:31:16.650]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:16.650]                   envs[common]]
[15:31:16.650]                 NAMES <- toupper(changed)
[15:31:16.650]                 args <- list()
[15:31:16.650]                 for (kk in seq_along(NAMES)) {
[15:31:16.650]                   name <- changed[[kk]]
[15:31:16.650]                   NAME <- NAMES[[kk]]
[15:31:16.650]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:16.650]                     next
[15:31:16.650]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:16.650]                 }
[15:31:16.650]                 NAMES <- toupper(added)
[15:31:16.650]                 for (kk in seq_along(NAMES)) {
[15:31:16.650]                   name <- added[[kk]]
[15:31:16.650]                   NAME <- NAMES[[kk]]
[15:31:16.650]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:16.650]                     next
[15:31:16.650]                   args[[name]] <- ""
[15:31:16.650]                 }
[15:31:16.650]                 NAMES <- toupper(removed)
[15:31:16.650]                 for (kk in seq_along(NAMES)) {
[15:31:16.650]                   name <- removed[[kk]]
[15:31:16.650]                   NAME <- NAMES[[kk]]
[15:31:16.650]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:16.650]                     next
[15:31:16.650]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:16.650]                 }
[15:31:16.650]                 if (length(args) > 0) 
[15:31:16.650]                   base::do.call(base::Sys.setenv, args = args)
[15:31:16.650]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:16.650]             }
[15:31:16.650]             else {
[15:31:16.650]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:16.650]             }
[15:31:16.650]             {
[15:31:16.650]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:16.650]                   0L) {
[15:31:16.650]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:16.650]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:16.650]                   base::options(opts)
[15:31:16.650]                 }
[15:31:16.650]                 {
[15:31:16.650]                   {
[15:31:16.650]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:16.650]                     NULL
[15:31:16.650]                   }
[15:31:16.650]                   options(future.plan = NULL)
[15:31:16.650]                   if (is.na(NA_character_)) 
[15:31:16.650]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:16.650]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:16.650]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:16.650]                     .init = FALSE)
[15:31:16.650]                 }
[15:31:16.650]             }
[15:31:16.650]         }
[15:31:16.650]     })
[15:31:16.650]     if (TRUE) {
[15:31:16.650]         base::sink(type = "output", split = FALSE)
[15:31:16.650]         if (TRUE) {
[15:31:16.650]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:16.650]         }
[15:31:16.650]         else {
[15:31:16.650]             ...future.result["stdout"] <- base::list(NULL)
[15:31:16.650]         }
[15:31:16.650]         base::close(...future.stdout)
[15:31:16.650]         ...future.stdout <- NULL
[15:31:16.650]     }
[15:31:16.650]     ...future.result$conditions <- ...future.conditions
[15:31:16.650]     ...future.result$finished <- base::Sys.time()
[15:31:16.650]     ...future.result
[15:31:16.650] }
[15:31:16.658] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:31:16.659] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:31:16.660] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:31:16.661] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:31:16.662] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:31:16.662] Exporting '...future.elements_ii' (64 bytes) to cluster node #1 ...
[15:31:16.663] Exporting '...future.elements_ii' (64 bytes) to cluster node #1 ... DONE
[15:31:16.664] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:31:16.665] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:31:16.665] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:31:16.666] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:31:16.667] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:31:16.668] MultisessionFuture started
[15:31:16.669] - Launch lazy future ... done
[15:31:16.669] run() for 'MultisessionFuture' ... done
[15:31:16.669] Created future:
[15:31:16.696] receiveMessageFromWorker() for ClusterFuture ...
[15:31:16.697] - Validating connection of MultisessionFuture
[15:31:16.697] - received message: FutureResult
[15:31:16.697] - Received FutureResult
[15:31:16.698] - Erased future from FutureRegistry
[15:31:16.698] result() for ClusterFuture ...
[15:31:16.699] - result already collected: FutureResult
[15:31:16.699] result() for ClusterFuture ... done
[15:31:16.699] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:16.669] MultisessionFuture:
[15:31:16.669] Label: 'future_eapply-1'
[15:31:16.669] Expression:
[15:31:16.669] {
[15:31:16.669]     do.call(function(...) {
[15:31:16.669]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:16.669]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:16.669]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:16.669]             on.exit(options(oopts), add = TRUE)
[15:31:16.669]         }
[15:31:16.669]         {
[15:31:16.669]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:16.669]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:16.669]                 ...future.FUN(...future.X_jj, ...)
[15:31:16.669]             })
[15:31:16.669]         }
[15:31:16.669]     }, args = future.call.arguments)
[15:31:16.669] }
[15:31:16.669] Lazy evaluation: FALSE
[15:31:16.669] Asynchronous evaluation: TRUE
[15:31:16.669] Local evaluation: TRUE
[15:31:16.669] Environment: R_GlobalEnv
[15:31:16.669] Capture standard output: TRUE
[15:31:16.669] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:16.669] Globals: 5 objects totaling 1.28 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 64 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:31:16.669] Packages: 1 packages ('stats')
[15:31:16.669] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:16.669] Resolved: TRUE
[15:31:16.669] Value: <not collected>
[15:31:16.669] Conditions captured: <none>
[15:31:16.669] Early signaling: FALSE
[15:31:16.669] Owner process: 1f501b3c-5bdf-35ad-4a62-196ce98a2fc6
[15:31:16.669] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:16.700] Chunk #1 of 2 ... DONE
[15:31:16.701] Chunk #2 of 2 ...
[15:31:16.701]  - Finding globals in 'X' for chunk #2 ...
[15:31:16.702] getGlobalsAndPackages() ...
[15:31:16.702] Searching for globals...
[15:31:16.702] 
[15:31:16.703] Searching for globals ... DONE
[15:31:16.703] - globals: [0] <none>
[15:31:16.703] getGlobalsAndPackages() ... DONE
[15:31:16.703]    + additional globals found: [n=0] 
[15:31:16.704]    + additional namespaces needed: [n=0] 
[15:31:16.704]  - Finding globals in 'X' for chunk #2 ... DONE
[15:31:16.704]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:31:16.704]  - seeds: <none>
[15:31:16.704]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:16.705] getGlobalsAndPackages() ...
[15:31:16.705] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:16.705] Resolving globals: FALSE
[15:31:16.705] Tweak future expression to call with '...' arguments ...
[15:31:16.706] {
[15:31:16.706]     do.call(function(...) {
[15:31:16.706]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:16.706]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:16.706]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:16.706]             on.exit(options(oopts), add = TRUE)
[15:31:16.706]         }
[15:31:16.706]         {
[15:31:16.706]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:16.706]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:16.706]                 ...future.FUN(...future.X_jj, ...)
[15:31:16.706]             })
[15:31:16.706]         }
[15:31:16.706]     }, args = future.call.arguments)
[15:31:16.706] }
[15:31:16.707] Tweak future expression to call with '...' arguments ... DONE
[15:31:16.708] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:16.708] - packages: [1] 'stats'
[15:31:16.709] getGlobalsAndPackages() ... DONE
[15:31:16.709] run() for 'Future' ...
[15:31:16.710] - state: 'created'
[15:31:16.710] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:16.733] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:16.734] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:31:16.734]   - Field: 'node'
[15:31:16.735]   - Field: 'label'
[15:31:16.735]   - Field: 'local'
[15:31:16.736]   - Field: 'owner'
[15:31:16.736]   - Field: 'envir'
[15:31:16.737]   - Field: 'workers'
[15:31:16.737]   - Field: 'packages'
[15:31:16.737]   - Field: 'gc'
[15:31:16.738]   - Field: 'conditions'
[15:31:16.738]   - Field: 'persistent'
[15:31:16.739]   - Field: 'expr'
[15:31:16.739]   - Field: 'uuid'
[15:31:16.739]   - Field: 'seed'
[15:31:16.740]   - Field: 'version'
[15:31:16.740]   - Field: 'result'
[15:31:16.741]   - Field: 'asynchronous'
[15:31:16.741]   - Field: 'calls'
[15:31:16.741]   - Field: 'globals'
[15:31:16.742]   - Field: 'stdout'
[15:31:16.742]   - Field: 'earlySignal'
[15:31:16.743]   - Field: 'lazy'
[15:31:16.743]   - Field: 'state'
[15:31:16.743] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:31:16.744] - Launch lazy future ...
[15:31:16.745] Packages needed by the future expression (n = 1): 'stats'
[15:31:16.745] Packages needed by future strategies (n = 0): <none>
[15:31:16.746] {
[15:31:16.746]     {
[15:31:16.746]         {
[15:31:16.746]             ...future.startTime <- base::Sys.time()
[15:31:16.746]             {
[15:31:16.746]                 {
[15:31:16.746]                   {
[15:31:16.746]                     {
[15:31:16.746]                       {
[15:31:16.746]                         base::local({
[15:31:16.746]                           has_future <- base::requireNamespace("future", 
[15:31:16.746]                             quietly = TRUE)
[15:31:16.746]                           if (has_future) {
[15:31:16.746]                             ns <- base::getNamespace("future")
[15:31:16.746]                             version <- ns[[".package"]][["version"]]
[15:31:16.746]                             if (is.null(version)) 
[15:31:16.746]                               version <- utils::packageVersion("future")
[15:31:16.746]                           }
[15:31:16.746]                           else {
[15:31:16.746]                             version <- NULL
[15:31:16.746]                           }
[15:31:16.746]                           if (!has_future || version < "1.8.0") {
[15:31:16.746]                             info <- base::c(r_version = base::gsub("R version ", 
[15:31:16.746]                               "", base::R.version$version.string), 
[15:31:16.746]                               platform = base::sprintf("%s (%s-bit)", 
[15:31:16.746]                                 base::R.version$platform, 8 * 
[15:31:16.746]                                   base::.Machine$sizeof.pointer), 
[15:31:16.746]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:16.746]                                 "release", "version")], collapse = " "), 
[15:31:16.746]                               hostname = base::Sys.info()[["nodename"]])
[15:31:16.746]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:31:16.746]                               info)
[15:31:16.746]                             info <- base::paste(info, collapse = "; ")
[15:31:16.746]                             if (!has_future) {
[15:31:16.746]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:16.746]                                 info)
[15:31:16.746]                             }
[15:31:16.746]                             else {
[15:31:16.746]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:16.746]                                 info, version)
[15:31:16.746]                             }
[15:31:16.746]                             base::stop(msg)
[15:31:16.746]                           }
[15:31:16.746]                         })
[15:31:16.746]                       }
[15:31:16.746]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:16.746]                       base::options(mc.cores = 1L)
[15:31:16.746]                     }
[15:31:16.746]                     base::local({
[15:31:16.746]                       for (pkg in "stats") {
[15:31:16.746]                         base::loadNamespace(pkg)
[15:31:16.746]                         base::library(pkg, character.only = TRUE)
[15:31:16.746]                       }
[15:31:16.746]                     })
[15:31:16.746]                   }
[15:31:16.746]                   ...future.strategy.old <- future::plan("list")
[15:31:16.746]                   options(future.plan = NULL)
[15:31:16.746]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:16.746]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:16.746]                 }
[15:31:16.746]                 ...future.workdir <- getwd()
[15:31:16.746]             }
[15:31:16.746]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:16.746]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:16.746]         }
[15:31:16.746]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:16.746]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:31:16.746]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:16.746]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:16.746]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:16.746]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:16.746]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:16.746]             base::names(...future.oldOptions))
[15:31:16.746]     }
[15:31:16.746]     if (FALSE) {
[15:31:16.746]     }
[15:31:16.746]     else {
[15:31:16.746]         if (TRUE) {
[15:31:16.746]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:16.746]                 open = "w")
[15:31:16.746]         }
[15:31:16.746]         else {
[15:31:16.746]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:16.746]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:16.746]         }
[15:31:16.746]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:16.746]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:16.746]             base::sink(type = "output", split = FALSE)
[15:31:16.746]             base::close(...future.stdout)
[15:31:16.746]         }, add = TRUE)
[15:31:16.746]     }
[15:31:16.746]     ...future.frame <- base::sys.nframe()
[15:31:16.746]     ...future.conditions <- base::list()
[15:31:16.746]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:16.746]     if (FALSE) {
[15:31:16.746]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:16.746]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:16.746]     }
[15:31:16.746]     ...future.result <- base::tryCatch({
[15:31:16.746]         base::withCallingHandlers({
[15:31:16.746]             ...future.value <- base::withVisible(base::local({
[15:31:16.746]                 ...future.makeSendCondition <- base::local({
[15:31:16.746]                   sendCondition <- NULL
[15:31:16.746]                   function(frame = 1L) {
[15:31:16.746]                     if (is.function(sendCondition)) 
[15:31:16.746]                       return(sendCondition)
[15:31:16.746]                     ns <- getNamespace("parallel")
[15:31:16.746]                     if (exists("sendData", mode = "function", 
[15:31:16.746]                       envir = ns)) {
[15:31:16.746]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:16.746]                         envir = ns)
[15:31:16.746]                       envir <- sys.frame(frame)
[15:31:16.746]                       master <- NULL
[15:31:16.746]                       while (!identical(envir, .GlobalEnv) && 
[15:31:16.746]                         !identical(envir, emptyenv())) {
[15:31:16.746]                         if (exists("master", mode = "list", envir = envir, 
[15:31:16.746]                           inherits = FALSE)) {
[15:31:16.746]                           master <- get("master", mode = "list", 
[15:31:16.746]                             envir = envir, inherits = FALSE)
[15:31:16.746]                           if (inherits(master, c("SOCKnode", 
[15:31:16.746]                             "SOCK0node"))) {
[15:31:16.746]                             sendCondition <<- function(cond) {
[15:31:16.746]                               data <- list(type = "VALUE", value = cond, 
[15:31:16.746]                                 success = TRUE)
[15:31:16.746]                               parallel_sendData(master, data)
[15:31:16.746]                             }
[15:31:16.746]                             return(sendCondition)
[15:31:16.746]                           }
[15:31:16.746]                         }
[15:31:16.746]                         frame <- frame + 1L
[15:31:16.746]                         envir <- sys.frame(frame)
[15:31:16.746]                       }
[15:31:16.746]                     }
[15:31:16.746]                     sendCondition <<- function(cond) NULL
[15:31:16.746]                   }
[15:31:16.746]                 })
[15:31:16.746]                 withCallingHandlers({
[15:31:16.746]                   {
[15:31:16.746]                     do.call(function(...) {
[15:31:16.746]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:16.746]                       if (!identical(...future.globals.maxSize.org, 
[15:31:16.746]                         ...future.globals.maxSize)) {
[15:31:16.746]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:16.746]                         on.exit(options(oopts), add = TRUE)
[15:31:16.746]                       }
[15:31:16.746]                       {
[15:31:16.746]                         lapply(seq_along(...future.elements_ii), 
[15:31:16.746]                           FUN = function(jj) {
[15:31:16.746]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:16.746]                             ...future.FUN(...future.X_jj, ...)
[15:31:16.746]                           })
[15:31:16.746]                       }
[15:31:16.746]                     }, args = future.call.arguments)
[15:31:16.746]                   }
[15:31:16.746]                 }, immediateCondition = function(cond) {
[15:31:16.746]                   sendCondition <- ...future.makeSendCondition()
[15:31:16.746]                   sendCondition(cond)
[15:31:16.746]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:16.746]                   {
[15:31:16.746]                     inherits <- base::inherits
[15:31:16.746]                     invokeRestart <- base::invokeRestart
[15:31:16.746]                     is.null <- base::is.null
[15:31:16.746]                     muffled <- FALSE
[15:31:16.746]                     if (inherits(cond, "message")) {
[15:31:16.746]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:16.746]                       if (muffled) 
[15:31:16.746]                         invokeRestart("muffleMessage")
[15:31:16.746]                     }
[15:31:16.746]                     else if (inherits(cond, "warning")) {
[15:31:16.746]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:16.746]                       if (muffled) 
[15:31:16.746]                         invokeRestart("muffleWarning")
[15:31:16.746]                     }
[15:31:16.746]                     else if (inherits(cond, "condition")) {
[15:31:16.746]                       if (!is.null(pattern)) {
[15:31:16.746]                         computeRestarts <- base::computeRestarts
[15:31:16.746]                         grepl <- base::grepl
[15:31:16.746]                         restarts <- computeRestarts(cond)
[15:31:16.746]                         for (restart in restarts) {
[15:31:16.746]                           name <- restart$name
[15:31:16.746]                           if (is.null(name)) 
[15:31:16.746]                             next
[15:31:16.746]                           if (!grepl(pattern, name)) 
[15:31:16.746]                             next
[15:31:16.746]                           invokeRestart(restart)
[15:31:16.746]                           muffled <- TRUE
[15:31:16.746]                           break
[15:31:16.746]                         }
[15:31:16.746]                       }
[15:31:16.746]                     }
[15:31:16.746]                     invisible(muffled)
[15:31:16.746]                   }
[15:31:16.746]                   muffleCondition(cond)
[15:31:16.746]                 })
[15:31:16.746]             }))
[15:31:16.746]             future::FutureResult(value = ...future.value$value, 
[15:31:16.746]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:16.746]                   ...future.rng), globalenv = if (FALSE) 
[15:31:16.746]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:16.746]                     ...future.globalenv.names))
[15:31:16.746]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:16.746]         }, condition = base::local({
[15:31:16.746]             c <- base::c
[15:31:16.746]             inherits <- base::inherits
[15:31:16.746]             invokeRestart <- base::invokeRestart
[15:31:16.746]             length <- base::length
[15:31:16.746]             list <- base::list
[15:31:16.746]             seq.int <- base::seq.int
[15:31:16.746]             signalCondition <- base::signalCondition
[15:31:16.746]             sys.calls <- base::sys.calls
[15:31:16.746]             `[[` <- base::`[[`
[15:31:16.746]             `+` <- base::`+`
[15:31:16.746]             `<<-` <- base::`<<-`
[15:31:16.746]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:16.746]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:16.746]                   3L)]
[15:31:16.746]             }
[15:31:16.746]             function(cond) {
[15:31:16.746]                 is_error <- inherits(cond, "error")
[15:31:16.746]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:16.746]                   NULL)
[15:31:16.746]                 if (is_error) {
[15:31:16.746]                   sessionInformation <- function() {
[15:31:16.746]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:16.746]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:16.746]                       search = base::search(), system = base::Sys.info())
[15:31:16.746]                   }
[15:31:16.746]                   ...future.conditions[[length(...future.conditions) + 
[15:31:16.746]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:16.746]                     cond$call), session = sessionInformation(), 
[15:31:16.746]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:16.746]                   signalCondition(cond)
[15:31:16.746]                 }
[15:31:16.746]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:16.746]                 "immediateCondition"))) {
[15:31:16.746]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:16.746]                   ...future.conditions[[length(...future.conditions) + 
[15:31:16.746]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:16.746]                   if (TRUE && !signal) {
[15:31:16.746]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:16.746]                     {
[15:31:16.746]                       inherits <- base::inherits
[15:31:16.746]                       invokeRestart <- base::invokeRestart
[15:31:16.746]                       is.null <- base::is.null
[15:31:16.746]                       muffled <- FALSE
[15:31:16.746]                       if (inherits(cond, "message")) {
[15:31:16.746]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:16.746]                         if (muffled) 
[15:31:16.746]                           invokeRestart("muffleMessage")
[15:31:16.746]                       }
[15:31:16.746]                       else if (inherits(cond, "warning")) {
[15:31:16.746]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:16.746]                         if (muffled) 
[15:31:16.746]                           invokeRestart("muffleWarning")
[15:31:16.746]                       }
[15:31:16.746]                       else if (inherits(cond, "condition")) {
[15:31:16.746]                         if (!is.null(pattern)) {
[15:31:16.746]                           computeRestarts <- base::computeRestarts
[15:31:16.746]                           grepl <- base::grepl
[15:31:16.746]                           restarts <- computeRestarts(cond)
[15:31:16.746]                           for (restart in restarts) {
[15:31:16.746]                             name <- restart$name
[15:31:16.746]                             if (is.null(name)) 
[15:31:16.746]                               next
[15:31:16.746]                             if (!grepl(pattern, name)) 
[15:31:16.746]                               next
[15:31:16.746]                             invokeRestart(restart)
[15:31:16.746]                             muffled <- TRUE
[15:31:16.746]                             break
[15:31:16.746]                           }
[15:31:16.746]                         }
[15:31:16.746]                       }
[15:31:16.746]                       invisible(muffled)
[15:31:16.746]                     }
[15:31:16.746]                     muffleCondition(cond, pattern = "^muffle")
[15:31:16.746]                   }
[15:31:16.746]                 }
[15:31:16.746]                 else {
[15:31:16.746]                   if (TRUE) {
[15:31:16.746]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:16.746]                     {
[15:31:16.746]                       inherits <- base::inherits
[15:31:16.746]                       invokeRestart <- base::invokeRestart
[15:31:16.746]                       is.null <- base::is.null
[15:31:16.746]                       muffled <- FALSE
[15:31:16.746]                       if (inherits(cond, "message")) {
[15:31:16.746]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:16.746]                         if (muffled) 
[15:31:16.746]                           invokeRestart("muffleMessage")
[15:31:16.746]                       }
[15:31:16.746]                       else if (inherits(cond, "warning")) {
[15:31:16.746]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:16.746]                         if (muffled) 
[15:31:16.746]                           invokeRestart("muffleWarning")
[15:31:16.746]                       }
[15:31:16.746]                       else if (inherits(cond, "condition")) {
[15:31:16.746]                         if (!is.null(pattern)) {
[15:31:16.746]                           computeRestarts <- base::computeRestarts
[15:31:16.746]                           grepl <- base::grepl
[15:31:16.746]                           restarts <- computeRestarts(cond)
[15:31:16.746]                           for (restart in restarts) {
[15:31:16.746]                             name <- restart$name
[15:31:16.746]                             if (is.null(name)) 
[15:31:16.746]                               next
[15:31:16.746]                             if (!grepl(pattern, name)) 
[15:31:16.746]                               next
[15:31:16.746]                             invokeRestart(restart)
[15:31:16.746]                             muffled <- TRUE
[15:31:16.746]                             break
[15:31:16.746]                           }
[15:31:16.746]                         }
[15:31:16.746]                       }
[15:31:16.746]                       invisible(muffled)
[15:31:16.746]                     }
[15:31:16.746]                     muffleCondition(cond, pattern = "^muffle")
[15:31:16.746]                   }
[15:31:16.746]                 }
[15:31:16.746]             }
[15:31:16.746]         }))
[15:31:16.746]     }, error = function(ex) {
[15:31:16.746]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:16.746]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:16.746]                 ...future.rng), started = ...future.startTime, 
[15:31:16.746]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:16.746]             version = "1.8"), class = "FutureResult")
[15:31:16.746]     }, finally = {
[15:31:16.746]         if (!identical(...future.workdir, getwd())) 
[15:31:16.746]             setwd(...future.workdir)
[15:31:16.746]         {
[15:31:16.746]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:16.746]                 ...future.oldOptions$nwarnings <- NULL
[15:31:16.746]             }
[15:31:16.746]             base::options(...future.oldOptions)
[15:31:16.746]             if (.Platform$OS.type == "windows") {
[15:31:16.746]                 old_names <- names(...future.oldEnvVars)
[15:31:16.746]                 envs <- base::Sys.getenv()
[15:31:16.746]                 names <- names(envs)
[15:31:16.746]                 common <- intersect(names, old_names)
[15:31:16.746]                 added <- setdiff(names, old_names)
[15:31:16.746]                 removed <- setdiff(old_names, names)
[15:31:16.746]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:16.746]                   envs[common]]
[15:31:16.746]                 NAMES <- toupper(changed)
[15:31:16.746]                 args <- list()
[15:31:16.746]                 for (kk in seq_along(NAMES)) {
[15:31:16.746]                   name <- changed[[kk]]
[15:31:16.746]                   NAME <- NAMES[[kk]]
[15:31:16.746]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:16.746]                     next
[15:31:16.746]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:16.746]                 }
[15:31:16.746]                 NAMES <- toupper(added)
[15:31:16.746]                 for (kk in seq_along(NAMES)) {
[15:31:16.746]                   name <- added[[kk]]
[15:31:16.746]                   NAME <- NAMES[[kk]]
[15:31:16.746]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:16.746]                     next
[15:31:16.746]                   args[[name]] <- ""
[15:31:16.746]                 }
[15:31:16.746]                 NAMES <- toupper(removed)
[15:31:16.746]                 for (kk in seq_along(NAMES)) {
[15:31:16.746]                   name <- removed[[kk]]
[15:31:16.746]                   NAME <- NAMES[[kk]]
[15:31:16.746]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:16.746]                     next
[15:31:16.746]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:16.746]                 }
[15:31:16.746]                 if (length(args) > 0) 
[15:31:16.746]                   base::do.call(base::Sys.setenv, args = args)
[15:31:16.746]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:16.746]             }
[15:31:16.746]             else {
[15:31:16.746]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:16.746]             }
[15:31:16.746]             {
[15:31:16.746]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:16.746]                   0L) {
[15:31:16.746]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:16.746]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:16.746]                   base::options(opts)
[15:31:16.746]                 }
[15:31:16.746]                 {
[15:31:16.746]                   {
[15:31:16.746]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:16.746]                     NULL
[15:31:16.746]                   }
[15:31:16.746]                   options(future.plan = NULL)
[15:31:16.746]                   if (is.na(NA_character_)) 
[15:31:16.746]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:16.746]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:16.746]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:16.746]                     .init = FALSE)
[15:31:16.746]                 }
[15:31:16.746]             }
[15:31:16.746]         }
[15:31:16.746]     })
[15:31:16.746]     if (TRUE) {
[15:31:16.746]         base::sink(type = "output", split = FALSE)
[15:31:16.746]         if (TRUE) {
[15:31:16.746]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:16.746]         }
[15:31:16.746]         else {
[15:31:16.746]             ...future.result["stdout"] <- base::list(NULL)
[15:31:16.746]         }
[15:31:16.746]         base::close(...future.stdout)
[15:31:16.746]         ...future.stdout <- NULL
[15:31:16.746]     }
[15:31:16.746]     ...future.result$conditions <- ...future.conditions
[15:31:16.746]     ...future.result$finished <- base::Sys.time()
[15:31:16.746]     ...future.result
[15:31:16.746] }
[15:31:16.757] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:31:16.758] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:31:16.758] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:31:16.759] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:31:16.760] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:31:16.760] Exporting '...future.elements_ii' (208 bytes) to cluster node #1 ...
[15:31:16.761] Exporting '...future.elements_ii' (208 bytes) to cluster node #1 ... DONE
[15:31:16.761] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:31:16.762] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:31:16.762] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:31:16.762] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:31:16.763] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:31:16.764] MultisessionFuture started
[15:31:16.764] - Launch lazy future ... done
[15:31:16.764] run() for 'MultisessionFuture' ... done
[15:31:16.765] Created future:
[15:31:16.782] receiveMessageFromWorker() for ClusterFuture ...
[15:31:16.783] - Validating connection of MultisessionFuture
[15:31:16.783] - received message: FutureResult
[15:31:16.783] - Received FutureResult
[15:31:16.783] - Erased future from FutureRegistry
[15:31:16.784] result() for ClusterFuture ...
[15:31:16.784] - result already collected: FutureResult
[15:31:16.784] result() for ClusterFuture ... done
[15:31:16.784] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:16.765] MultisessionFuture:
[15:31:16.765] Label: 'future_eapply-2'
[15:31:16.765] Expression:
[15:31:16.765] {
[15:31:16.765]     do.call(function(...) {
[15:31:16.765]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:16.765]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:16.765]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:16.765]             on.exit(options(oopts), add = TRUE)
[15:31:16.765]         }
[15:31:16.765]         {
[15:31:16.765]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:16.765]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:16.765]                 ...future.FUN(...future.X_jj, ...)
[15:31:16.765]             })
[15:31:16.765]         }
[15:31:16.765]     }, args = future.call.arguments)
[15:31:16.765] }
[15:31:16.765] Lazy evaluation: FALSE
[15:31:16.765] Asynchronous evaluation: TRUE
[15:31:16.765] Local evaluation: TRUE
[15:31:16.765] Environment: R_GlobalEnv
[15:31:16.765] Capture standard output: TRUE
[15:31:16.765] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:16.765] Globals: 5 objects totaling 1.42 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 208 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:31:16.765] Packages: 1 packages ('stats')
[15:31:16.765] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:16.765] Resolved: TRUE
[15:31:16.765] Value: <not collected>
[15:31:16.765] Conditions captured: <none>
[15:31:16.765] Early signaling: FALSE
[15:31:16.765] Owner process: 1f501b3c-5bdf-35ad-4a62-196ce98a2fc6
[15:31:16.765] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:16.785] Chunk #2 of 2 ... DONE
[15:31:16.785] Launching 2 futures (chunks) ... DONE
[15:31:16.785] Resolving 2 futures (chunks) ...
[15:31:16.785] resolve() on list ...
[15:31:16.785]  recursive: 0
[15:31:16.786]  length: 2
[15:31:16.786] 
[15:31:16.786] Future #1
[15:31:16.786] result() for ClusterFuture ...
[15:31:16.786] - result already collected: FutureResult
[15:31:16.786] result() for ClusterFuture ... done
[15:31:16.787] result() for ClusterFuture ...
[15:31:16.787] - result already collected: FutureResult
[15:31:16.787] result() for ClusterFuture ... done
[15:31:16.787] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:31:16.787] - nx: 2
[15:31:16.787] - relay: TRUE
[15:31:16.788] - stdout: TRUE
[15:31:16.788] - signal: TRUE
[15:31:16.788] - resignal: FALSE
[15:31:16.788] - force: TRUE
[15:31:16.788] - relayed: [n=2] FALSE, FALSE
[15:31:16.788] - queued futures: [n=2] FALSE, FALSE
[15:31:16.789]  - until=1
[15:31:16.789]  - relaying element #1
[15:31:16.789] result() for ClusterFuture ...
[15:31:16.789] - result already collected: FutureResult
[15:31:16.789] result() for ClusterFuture ... done
[15:31:16.789] result() for ClusterFuture ...
[15:31:16.790] - result already collected: FutureResult
[15:31:16.790] result() for ClusterFuture ... done
[15:31:16.790] result() for ClusterFuture ...
[15:31:16.790] - result already collected: FutureResult
[15:31:16.790] result() for ClusterFuture ... done
[15:31:16.790] result() for ClusterFuture ...
[15:31:16.791] - result already collected: FutureResult
[15:31:16.791] result() for ClusterFuture ... done
[15:31:16.791] - relayed: [n=2] TRUE, FALSE
[15:31:16.791] - queued futures: [n=2] TRUE, FALSE
[15:31:16.791] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:31:16.791]  length: 1 (resolved future 1)
[15:31:16.792] Future #2
[15:31:16.792] result() for ClusterFuture ...
[15:31:16.792] - result already collected: FutureResult
[15:31:16.792] result() for ClusterFuture ... done
[15:31:16.792] result() for ClusterFuture ...
[15:31:16.793] - result already collected: FutureResult
[15:31:16.793] result() for ClusterFuture ... done
[15:31:16.793] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:31:16.793] - nx: 2
[15:31:16.793] - relay: TRUE
[15:31:16.793] - stdout: TRUE
[15:31:16.794] - signal: TRUE
[15:31:16.794] - resignal: FALSE
[15:31:16.794] - force: TRUE
[15:31:16.794] - relayed: [n=2] TRUE, FALSE
[15:31:16.794] - queued futures: [n=2] TRUE, FALSE
[15:31:16.794]  - until=2
[15:31:16.794]  - relaying element #2
[15:31:16.795] result() for ClusterFuture ...
[15:31:16.795] - result already collected: FutureResult
[15:31:16.795] result() for ClusterFuture ... done
[15:31:16.795] result() for ClusterFuture ...
[15:31:16.795] - result already collected: FutureResult
[15:31:16.796] result() for ClusterFuture ... done
[15:31:16.796] result() for ClusterFuture ...
[15:31:16.796] - result already collected: FutureResult
[15:31:16.796] result() for ClusterFuture ... done
[15:31:16.796] result() for ClusterFuture ...
[15:31:16.796] - result already collected: FutureResult
[15:31:16.797] result() for ClusterFuture ... done
[15:31:16.797] - relayed: [n=2] TRUE, TRUE
[15:31:16.797] - queued futures: [n=2] TRUE, TRUE
[15:31:16.797] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:31:16.797]  length: 0 (resolved future 2)
[15:31:16.797] Relaying remaining futures
[15:31:16.798] signalConditionsASAP(NULL, pos=0) ...
[15:31:16.798] - nx: 2
[15:31:16.798] - relay: TRUE
[15:31:16.798] - stdout: TRUE
[15:31:16.798] - signal: TRUE
[15:31:16.798] - resignal: FALSE
[15:31:16.798] - force: TRUE
[15:31:16.799] - relayed: [n=2] TRUE, TRUE
[15:31:16.799] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:31:16.799] - relayed: [n=2] TRUE, TRUE
[15:31:16.799] - queued futures: [n=2] TRUE, TRUE
[15:31:16.799] signalConditionsASAP(NULL, pos=0) ... done
[15:31:16.800] resolve() on list ... DONE
[15:31:16.800] result() for ClusterFuture ...
[15:31:16.800] - result already collected: FutureResult
[15:31:16.800] result() for ClusterFuture ... done
[15:31:16.800] result() for ClusterFuture ...
[15:31:16.800] - result already collected: FutureResult
[15:31:16.801] result() for ClusterFuture ... done
[15:31:16.801] result() for ClusterFuture ...
[15:31:16.801] - result already collected: FutureResult
[15:31:16.801] result() for ClusterFuture ... done
[15:31:16.801] result() for ClusterFuture ...
[15:31:16.801] - result already collected: FutureResult
[15:31:16.802] result() for ClusterFuture ... done
[15:31:16.802]  - Number of value chunks collected: 2
[15:31:16.802] Resolving 2 futures (chunks) ... DONE
[15:31:16.802] Reducing values from 2 chunks ...
[15:31:16.802]  - Number of values collected after concatenation: 3
[15:31:16.802]  - Number of values expected: 3
[15:31:16.803] Reducing values from 2 chunks ... DONE
[15:31:16.803] future_lapply() ... DONE
[15:31:16.803] future_lapply() ...
[15:31:16.807] Number of chunks: 2
[15:31:16.807] getGlobalsAndPackagesXApply() ...
[15:31:16.807]  - future.globals: TRUE
[15:31:16.807] getGlobalsAndPackages() ...
[15:31:16.808] Searching for globals...
[15:31:16.809] - globals found: [2] 'FUN', 'UseMethod'
[15:31:16.809] Searching for globals ... DONE
[15:31:16.809] Resolving globals: FALSE
[15:31:16.810] The total size of the 1 globals is 1.22 KiB (1248 bytes)
[15:31:16.810] The total size of the 1 globals exported for future expression ('FUN()') 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:16.811] - globals: [1] 'FUN'
[15:31:16.811] - packages: [1] 'stats'
[15:31:16.811] getGlobalsAndPackages() ... DONE
[15:31:16.812]  - globals found/used: [n=1] 'FUN'
[15:31:16.812]  - needed namespaces: [n=1] 'stats'
[15:31:16.812] Finding globals ... DONE
[15:31:16.813]  - use_args: TRUE
[15:31:16.813]  - Getting '...' globals ...
[15:31:16.814] resolve() on list ...
[15:31:16.814]  recursive: 0
[15:31:16.814]  length: 1
[15:31:16.815]  elements: '...'
[15:31:16.815]  length: 0 (resolved future 1)
[15:31:16.815] resolve() on list ... DONE
[15:31:16.816]    - '...' content: [n=0] 
[15:31:16.816] List of 1
[15:31:16.816]  $ ...: list()
[15:31:16.816]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:16.816]  - attr(*, "where")=List of 1
[15:31:16.816]   ..$ ...:<environment: 0x000001b3fceab6b8> 
[15:31:16.816]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:16.816]  - attr(*, "resolved")= logi TRUE
[15:31:16.816]  - attr(*, "total_size")= num NA
[15:31:16.821]  - Getting '...' globals ... DONE
[15:31:16.821] Globals to be used in all futures (chunks): [n=2] '...future.FUN', '...'
[15:31:16.822] List of 2
[15:31:16.822]  $ ...future.FUN:function (x, ...)  
[15:31:16.822]  $ ...          : list()
[15:31:16.822]   ..- attr(*, "class")= chr [1:2] "DotDotDotList" "list"
[15:31:16.822]  - attr(*, "where")=List of 2
[15:31:16.822]   ..$ ...future.FUN:<environment: R_EmptyEnv> 
[15:31:16.822]   ..$ ...          :<environment: 0x000001b3fceab6b8> 
[15:31:16.822]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[15:31:16.822]  - attr(*, "resolved")= logi FALSE
[15:31:16.822]  - attr(*, "total_size")= num 1248
[15:31:16.827] Packages to be attached in all futures: [n=1] 'stats'
[15:31:16.827] getGlobalsAndPackagesXApply() ... DONE
[15:31:16.828] Number of futures (= number of chunks): 2
[15:31:16.828] Launching 2 futures (chunks) ...
[15:31:16.828] Chunk #1 of 2 ...
[15:31:16.829]  - Finding globals in 'X' for chunk #1 ...
[15:31:16.829] getGlobalsAndPackages() ...
[15:31:16.829] Searching for globals...
[15:31:16.830] 
[15:31:16.830] Searching for globals ... DONE
[15:31:16.830] - globals: [0] <none>
[15:31:16.831] getGlobalsAndPackages() ... DONE
[15:31:16.831]    + additional globals found: [n=0] 
[15:31:16.831]    + additional namespaces needed: [n=0] 
[15:31:16.831]  - Finding globals in 'X' for chunk #1 ... DONE
[15:31:16.832]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:31:16.832]  - seeds: <none>
[15:31:16.832]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:16.833] getGlobalsAndPackages() ...
[15:31:16.833] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:16.833] Resolving globals: FALSE
[15:31:16.833] Tweak future expression to call with '...' arguments ...
[15:31:16.834] {
[15:31:16.834]     do.call(function(...) {
[15:31:16.834]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:16.834]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:16.834]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:16.834]             on.exit(options(oopts), add = TRUE)
[15:31:16.834]         }
[15:31:16.834]         {
[15:31:16.834]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:16.834]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:16.834]                 ...future.FUN(...future.X_jj, ...)
[15:31:16.834]             })
[15:31:16.834]         }
[15:31:16.834]     }, args = future.call.arguments)
[15:31:16.834] }
[15:31:16.835] Tweak future expression to call with '...' arguments ... DONE
[15:31:16.836] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:16.836] - packages: [1] 'stats'
[15:31:16.836] getGlobalsAndPackages() ... DONE
[15:31:16.837] run() for 'Future' ...
[15:31:16.837] - state: 'created'
[15:31:16.838] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:16.857] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:16.858] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:31:16.858]   - Field: 'node'
[15:31:16.858]   - Field: 'label'
[15:31:16.859]   - Field: 'local'
[15:31:16.859]   - Field: 'owner'
[15:31:16.859]   - Field: 'envir'
[15:31:16.860]   - Field: 'workers'
[15:31:16.860]   - Field: 'packages'
[15:31:16.860]   - Field: 'gc'
[15:31:16.861]   - Field: 'conditions'
[15:31:16.861]   - Field: 'persistent'
[15:31:16.861]   - Field: 'expr'
[15:31:16.862]   - Field: 'uuid'
[15:31:16.862]   - Field: 'seed'
[15:31:16.862]   - Field: 'version'
[15:31:16.862]   - Field: 'result'
[15:31:16.863]   - Field: 'asynchronous'
[15:31:16.863]   - Field: 'calls'
[15:31:16.863]   - Field: 'globals'
[15:31:16.864]   - Field: 'stdout'
[15:31:16.864]   - Field: 'earlySignal'
[15:31:16.864]   - Field: 'lazy'
[15:31:16.865]   - Field: 'state'
[15:31:16.865] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:31:16.865] - Launch lazy future ...
[15:31:16.866] Packages needed by the future expression (n = 1): 'stats'
[15:31:16.866] Packages needed by future strategies (n = 0): <none>
[15:31:16.868] {
[15:31:16.868]     {
[15:31:16.868]         {
[15:31:16.868]             ...future.startTime <- base::Sys.time()
[15:31:16.868]             {
[15:31:16.868]                 {
[15:31:16.868]                   {
[15:31:16.868]                     {
[15:31:16.868]                       {
[15:31:16.868]                         base::local({
[15:31:16.868]                           has_future <- base::requireNamespace("future", 
[15:31:16.868]                             quietly = TRUE)
[15:31:16.868]                           if (has_future) {
[15:31:16.868]                             ns <- base::getNamespace("future")
[15:31:16.868]                             version <- ns[[".package"]][["version"]]
[15:31:16.868]                             if (is.null(version)) 
[15:31:16.868]                               version <- utils::packageVersion("future")
[15:31:16.868]                           }
[15:31:16.868]                           else {
[15:31:16.868]                             version <- NULL
[15:31:16.868]                           }
[15:31:16.868]                           if (!has_future || version < "1.8.0") {
[15:31:16.868]                             info <- base::c(r_version = base::gsub("R version ", 
[15:31:16.868]                               "", base::R.version$version.string), 
[15:31:16.868]                               platform = base::sprintf("%s (%s-bit)", 
[15:31:16.868]                                 base::R.version$platform, 8 * 
[15:31:16.868]                                   base::.Machine$sizeof.pointer), 
[15:31:16.868]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:16.868]                                 "release", "version")], collapse = " "), 
[15:31:16.868]                               hostname = base::Sys.info()[["nodename"]])
[15:31:16.868]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:31:16.868]                               info)
[15:31:16.868]                             info <- base::paste(info, collapse = "; ")
[15:31:16.868]                             if (!has_future) {
[15:31:16.868]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:16.868]                                 info)
[15:31:16.868]                             }
[15:31:16.868]                             else {
[15:31:16.868]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:16.868]                                 info, version)
[15:31:16.868]                             }
[15:31:16.868]                             base::stop(msg)
[15:31:16.868]                           }
[15:31:16.868]                         })
[15:31:16.868]                       }
[15:31:16.868]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:16.868]                       base::options(mc.cores = 1L)
[15:31:16.868]                     }
[15:31:16.868]                     base::local({
[15:31:16.868]                       for (pkg in "stats") {
[15:31:16.868]                         base::loadNamespace(pkg)
[15:31:16.868]                         base::library(pkg, character.only = TRUE)
[15:31:16.868]                       }
[15:31:16.868]                     })
[15:31:16.868]                   }
[15:31:16.868]                   ...future.strategy.old <- future::plan("list")
[15:31:16.868]                   options(future.plan = NULL)
[15:31:16.868]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:16.868]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:16.868]                 }
[15:31:16.868]                 ...future.workdir <- getwd()
[15:31:16.868]             }
[15:31:16.868]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:16.868]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:16.868]         }
[15:31:16.868]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:16.868]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:31:16.868]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:16.868]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:16.868]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:16.868]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:16.868]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:16.868]             base::names(...future.oldOptions))
[15:31:16.868]     }
[15:31:16.868]     if (FALSE) {
[15:31:16.868]     }
[15:31:16.868]     else {
[15:31:16.868]         if (TRUE) {
[15:31:16.868]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:16.868]                 open = "w")
[15:31:16.868]         }
[15:31:16.868]         else {
[15:31:16.868]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:16.868]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:16.868]         }
[15:31:16.868]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:16.868]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:16.868]             base::sink(type = "output", split = FALSE)
[15:31:16.868]             base::close(...future.stdout)
[15:31:16.868]         }, add = TRUE)
[15:31:16.868]     }
[15:31:16.868]     ...future.frame <- base::sys.nframe()
[15:31:16.868]     ...future.conditions <- base::list()
[15:31:16.868]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:16.868]     if (FALSE) {
[15:31:16.868]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:16.868]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:16.868]     }
[15:31:16.868]     ...future.result <- base::tryCatch({
[15:31:16.868]         base::withCallingHandlers({
[15:31:16.868]             ...future.value <- base::withVisible(base::local({
[15:31:16.868]                 ...future.makeSendCondition <- base::local({
[15:31:16.868]                   sendCondition <- NULL
[15:31:16.868]                   function(frame = 1L) {
[15:31:16.868]                     if (is.function(sendCondition)) 
[15:31:16.868]                       return(sendCondition)
[15:31:16.868]                     ns <- getNamespace("parallel")
[15:31:16.868]                     if (exists("sendData", mode = "function", 
[15:31:16.868]                       envir = ns)) {
[15:31:16.868]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:16.868]                         envir = ns)
[15:31:16.868]                       envir <- sys.frame(frame)
[15:31:16.868]                       master <- NULL
[15:31:16.868]                       while (!identical(envir, .GlobalEnv) && 
[15:31:16.868]                         !identical(envir, emptyenv())) {
[15:31:16.868]                         if (exists("master", mode = "list", envir = envir, 
[15:31:16.868]                           inherits = FALSE)) {
[15:31:16.868]                           master <- get("master", mode = "list", 
[15:31:16.868]                             envir = envir, inherits = FALSE)
[15:31:16.868]                           if (inherits(master, c("SOCKnode", 
[15:31:16.868]                             "SOCK0node"))) {
[15:31:16.868]                             sendCondition <<- function(cond) {
[15:31:16.868]                               data <- list(type = "VALUE", value = cond, 
[15:31:16.868]                                 success = TRUE)
[15:31:16.868]                               parallel_sendData(master, data)
[15:31:16.868]                             }
[15:31:16.868]                             return(sendCondition)
[15:31:16.868]                           }
[15:31:16.868]                         }
[15:31:16.868]                         frame <- frame + 1L
[15:31:16.868]                         envir <- sys.frame(frame)
[15:31:16.868]                       }
[15:31:16.868]                     }
[15:31:16.868]                     sendCondition <<- function(cond) NULL
[15:31:16.868]                   }
[15:31:16.868]                 })
[15:31:16.868]                 withCallingHandlers({
[15:31:16.868]                   {
[15:31:16.868]                     do.call(function(...) {
[15:31:16.868]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:16.868]                       if (!identical(...future.globals.maxSize.org, 
[15:31:16.868]                         ...future.globals.maxSize)) {
[15:31:16.868]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:16.868]                         on.exit(options(oopts), add = TRUE)
[15:31:16.868]                       }
[15:31:16.868]                       {
[15:31:16.868]                         lapply(seq_along(...future.elements_ii), 
[15:31:16.868]                           FUN = function(jj) {
[15:31:16.868]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:16.868]                             ...future.FUN(...future.X_jj, ...)
[15:31:16.868]                           })
[15:31:16.868]                       }
[15:31:16.868]                     }, args = future.call.arguments)
[15:31:16.868]                   }
[15:31:16.868]                 }, immediateCondition = function(cond) {
[15:31:16.868]                   sendCondition <- ...future.makeSendCondition()
[15:31:16.868]                   sendCondition(cond)
[15:31:16.868]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:16.868]                   {
[15:31:16.868]                     inherits <- base::inherits
[15:31:16.868]                     invokeRestart <- base::invokeRestart
[15:31:16.868]                     is.null <- base::is.null
[15:31:16.868]                     muffled <- FALSE
[15:31:16.868]                     if (inherits(cond, "message")) {
[15:31:16.868]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:16.868]                       if (muffled) 
[15:31:16.868]                         invokeRestart("muffleMessage")
[15:31:16.868]                     }
[15:31:16.868]                     else if (inherits(cond, "warning")) {
[15:31:16.868]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:16.868]                       if (muffled) 
[15:31:16.868]                         invokeRestart("muffleWarning")
[15:31:16.868]                     }
[15:31:16.868]                     else if (inherits(cond, "condition")) {
[15:31:16.868]                       if (!is.null(pattern)) {
[15:31:16.868]                         computeRestarts <- base::computeRestarts
[15:31:16.868]                         grepl <- base::grepl
[15:31:16.868]                         restarts <- computeRestarts(cond)
[15:31:16.868]                         for (restart in restarts) {
[15:31:16.868]                           name <- restart$name
[15:31:16.868]                           if (is.null(name)) 
[15:31:16.868]                             next
[15:31:16.868]                           if (!grepl(pattern, name)) 
[15:31:16.868]                             next
[15:31:16.868]                           invokeRestart(restart)
[15:31:16.868]                           muffled <- TRUE
[15:31:16.868]                           break
[15:31:16.868]                         }
[15:31:16.868]                       }
[15:31:16.868]                     }
[15:31:16.868]                     invisible(muffled)
[15:31:16.868]                   }
[15:31:16.868]                   muffleCondition(cond)
[15:31:16.868]                 })
[15:31:16.868]             }))
[15:31:16.868]             future::FutureResult(value = ...future.value$value, 
[15:31:16.868]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:16.868]                   ...future.rng), globalenv = if (FALSE) 
[15:31:16.868]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:16.868]                     ...future.globalenv.names))
[15:31:16.868]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:16.868]         }, condition = base::local({
[15:31:16.868]             c <- base::c
[15:31:16.868]             inherits <- base::inherits
[15:31:16.868]             invokeRestart <- base::invokeRestart
[15:31:16.868]             length <- base::length
[15:31:16.868]             list <- base::list
[15:31:16.868]             seq.int <- base::seq.int
[15:31:16.868]             signalCondition <- base::signalCondition
[15:31:16.868]             sys.calls <- base::sys.calls
[15:31:16.868]             `[[` <- base::`[[`
[15:31:16.868]             `+` <- base::`+`
[15:31:16.868]             `<<-` <- base::`<<-`
[15:31:16.868]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:16.868]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:16.868]                   3L)]
[15:31:16.868]             }
[15:31:16.868]             function(cond) {
[15:31:16.868]                 is_error <- inherits(cond, "error")
[15:31:16.868]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:16.868]                   NULL)
[15:31:16.868]                 if (is_error) {
[15:31:16.868]                   sessionInformation <- function() {
[15:31:16.868]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:16.868]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:16.868]                       search = base::search(), system = base::Sys.info())
[15:31:16.868]                   }
[15:31:16.868]                   ...future.conditions[[length(...future.conditions) + 
[15:31:16.868]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:16.868]                     cond$call), session = sessionInformation(), 
[15:31:16.868]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:16.868]                   signalCondition(cond)
[15:31:16.868]                 }
[15:31:16.868]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:16.868]                 "immediateCondition"))) {
[15:31:16.868]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:16.868]                   ...future.conditions[[length(...future.conditions) + 
[15:31:16.868]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:16.868]                   if (TRUE && !signal) {
[15:31:16.868]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:16.868]                     {
[15:31:16.868]                       inherits <- base::inherits
[15:31:16.868]                       invokeRestart <- base::invokeRestart
[15:31:16.868]                       is.null <- base::is.null
[15:31:16.868]                       muffled <- FALSE
[15:31:16.868]                       if (inherits(cond, "message")) {
[15:31:16.868]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:16.868]                         if (muffled) 
[15:31:16.868]                           invokeRestart("muffleMessage")
[15:31:16.868]                       }
[15:31:16.868]                       else if (inherits(cond, "warning")) {
[15:31:16.868]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:16.868]                         if (muffled) 
[15:31:16.868]                           invokeRestart("muffleWarning")
[15:31:16.868]                       }
[15:31:16.868]                       else if (inherits(cond, "condition")) {
[15:31:16.868]                         if (!is.null(pattern)) {
[15:31:16.868]                           computeRestarts <- base::computeRestarts
[15:31:16.868]                           grepl <- base::grepl
[15:31:16.868]                           restarts <- computeRestarts(cond)
[15:31:16.868]                           for (restart in restarts) {
[15:31:16.868]                             name <- restart$name
[15:31:16.868]                             if (is.null(name)) 
[15:31:16.868]                               next
[15:31:16.868]                             if (!grepl(pattern, name)) 
[15:31:16.868]                               next
[15:31:16.868]                             invokeRestart(restart)
[15:31:16.868]                             muffled <- TRUE
[15:31:16.868]                             break
[15:31:16.868]                           }
[15:31:16.868]                         }
[15:31:16.868]                       }
[15:31:16.868]                       invisible(muffled)
[15:31:16.868]                     }
[15:31:16.868]                     muffleCondition(cond, pattern = "^muffle")
[15:31:16.868]                   }
[15:31:16.868]                 }
[15:31:16.868]                 else {
[15:31:16.868]                   if (TRUE) {
[15:31:16.868]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:16.868]                     {
[15:31:16.868]                       inherits <- base::inherits
[15:31:16.868]                       invokeRestart <- base::invokeRestart
[15:31:16.868]                       is.null <- base::is.null
[15:31:16.868]                       muffled <- FALSE
[15:31:16.868]                       if (inherits(cond, "message")) {
[15:31:16.868]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:16.868]                         if (muffled) 
[15:31:16.868]                           invokeRestart("muffleMessage")
[15:31:16.868]                       }
[15:31:16.868]                       else if (inherits(cond, "warning")) {
[15:31:16.868]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:16.868]                         if (muffled) 
[15:31:16.868]                           invokeRestart("muffleWarning")
[15:31:16.868]                       }
[15:31:16.868]                       else if (inherits(cond, "condition")) {
[15:31:16.868]                         if (!is.null(pattern)) {
[15:31:16.868]                           computeRestarts <- base::computeRestarts
[15:31:16.868]                           grepl <- base::grepl
[15:31:16.868]                           restarts <- computeRestarts(cond)
[15:31:16.868]                           for (restart in restarts) {
[15:31:16.868]                             name <- restart$name
[15:31:16.868]                             if (is.null(name)) 
[15:31:16.868]                               next
[15:31:16.868]                             if (!grepl(pattern, name)) 
[15:31:16.868]                               next
[15:31:16.868]                             invokeRestart(restart)
[15:31:16.868]                             muffled <- TRUE
[15:31:16.868]                             break
[15:31:16.868]                           }
[15:31:16.868]                         }
[15:31:16.868]                       }
[15:31:16.868]                       invisible(muffled)
[15:31:16.868]                     }
[15:31:16.868]                     muffleCondition(cond, pattern = "^muffle")
[15:31:16.868]                   }
[15:31:16.868]                 }
[15:31:16.868]             }
[15:31:16.868]         }))
[15:31:16.868]     }, error = function(ex) {
[15:31:16.868]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:16.868]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:16.868]                 ...future.rng), started = ...future.startTime, 
[15:31:16.868]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:16.868]             version = "1.8"), class = "FutureResult")
[15:31:16.868]     }, finally = {
[15:31:16.868]         if (!identical(...future.workdir, getwd())) 
[15:31:16.868]             setwd(...future.workdir)
[15:31:16.868]         {
[15:31:16.868]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:16.868]                 ...future.oldOptions$nwarnings <- NULL
[15:31:16.868]             }
[15:31:16.868]             base::options(...future.oldOptions)
[15:31:16.868]             if (.Platform$OS.type == "windows") {
[15:31:16.868]                 old_names <- names(...future.oldEnvVars)
[15:31:16.868]                 envs <- base::Sys.getenv()
[15:31:16.868]                 names <- names(envs)
[15:31:16.868]                 common <- intersect(names, old_names)
[15:31:16.868]                 added <- setdiff(names, old_names)
[15:31:16.868]                 removed <- setdiff(old_names, names)
[15:31:16.868]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:16.868]                   envs[common]]
[15:31:16.868]                 NAMES <- toupper(changed)
[15:31:16.868]                 args <- list()
[15:31:16.868]                 for (kk in seq_along(NAMES)) {
[15:31:16.868]                   name <- changed[[kk]]
[15:31:16.868]                   NAME <- NAMES[[kk]]
[15:31:16.868]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:16.868]                     next
[15:31:16.868]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:16.868]                 }
[15:31:16.868]                 NAMES <- toupper(added)
[15:31:16.868]                 for (kk in seq_along(NAMES)) {
[15:31:16.868]                   name <- added[[kk]]
[15:31:16.868]                   NAME <- NAMES[[kk]]
[15:31:16.868]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:16.868]                     next
[15:31:16.868]                   args[[name]] <- ""
[15:31:16.868]                 }
[15:31:16.868]                 NAMES <- toupper(removed)
[15:31:16.868]                 for (kk in seq_along(NAMES)) {
[15:31:16.868]                   name <- removed[[kk]]
[15:31:16.868]                   NAME <- NAMES[[kk]]
[15:31:16.868]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:16.868]                     next
[15:31:16.868]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:16.868]                 }
[15:31:16.868]                 if (length(args) > 0) 
[15:31:16.868]                   base::do.call(base::Sys.setenv, args = args)
[15:31:16.868]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:16.868]             }
[15:31:16.868]             else {
[15:31:16.868]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:16.868]             }
[15:31:16.868]             {
[15:31:16.868]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:16.868]                   0L) {
[15:31:16.868]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:16.868]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:16.868]                   base::options(opts)
[15:31:16.868]                 }
[15:31:16.868]                 {
[15:31:16.868]                   {
[15:31:16.868]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:16.868]                     NULL
[15:31:16.868]                   }
[15:31:16.868]                   options(future.plan = NULL)
[15:31:16.868]                   if (is.na(NA_character_)) 
[15:31:16.868]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:16.868]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:16.868]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:16.868]                     .init = FALSE)
[15:31:16.868]                 }
[15:31:16.868]             }
[15:31:16.868]         }
[15:31:16.868]     })
[15:31:16.868]     if (TRUE) {
[15:31:16.868]         base::sink(type = "output", split = FALSE)
[15:31:16.868]         if (TRUE) {
[15:31:16.868]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:16.868]         }
[15:31:16.868]         else {
[15:31:16.868]             ...future.result["stdout"] <- base::list(NULL)
[15:31:16.868]         }
[15:31:16.868]         base::close(...future.stdout)
[15:31:16.868]         ...future.stdout <- NULL
[15:31:16.868]     }
[15:31:16.868]     ...future.result$conditions <- ...future.conditions
[15:31:16.868]     ...future.result$finished <- base::Sys.time()
[15:31:16.868]     ...future.result
[15:31:16.868] }
[15:31:16.878] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:31:16.878] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:31:16.879] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:31:16.880] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:31:16.880] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:31:16.880] Exporting '...future.elements_ii' (64 bytes) to cluster node #1 ...
[15:31:16.881] Exporting '...future.elements_ii' (64 bytes) to cluster node #1 ... DONE
[15:31:16.881] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:31:16.882] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:31:16.882] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:31:16.883] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:31:16.883] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:31:16.884] MultisessionFuture started
[15:31:16.884] - Launch lazy future ... done
[15:31:16.884] run() for 'MultisessionFuture' ... done
[15:31:16.885] Created future:
[15:31:16.909] receiveMessageFromWorker() for ClusterFuture ...
[15:31:16.910] - Validating connection of MultisessionFuture
[15:31:16.910] - received message: FutureResult
[15:31:16.910] - Received FutureResult
[15:31:16.911] - Erased future from FutureRegistry
[15:31:16.911] result() for ClusterFuture ...
[15:31:16.911] - result already collected: FutureResult
[15:31:16.912] result() for ClusterFuture ... done
[15:31:16.912] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:16.885] MultisessionFuture:
[15:31:16.885] Label: 'future_eapply-1'
[15:31:16.885] Expression:
[15:31:16.885] {
[15:31:16.885]     do.call(function(...) {
[15:31:16.885]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:16.885]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:16.885]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:16.885]             on.exit(options(oopts), add = TRUE)
[15:31:16.885]         }
[15:31:16.885]         {
[15:31:16.885]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:16.885]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:16.885]                 ...future.FUN(...future.X_jj, ...)
[15:31:16.885]             })
[15:31:16.885]         }
[15:31:16.885]     }, args = future.call.arguments)
[15:31:16.885] }
[15:31:16.885] Lazy evaluation: FALSE
[15:31:16.885] Asynchronous evaluation: TRUE
[15:31:16.885] Local evaluation: TRUE
[15:31:16.885] Environment: R_GlobalEnv
[15:31:16.885] Capture standard output: TRUE
[15:31:16.885] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:16.885] Globals: 5 objects totaling 1.28 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 64 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:31:16.885] Packages: 1 packages ('stats')
[15:31:16.885] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:16.885] Resolved: TRUE
[15:31:16.885] Value: <not collected>
[15:31:16.885] Conditions captured: <none>
[15:31:16.885] Early signaling: FALSE
[15:31:16.885] Owner process: 1f501b3c-5bdf-35ad-4a62-196ce98a2fc6
[15:31:16.885] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:16.913] Chunk #1 of 2 ... DONE
[15:31:16.913] Chunk #2 of 2 ...
[15:31:16.913]  - Finding globals in 'X' for chunk #2 ...
[15:31:16.913] getGlobalsAndPackages() ...
[15:31:16.914] Searching for globals...
[15:31:16.914] 
[15:31:16.915] Searching for globals ... DONE
[15:31:16.915] - globals: [0] <none>
[15:31:16.915] getGlobalsAndPackages() ... DONE
[15:31:16.915]    + additional globals found: [n=0] 
[15:31:16.916]    + additional namespaces needed: [n=0] 
[15:31:16.916]  - Finding globals in 'X' for chunk #2 ... DONE
[15:31:16.916]  - Adjusted option 'future.globals.maxSize': 524288000 -> 2 * 524288000 = 1048576000 (bytes)
[15:31:16.916]  - seeds: <none>
[15:31:16.917]  - All globals exported: [n=5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:16.917] getGlobalsAndPackages() ...
[15:31:16.917] - globals passed as-is: [5] '...future.FUN', '...', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:16.918] Resolving globals: FALSE
[15:31:16.918] Tweak future expression to call with '...' arguments ...
[15:31:16.918] {
[15:31:16.918]     do.call(function(...) {
[15:31:16.918]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:16.918]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:16.918]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:16.918]             on.exit(options(oopts), add = TRUE)
[15:31:16.918]         }
[15:31:16.918]         {
[15:31:16.918]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:16.918]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:16.918]                 ...future.FUN(...future.X_jj, ...)
[15:31:16.918]             })
[15:31:16.918]         }
[15:31:16.918]     }, args = future.call.arguments)
[15:31:16.918] }
[15:31:16.919] Tweak future expression to call with '...' arguments ... DONE
[15:31:16.920] - globals: [5] '...future.FUN', 'future.call.arguments', '...future.elements_ii', '...future.seeds_ii', '...future.globals.maxSize'
[15:31:16.920] - packages: [1] 'stats'
[15:31:16.920] getGlobalsAndPackages() ... DONE
[15:31:16.921] run() for 'Future' ...
[15:31:16.921] - state: 'created'
[15:31:16.922] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[15:31:16.944] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:16.945] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[15:31:16.945]   - Field: 'node'
[15:31:16.945]   - Field: 'label'
[15:31:16.946]   - Field: 'local'
[15:31:16.946]   - Field: 'owner'
[15:31:16.946]   - Field: 'envir'
[15:31:16.947]   - Field: 'workers'
[15:31:16.947]   - Field: 'packages'
[15:31:16.947]   - Field: 'gc'
[15:31:16.948]   - Field: 'conditions'
[15:31:16.948]   - Field: 'persistent'
[15:31:16.948]   - Field: 'expr'
[15:31:16.948]   - Field: 'uuid'
[15:31:16.949]   - Field: 'seed'
[15:31:16.949]   - Field: 'version'
[15:31:16.949]   - Field: 'result'
[15:31:16.950]   - Field: 'asynchronous'
[15:31:16.950]   - Field: 'calls'
[15:31:16.950]   - Field: 'globals'
[15:31:16.950]   - Field: 'stdout'
[15:31:16.951]   - Field: 'earlySignal'
[15:31:16.951]   - Field: 'lazy'
[15:31:16.951]   - Field: 'state'
[15:31:16.952] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[15:31:16.952] - Launch lazy future ...
[15:31:16.953] Packages needed by the future expression (n = 1): 'stats'
[15:31:16.953] Packages needed by future strategies (n = 0): <none>
[15:31:16.954] {
[15:31:16.954]     {
[15:31:16.954]         {
[15:31:16.954]             ...future.startTime <- base::Sys.time()
[15:31:16.954]             {
[15:31:16.954]                 {
[15:31:16.954]                   {
[15:31:16.954]                     {
[15:31:16.954]                       {
[15:31:16.954]                         base::local({
[15:31:16.954]                           has_future <- base::requireNamespace("future", 
[15:31:16.954]                             quietly = TRUE)
[15:31:16.954]                           if (has_future) {
[15:31:16.954]                             ns <- base::getNamespace("future")
[15:31:16.954]                             version <- ns[[".package"]][["version"]]
[15:31:16.954]                             if (is.null(version)) 
[15:31:16.954]                               version <- utils::packageVersion("future")
[15:31:16.954]                           }
[15:31:16.954]                           else {
[15:31:16.954]                             version <- NULL
[15:31:16.954]                           }
[15:31:16.954]                           if (!has_future || version < "1.8.0") {
[15:31:16.954]                             info <- base::c(r_version = base::gsub("R version ", 
[15:31:16.954]                               "", base::R.version$version.string), 
[15:31:16.954]                               platform = base::sprintf("%s (%s-bit)", 
[15:31:16.954]                                 base::R.version$platform, 8 * 
[15:31:16.954]                                   base::.Machine$sizeof.pointer), 
[15:31:16.954]                               os = base::paste(base::Sys.info()[base::c("sysname", 
[15:31:16.954]                                 "release", "version")], collapse = " "), 
[15:31:16.954]                               hostname = base::Sys.info()[["nodename"]])
[15:31:16.954]                             info <- base::sprintf("%s: %s", base::names(info), 
[15:31:16.954]                               info)
[15:31:16.954]                             info <- base::paste(info, collapse = "; ")
[15:31:16.954]                             if (!has_future) {
[15:31:16.954]                               msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[15:31:16.954]                                 info)
[15:31:16.954]                             }
[15:31:16.954]                             else {
[15:31:16.954]                               msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[15:31:16.954]                                 info, version)
[15:31:16.954]                             }
[15:31:16.954]                             base::stop(msg)
[15:31:16.954]                           }
[15:31:16.954]                         })
[15:31:16.954]                       }
[15:31:16.954]                       ...future.mc.cores.old <- base::getOption("mc.cores")
[15:31:16.954]                       base::options(mc.cores = 1L)
[15:31:16.954]                     }
[15:31:16.954]                     base::local({
[15:31:16.954]                       for (pkg in "stats") {
[15:31:16.954]                         base::loadNamespace(pkg)
[15:31:16.954]                         base::library(pkg, character.only = TRUE)
[15:31:16.954]                       }
[15:31:16.954]                     })
[15:31:16.954]                   }
[15:31:16.954]                   ...future.strategy.old <- future::plan("list")
[15:31:16.954]                   options(future.plan = NULL)
[15:31:16.954]                   Sys.unsetenv("R_FUTURE_PLAN")
[15:31:16.954]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[15:31:16.954]                 }
[15:31:16.954]                 ...future.workdir <- getwd()
[15:31:16.954]             }
[15:31:16.954]             ...future.oldOptions <- base::as.list(base::.Options)
[15:31:16.954]             ...future.oldEnvVars <- base::Sys.getenv()
[15:31:16.954]         }
[15:31:16.954]         base::options(future.startup.script = FALSE, future.globals.onMissing = NULL, 
[15:31:16.954]             future.globals.maxSize = 1048576000, future.globals.method = NULL, 
[15:31:16.954]             future.globals.onMissing = NULL, future.globals.onReference = NULL, 
[15:31:16.954]             future.globals.resolve = NULL, future.resolve.recursive = NULL, 
[15:31:16.954]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[15:31:16.954]             future.stdout.windows.reencode = NULL, width = 80L)
[15:31:16.954]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[15:31:16.954]             base::names(...future.oldOptions))
[15:31:16.954]     }
[15:31:16.954]     if (FALSE) {
[15:31:16.954]     }
[15:31:16.954]     else {
[15:31:16.954]         if (TRUE) {
[15:31:16.954]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[15:31:16.954]                 open = "w")
[15:31:16.954]         }
[15:31:16.954]         else {
[15:31:16.954]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[15:31:16.954]                 windows = "NUL", "/dev/null"), open = "w")
[15:31:16.954]         }
[15:31:16.954]         base::sink(...future.stdout, type = "output", split = FALSE)
[15:31:16.954]         base::on.exit(if (!base::is.null(...future.stdout)) {
[15:31:16.954]             base::sink(type = "output", split = FALSE)
[15:31:16.954]             base::close(...future.stdout)
[15:31:16.954]         }, add = TRUE)
[15:31:16.954]     }
[15:31:16.954]     ...future.frame <- base::sys.nframe()
[15:31:16.954]     ...future.conditions <- base::list()
[15:31:16.954]     ...future.rng <- base::globalenv()$.Random.seed
[15:31:16.954]     if (FALSE) {
[15:31:16.954]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[15:31:16.954]             "...future.value", "...future.globalenv.names", ".Random.seed")
[15:31:16.954]     }
[15:31:16.954]     ...future.result <- base::tryCatch({
[15:31:16.954]         base::withCallingHandlers({
[15:31:16.954]             ...future.value <- base::withVisible(base::local({
[15:31:16.954]                 ...future.makeSendCondition <- base::local({
[15:31:16.954]                   sendCondition <- NULL
[15:31:16.954]                   function(frame = 1L) {
[15:31:16.954]                     if (is.function(sendCondition)) 
[15:31:16.954]                       return(sendCondition)
[15:31:16.954]                     ns <- getNamespace("parallel")
[15:31:16.954]                     if (exists("sendData", mode = "function", 
[15:31:16.954]                       envir = ns)) {
[15:31:16.954]                       parallel_sendData <- get("sendData", mode = "function", 
[15:31:16.954]                         envir = ns)
[15:31:16.954]                       envir <- sys.frame(frame)
[15:31:16.954]                       master <- NULL
[15:31:16.954]                       while (!identical(envir, .GlobalEnv) && 
[15:31:16.954]                         !identical(envir, emptyenv())) {
[15:31:16.954]                         if (exists("master", mode = "list", envir = envir, 
[15:31:16.954]                           inherits = FALSE)) {
[15:31:16.954]                           master <- get("master", mode = "list", 
[15:31:16.954]                             envir = envir, inherits = FALSE)
[15:31:16.954]                           if (inherits(master, c("SOCKnode", 
[15:31:16.954]                             "SOCK0node"))) {
[15:31:16.954]                             sendCondition <<- function(cond) {
[15:31:16.954]                               data <- list(type = "VALUE", value = cond, 
[15:31:16.954]                                 success = TRUE)
[15:31:16.954]                               parallel_sendData(master, data)
[15:31:16.954]                             }
[15:31:16.954]                             return(sendCondition)
[15:31:16.954]                           }
[15:31:16.954]                         }
[15:31:16.954]                         frame <- frame + 1L
[15:31:16.954]                         envir <- sys.frame(frame)
[15:31:16.954]                       }
[15:31:16.954]                     }
[15:31:16.954]                     sendCondition <<- function(cond) NULL
[15:31:16.954]                   }
[15:31:16.954]                 })
[15:31:16.954]                 withCallingHandlers({
[15:31:16.954]                   {
[15:31:16.954]                     do.call(function(...) {
[15:31:16.954]                       ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:16.954]                       if (!identical(...future.globals.maxSize.org, 
[15:31:16.954]                         ...future.globals.maxSize)) {
[15:31:16.954]                         oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:16.954]                         on.exit(options(oopts), add = TRUE)
[15:31:16.954]                       }
[15:31:16.954]                       {
[15:31:16.954]                         lapply(seq_along(...future.elements_ii), 
[15:31:16.954]                           FUN = function(jj) {
[15:31:16.954]                             ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:16.954]                             ...future.FUN(...future.X_jj, ...)
[15:31:16.954]                           })
[15:31:16.954]                       }
[15:31:16.954]                     }, args = future.call.arguments)
[15:31:16.954]                   }
[15:31:16.954]                 }, immediateCondition = function(cond) {
[15:31:16.954]                   sendCondition <- ...future.makeSendCondition()
[15:31:16.954]                   sendCondition(cond)
[15:31:16.954]                   muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:16.954]                   {
[15:31:16.954]                     inherits <- base::inherits
[15:31:16.954]                     invokeRestart <- base::invokeRestart
[15:31:16.954]                     is.null <- base::is.null
[15:31:16.954]                     muffled <- FALSE
[15:31:16.954]                     if (inherits(cond, "message")) {
[15:31:16.954]                       muffled <- grepl(pattern, "muffleMessage")
[15:31:16.954]                       if (muffled) 
[15:31:16.954]                         invokeRestart("muffleMessage")
[15:31:16.954]                     }
[15:31:16.954]                     else if (inherits(cond, "warning")) {
[15:31:16.954]                       muffled <- grepl(pattern, "muffleWarning")
[15:31:16.954]                       if (muffled) 
[15:31:16.954]                         invokeRestart("muffleWarning")
[15:31:16.954]                     }
[15:31:16.954]                     else if (inherits(cond, "condition")) {
[15:31:16.954]                       if (!is.null(pattern)) {
[15:31:16.954]                         computeRestarts <- base::computeRestarts
[15:31:16.954]                         grepl <- base::grepl
[15:31:16.954]                         restarts <- computeRestarts(cond)
[15:31:16.954]                         for (restart in restarts) {
[15:31:16.954]                           name <- restart$name
[15:31:16.954]                           if (is.null(name)) 
[15:31:16.954]                             next
[15:31:16.954]                           if (!grepl(pattern, name)) 
[15:31:16.954]                             next
[15:31:16.954]                           invokeRestart(restart)
[15:31:16.954]                           muffled <- TRUE
[15:31:16.954]                           break
[15:31:16.954]                         }
[15:31:16.954]                       }
[15:31:16.954]                     }
[15:31:16.954]                     invisible(muffled)
[15:31:16.954]                   }
[15:31:16.954]                   muffleCondition(cond)
[15:31:16.954]                 })
[15:31:16.954]             }))
[15:31:16.954]             future::FutureResult(value = ...future.value$value, 
[15:31:16.954]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:16.954]                   ...future.rng), globalenv = if (FALSE) 
[15:31:16.954]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[15:31:16.954]                     ...future.globalenv.names))
[15:31:16.954]                 else NULL, started = ...future.startTime, version = "1.8")
[15:31:16.954]         }, condition = base::local({
[15:31:16.954]             c <- base::c
[15:31:16.954]             inherits <- base::inherits
[15:31:16.954]             invokeRestart <- base::invokeRestart
[15:31:16.954]             length <- base::length
[15:31:16.954]             list <- base::list
[15:31:16.954]             seq.int <- base::seq.int
[15:31:16.954]             signalCondition <- base::signalCondition
[15:31:16.954]             sys.calls <- base::sys.calls
[15:31:16.954]             `[[` <- base::`[[`
[15:31:16.954]             `+` <- base::`+`
[15:31:16.954]             `<<-` <- base::`<<-`
[15:31:16.954]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[15:31:16.954]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[15:31:16.954]                   3L)]
[15:31:16.954]             }
[15:31:16.954]             function(cond) {
[15:31:16.954]                 is_error <- inherits(cond, "error")
[15:31:16.954]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[15:31:16.954]                   NULL)
[15:31:16.954]                 if (is_error) {
[15:31:16.954]                   sessionInformation <- function() {
[15:31:16.954]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[15:31:16.954]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[15:31:16.954]                       search = base::search(), system = base::Sys.info())
[15:31:16.954]                   }
[15:31:16.954]                   ...future.conditions[[length(...future.conditions) + 
[15:31:16.954]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[15:31:16.954]                     cond$call), session = sessionInformation(), 
[15:31:16.954]                     timestamp = base::Sys.time(), signaled = 0L)
[15:31:16.954]                   signalCondition(cond)
[15:31:16.954]                 }
[15:31:16.954]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[15:31:16.954]                 "immediateCondition"))) {
[15:31:16.954]                   signal <- TRUE && inherits(cond, "immediateCondition")
[15:31:16.954]                   ...future.conditions[[length(...future.conditions) + 
[15:31:16.954]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[15:31:16.954]                   if (TRUE && !signal) {
[15:31:16.954]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:16.954]                     {
[15:31:16.954]                       inherits <- base::inherits
[15:31:16.954]                       invokeRestart <- base::invokeRestart
[15:31:16.954]                       is.null <- base::is.null
[15:31:16.954]                       muffled <- FALSE
[15:31:16.954]                       if (inherits(cond, "message")) {
[15:31:16.954]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:16.954]                         if (muffled) 
[15:31:16.954]                           invokeRestart("muffleMessage")
[15:31:16.954]                       }
[15:31:16.954]                       else if (inherits(cond, "warning")) {
[15:31:16.954]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:16.954]                         if (muffled) 
[15:31:16.954]                           invokeRestart("muffleWarning")
[15:31:16.954]                       }
[15:31:16.954]                       else if (inherits(cond, "condition")) {
[15:31:16.954]                         if (!is.null(pattern)) {
[15:31:16.954]                           computeRestarts <- base::computeRestarts
[15:31:16.954]                           grepl <- base::grepl
[15:31:16.954]                           restarts <- computeRestarts(cond)
[15:31:16.954]                           for (restart in restarts) {
[15:31:16.954]                             name <- restart$name
[15:31:16.954]                             if (is.null(name)) 
[15:31:16.954]                               next
[15:31:16.954]                             if (!grepl(pattern, name)) 
[15:31:16.954]                               next
[15:31:16.954]                             invokeRestart(restart)
[15:31:16.954]                             muffled <- TRUE
[15:31:16.954]                             break
[15:31:16.954]                           }
[15:31:16.954]                         }
[15:31:16.954]                       }
[15:31:16.954]                       invisible(muffled)
[15:31:16.954]                     }
[15:31:16.954]                     muffleCondition(cond, pattern = "^muffle")
[15:31:16.954]                   }
[15:31:16.954]                 }
[15:31:16.954]                 else {
[15:31:16.954]                   if (TRUE) {
[15:31:16.954]                     muffleCondition <- function (cond, pattern = "^muffle") 
[15:31:16.954]                     {
[15:31:16.954]                       inherits <- base::inherits
[15:31:16.954]                       invokeRestart <- base::invokeRestart
[15:31:16.954]                       is.null <- base::is.null
[15:31:16.954]                       muffled <- FALSE
[15:31:16.954]                       if (inherits(cond, "message")) {
[15:31:16.954]                         muffled <- grepl(pattern, "muffleMessage")
[15:31:16.954]                         if (muffled) 
[15:31:16.954]                           invokeRestart("muffleMessage")
[15:31:16.954]                       }
[15:31:16.954]                       else if (inherits(cond, "warning")) {
[15:31:16.954]                         muffled <- grepl(pattern, "muffleWarning")
[15:31:16.954]                         if (muffled) 
[15:31:16.954]                           invokeRestart("muffleWarning")
[15:31:16.954]                       }
[15:31:16.954]                       else if (inherits(cond, "condition")) {
[15:31:16.954]                         if (!is.null(pattern)) {
[15:31:16.954]                           computeRestarts <- base::computeRestarts
[15:31:16.954]                           grepl <- base::grepl
[15:31:16.954]                           restarts <- computeRestarts(cond)
[15:31:16.954]                           for (restart in restarts) {
[15:31:16.954]                             name <- restart$name
[15:31:16.954]                             if (is.null(name)) 
[15:31:16.954]                               next
[15:31:16.954]                             if (!grepl(pattern, name)) 
[15:31:16.954]                               next
[15:31:16.954]                             invokeRestart(restart)
[15:31:16.954]                             muffled <- TRUE
[15:31:16.954]                             break
[15:31:16.954]                           }
[15:31:16.954]                         }
[15:31:16.954]                       }
[15:31:16.954]                       invisible(muffled)
[15:31:16.954]                     }
[15:31:16.954]                     muffleCondition(cond, pattern = "^muffle")
[15:31:16.954]                   }
[15:31:16.954]                 }
[15:31:16.954]             }
[15:31:16.954]         }))
[15:31:16.954]     }, error = function(ex) {
[15:31:16.954]         base::structure(base::list(value = NULL, visible = NULL, 
[15:31:16.954]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[15:31:16.954]                 ...future.rng), started = ...future.startTime, 
[15:31:16.954]             finished = Sys.time(), session_uuid = NA_character_, 
[15:31:16.954]             version = "1.8"), class = "FutureResult")
[15:31:16.954]     }, finally = {
[15:31:16.954]         if (!identical(...future.workdir, getwd())) 
[15:31:16.954]             setwd(...future.workdir)
[15:31:16.954]         {
[15:31:16.954]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[15:31:16.954]                 ...future.oldOptions$nwarnings <- NULL
[15:31:16.954]             }
[15:31:16.954]             base::options(...future.oldOptions)
[15:31:16.954]             if (.Platform$OS.type == "windows") {
[15:31:16.954]                 old_names <- names(...future.oldEnvVars)
[15:31:16.954]                 envs <- base::Sys.getenv()
[15:31:16.954]                 names <- names(envs)
[15:31:16.954]                 common <- intersect(names, old_names)
[15:31:16.954]                 added <- setdiff(names, old_names)
[15:31:16.954]                 removed <- setdiff(old_names, names)
[15:31:16.954]                 changed <- common[...future.oldEnvVars[common] != 
[15:31:16.954]                   envs[common]]
[15:31:16.954]                 NAMES <- toupper(changed)
[15:31:16.954]                 args <- list()
[15:31:16.954]                 for (kk in seq_along(NAMES)) {
[15:31:16.954]                   name <- changed[[kk]]
[15:31:16.954]                   NAME <- NAMES[[kk]]
[15:31:16.954]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:16.954]                     next
[15:31:16.954]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:16.954]                 }
[15:31:16.954]                 NAMES <- toupper(added)
[15:31:16.954]                 for (kk in seq_along(NAMES)) {
[15:31:16.954]                   name <- added[[kk]]
[15:31:16.954]                   NAME <- NAMES[[kk]]
[15:31:16.954]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:16.954]                     next
[15:31:16.954]                   args[[name]] <- ""
[15:31:16.954]                 }
[15:31:16.954]                 NAMES <- toupper(removed)
[15:31:16.954]                 for (kk in seq_along(NAMES)) {
[15:31:16.954]                   name <- removed[[kk]]
[15:31:16.954]                   NAME <- NAMES[[kk]]
[15:31:16.954]                   if (name != NAME && is.element(NAME, old_names)) 
[15:31:16.954]                     next
[15:31:16.954]                   args[[name]] <- ...future.oldEnvVars[[name]]
[15:31:16.954]                 }
[15:31:16.954]                 if (length(args) > 0) 
[15:31:16.954]                   base::do.call(base::Sys.setenv, args = args)
[15:31:16.954]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[15:31:16.954]             }
[15:31:16.954]             else {
[15:31:16.954]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[15:31:16.954]             }
[15:31:16.954]             {
[15:31:16.954]                 if (base::length(...future.futureOptionsAdded) > 
[15:31:16.954]                   0L) {
[15:31:16.954]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[15:31:16.954]                   base::names(opts) <- ...future.futureOptionsAdded
[15:31:16.954]                   base::options(opts)
[15:31:16.954]                 }
[15:31:16.954]                 {
[15:31:16.954]                   {
[15:31:16.954]                     base::options(mc.cores = ...future.mc.cores.old)
[15:31:16.954]                     NULL
[15:31:16.954]                   }
[15:31:16.954]                   options(future.plan = NULL)
[15:31:16.954]                   if (is.na(NA_character_)) 
[15:31:16.954]                     Sys.unsetenv("R_FUTURE_PLAN")
[15:31:16.954]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[15:31:16.954]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[15:31:16.954]                     .init = FALSE)
[15:31:16.954]                 }
[15:31:16.954]             }
[15:31:16.954]         }
[15:31:16.954]     })
[15:31:16.954]     if (TRUE) {
[15:31:16.954]         base::sink(type = "output", split = FALSE)
[15:31:16.954]         if (TRUE) {
[15:31:16.954]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[15:31:16.954]         }
[15:31:16.954]         else {
[15:31:16.954]             ...future.result["stdout"] <- base::list(NULL)
[15:31:16.954]         }
[15:31:16.954]         base::close(...future.stdout)
[15:31:16.954]         ...future.stdout <- NULL
[15:31:16.954]     }
[15:31:16.954]     ...future.result$conditions <- ...future.conditions
[15:31:16.954]     ...future.result$finished <- base::Sys.time()
[15:31:16.954]     ...future.result
[15:31:16.954] }
[15:31:16.963] Exporting 5 global objects (1.22 KiB) to cluster node #1 ...
[15:31:16.963] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ...
[15:31:16.964] Exporting '...future.FUN' (1.22 KiB) to cluster node #1 ... DONE
[15:31:16.965] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ...
[15:31:16.965] Exporting 'future.call.arguments' (0 bytes) to cluster node #1 ... DONE
[15:31:16.966] Exporting '...future.elements_ii' (208 bytes) to cluster node #1 ...
[15:31:16.966] Exporting '...future.elements_ii' (208 bytes) to cluster node #1 ... DONE
[15:31:16.967] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ...
[15:31:16.967] Exporting '...future.seeds_ii' (0 bytes) to cluster node #1 ... DONE
[15:31:16.968] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ...
[15:31:16.968] Exporting '...future.globals.maxSize' (0 bytes) to cluster node #1 ... DONE
[15:31:16.969] Exporting 5 global objects (1.22 KiB) to cluster node #1 ... DONE
[15:31:16.970] MultisessionFuture started
[15:31:16.970] - Launch lazy future ... done
[15:31:16.970] run() for 'MultisessionFuture' ... done
[15:31:16.971] Created future:
[15:31:16.997] receiveMessageFromWorker() for ClusterFuture ...
[15:31:16.997] - Validating connection of MultisessionFuture
[15:31:16.998] - received message: FutureResult
[15:31:16.998] - Received FutureResult
[15:31:16.998] - Erased future from FutureRegistry
[15:31:16.999] result() for ClusterFuture ...
[15:31:16.999] - result already collected: FutureResult
[15:31:16.999] result() for ClusterFuture ... done
[15:31:17.000] receiveMessageFromWorker() for ClusterFuture ... done
[15:31:16.971] MultisessionFuture:
[15:31:16.971] Label: 'future_eapply-2'
[15:31:16.971] Expression:
[15:31:16.971] {
[15:31:16.971]     do.call(function(...) {
[15:31:16.971]         ...future.globals.maxSize.org <- getOption("future.globals.maxSize")
[15:31:16.971]         if (!identical(...future.globals.maxSize.org, ...future.globals.maxSize)) {
[15:31:16.971]             oopts <- options(future.globals.maxSize = ...future.globals.maxSize)
[15:31:16.971]             on.exit(options(oopts), add = TRUE)
[15:31:16.971]         }
[15:31:16.971]         {
[15:31:16.971]             lapply(seq_along(...future.elements_ii), FUN = function(jj) {
[15:31:16.971]                 ...future.X_jj <- ...future.elements_ii[[jj]]
[15:31:16.971]                 ...future.FUN(...future.X_jj, ...)
[15:31:16.971]             })
[15:31:16.971]         }
[15:31:16.971]     }, args = future.call.arguments)
[15:31:16.971] }
[15:31:16.971] Lazy evaluation: FALSE
[15:31:16.971] Asynchronous evaluation: TRUE
[15:31:16.971] Local evaluation: TRUE
[15:31:16.971] Environment: R_GlobalEnv
[15:31:16.971] Capture standard output: TRUE
[15:31:16.971] Capture condition classes: 'condition' (excluding 'nothing')
[15:31:16.971] Globals: 5 objects totaling 1.42 KiB (function '...future.FUN' of 1.22 KiB, DotDotDotList 'future.call.arguments' of 0 bytes, list '...future.elements_ii' of 208 bytes, NULL '...future.seeds_ii' of 0 bytes, NULL '...future.globals.maxSize' of 0 bytes)
[15:31:16.971] Packages: 1 packages ('stats')
[15:31:16.971] L'Ecuyer-CMRG RNG seed: <none> (seed = FALSE)
[15:31:16.971] Resolved: TRUE
[15:31:16.971] Value: <not collected>
[15:31:16.971] Conditions captured: <none>
[15:31:16.971] Early signaling: FALSE
[15:31:16.971] Owner process: 1f501b3c-5bdf-35ad-4a62-196ce98a2fc6
[15:31:16.971] Class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[15:31:17.000] Chunk #2 of 2 ... DONE
[15:31:17.001] Launching 2 futures (chunks) ... DONE
[15:31:17.001] Resolving 2 futures (chunks) ...
[15:31:17.001] resolve() on list ...
[15:31:17.002]  recursive: 0
[15:31:17.002]  length: 2
[15:31:17.002] 
[15:31:17.002] Future #1
[15:31:17.003] result() for ClusterFuture ...
[15:31:17.003] - result already collected: FutureResult
[15:31:17.003] result() for ClusterFuture ... done
[15:31:17.004] result() for ClusterFuture ...
[15:31:17.004] - result already collected: FutureResult
[15:31:17.004] result() for ClusterFuture ... done
[15:31:17.004] signalConditionsASAP(MultisessionFuture, pos=1) ...
[15:31:17.005] - nx: 2
[15:31:17.005] - relay: TRUE
[15:31:17.005] - stdout: TRUE
[15:31:17.005] - signal: TRUE
[15:31:17.006] - resignal: FALSE
[15:31:17.006] - force: TRUE
[15:31:17.006] - relayed: [n=2] FALSE, FALSE
[15:31:17.006] - queued futures: [n=2] FALSE, FALSE
[15:31:17.007]  - until=1
[15:31:17.007]  - relaying element #1
[15:31:17.007] result() for ClusterFuture ...
[15:31:17.008] - result already collected: FutureResult
[15:31:17.008] result() for ClusterFuture ... done
[15:31:17.008] result() for ClusterFuture ...
[15:31:17.008] - result already collected: FutureResult
[15:31:17.009] result() for ClusterFuture ... done
[15:31:17.009] result() for ClusterFuture ...
[15:31:17.009] - result already collected: FutureResult
[15:31:17.009] result() for ClusterFuture ... done
[15:31:17.010] result() for ClusterFuture ...
[15:31:17.010] - result already collected: FutureResult
[15:31:17.010] result() for ClusterFuture ... done
[15:31:17.011] - relayed: [n=2] TRUE, FALSE
[15:31:17.011] - queued futures: [n=2] TRUE, FALSE
[15:31:17.011] signalConditionsASAP(MultisessionFuture, pos=1) ... done
[15:31:17.011]  length: 1 (resolved future 1)
[15:31:17.012] Future #2
[15:31:17.012] result() for ClusterFuture ...
[15:31:17.012] - result already collected: FutureResult
[15:31:17.013] result() for ClusterFuture ... done
[15:31:17.013] result() for ClusterFuture ...
[15:31:17.013] - result already collected: FutureResult
[15:31:17.013] result() for ClusterFuture ... done
[15:31:17.014] signalConditionsASAP(MultisessionFuture, pos=2) ...
[15:31:17.014] - nx: 2
[15:31:17.014] - relay: TRUE
[15:31:17.015] - stdout: TRUE
[15:31:17.015] - signal: TRUE
[15:31:17.015] - resignal: FALSE
[15:31:17.015] - force: TRUE
[15:31:17.016] - relayed: [n=2] TRUE, FALSE
[15:31:17.016] - queued futures: [n=2] TRUE, FALSE
[15:31:17.016]  - until=2
[15:31:17.016]  - relaying element #2
[15:31:17.017] result() for ClusterFuture ...
[15:31:17.017] - result already collected: FutureResult
[15:31:17.017] result() for ClusterFuture ... done
[15:31:17.017] result() for ClusterFuture ...
[15:31:17.018] - result already collected: FutureResult
[15:31:17.018] result() for ClusterFuture ... done
[15:31:17.018] result() for ClusterFuture ...
[15:31:17.019] - result already collected: FutureResult
[15:31:17.019] result() for ClusterFuture ... done
[15:31:17.019] result() for ClusterFuture ...
[15:31:17.019] - result already collected: FutureResult
[15:31:17.020] result() for ClusterFuture ... done
[15:31:17.020] - relayed: [n=2] TRUE, TRUE
[15:31:17.020] - queued futures: [n=2] TRUE, TRUE
[15:31:17.020] signalConditionsASAP(MultisessionFuture, pos=2) ... done
[15:31:17.021]  length: 0 (resolved future 2)
[15:31:17.021] Relaying remaining futures
[15:31:17.021] signalConditionsASAP(NULL, pos=0) ...
[15:31:17.022] - nx: 2
[15:31:17.022] - relay: TRUE
[15:31:17.022] - stdout: TRUE
[15:31:17.022] - signal: TRUE
[15:31:17.023] - resignal: FALSE
[15:31:17.023] - force: TRUE
[15:31:17.023] - relayed: [n=2] TRUE, TRUE
[15:31:17.023] - queued futures: [n=2] TRUE, TRUE
 - flush all
[15:31:17.024] - relayed: [n=2] TRUE, TRUE
[15:31:17.024] - queued futures: [n=2] TRUE, TRUE
[15:31:17.025] signalConditionsASAP(NULL, pos=0) ... done
[15:31:17.025] resolve() on list ... DONE
[15:31:17.025] result() for ClusterFuture ...
[15:31:17.025] - result already collected: FutureResult
[15:31:17.026] result() for ClusterFuture ... done
[15:31:17.026] result() for ClusterFuture ...
[15:31:17.026] - result already collected: FutureResult
[15:31:17.026] result() for ClusterFuture ... done
[15:31:17.027] result() for ClusterFuture ...
[15:31:17.027] - result already collected: FutureResult
[15:31:17.027] result() for ClusterFuture ... done
[15:31:17.028] result() for ClusterFuture ...
[15:31:17.028] - result already collected: FutureResult
[15:31:17.028] result() for ClusterFuture ... done
[15:31:17.029]  - Number of value chunks collected: 2
[15:31:17.029] Resolving 2 futures (chunks) ... DONE
[15:31:17.029] Reducing values from 2 chunks ...
[15:31:17.029]  - Number of values collected after concatenation: 3
[15:31:17.030]  - Number of values expected: 3
[15:31:17.030] Reducing values from 2 chunks ... DONE
[15:31:17.030] future_lapply() ... DONE
[15:31:17.031] plan(): Setting new future strategy stack:
[15:31:17.031] List of future strategies:
[15:31:17.031] 1. sequential:
[15:31:17.031]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:17.031]    - tweaked: FALSE
[15:31:17.031]    - call: plan(sequential)
[15:31:17.033] plan(): nbrOfWorkers() = 1
*** strategy = 'multisession' ... done
> 
> message("*** future_eapply() ... DONE")
*** future_eapply() ... DONE
> 
> source("incl/end.R")
[15:31:17.034] plan(): Setting new future strategy stack:
[15:31:17.035] List of future strategies:
[15:31:17.035] 1. FutureStrategy:
[15:31:17.035]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[15:31:17.035]    - tweaked: FALSE
[15:31:17.035]    - call: future::plan(oplan)
[15:31:17.036] plan(): nbrOfWorkers() = 1
> 
> proc.time()
   user  system elapsed 
   1.70    0.17    2.89